import test from 'node:test'; import assert from 'node:assert/strict'; import http from 'node:http'; import net from 'node:net'; import { createHash } from 'node:crypto'; import { ModelTransport } from '../src/core/models/transport.mjs'; import { Provider } from '../src/server/provider.mjs'; import { connectionFailure } from '../src/server/diagnostics.mjs'; import { Runtime } from '../src/server/runtime.mjs'; import { fixture,compatibleFixture,completion,until } from './helpers.mjs'; const config=baseUrl=>({mode:'compatible',baseUrl,model:'owned-transport',maxOutputTokens:128}); const policy={attempts:3,delays:[1,1],timeoutMs:1500,totalTimeoutMs:4000}; const lookup=(_hostname,options,callback)=>{ assert.equal(options.all,true);callback(null,[{address:'::1',family:6},{address:'127.0.0.1',family:4}]); }; test('owned IPv4 service works after a failed IPv6 candidate without a second model POST or global DNS change',async t=>{ const model=await compatibleFixture(t,()=>completion([],'Owned dual-stack result')); const url=new URL(model.baseUrl);url.hostname='owned-transport.invalid'; const transport=new ModelTransport({environment:{},lookup}),provider=new Provider({transport,retryPolicy:policy}),events=[]; t.after(()=>provider.abortRequests());const original=net.getDefaultAutoSelectFamily(); const result=await provider.complete(config(url.href),[],null,null,event=>events.push(event)); assert.equal(result.message.content,'Owned dual-stack result');assert.equal(model.requests.length,1); assert.equal(net.getDefaultAutoSelectFamily(),original);assert.ok(events.some(event=>event.transport?.autoSelectFamily)); assert.equal(provider.lastRequest.attempts,1); }); test('environment HTTP proxy tunnels the owned request and NO_PROXY sends a separate direct request',async t=>{ const model=await compatibleFixture(t,()=>completion([],'Owned proxy result')),target=new URL(model.baseUrl),sockets=new Set();let tunnels=0; const proxy=http.createServer();proxy.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));}); proxy.on('connect',(request,socket,head)=>{ assert.equal(request.url,target.host);tunnels++; const upstream=net.connect({host:target.hostname,port:Number(target.port)},()=>{socket.write('HTTP/1.1 200 Connection Established\r\n\r\n');if(head.length)upstream.write(head);socket.pipe(upstream);upstream.pipe(socket);}); upstream.on('error',()=>socket.destroy());socket.on('error',()=>upstream.destroy());socket.on('close',()=>upstream.destroy()); }); await new Promise(resolve=>proxy.listen(0,'127.0.0.1',resolve)); t.after(async()=>{for(const socket of sockets)socket.destroy();await new Promise(resolve=>proxy.close(resolve));}); const environment={HTTP_PROXY:'http://owned-proxy.invalid:'+proxy.address().port}; const through=new Provider({transport:new ModelTransport({environment,lookup}),retryPolicy:policy});t.after(()=>through.abortRequests()); assert.equal((await through.complete(config(model.baseUrl),[],null)).message.content,'Owned proxy result');assert.equal(tunnels,1); const bypass=new Provider({transport:new ModelTransport({environment:{...environment,NO_PROXY:'127.0.0.1'}}),retryPolicy:policy});t.after(()=>bypass.abortRequests()); await bypass.complete(config(model.baseUrl),[],null);assert.equal(tunnels,1);assert.equal(model.requests.length,2); assert.equal(JSON.stringify(through.transport.profile).includes(environment.HTTP_PROXY),false); }); test('original connect timeout has a bounded nested cause and does not masquerade as response generation timeout',()=>{ const error=new TypeError('fetch failed',{cause:Object.assign(new Error('socket'),{code:'UND_ERR_CONNECT_TIMEOUT'})}); const value=connectionFailure(error,{model:'owned',attempt:1}); assert.equal(value.kind,'timeout');assert.equal(value.network.stage,'connect');assert.equal(value.network.replaySafety,'before_model_send'); assert.equal(value.retryable,true);assert.equal(value.outcome,'failed');assert.equal(value.title,'模型服务连接超时'); assert.match(value.suggestion,/增加模型响应等待时限不能修复连接/); const unreachable=Object.assign(new Error('owned'),{code:'ENETUNREACH',family:6,syscall:'connect'}); const aggregate=new TypeError('fetch',{cause:new AggregateError([unreachable,Object.assign(new Error('owned'),{code:'ECONNREFUSED',family:4})])}); const bounded=connectionFailure(aggregate,{attempt:1});assert.equal(bounded.retryable,true);assert.equal(bounded.network.causes.length,2); unreachable.cause=unreachable; assert.equal(connectionFailure(aggregate,{attempt:1}).retryable,false,'Incomplete or cyclic causes cannot establish safe replay.'); for(const errors of [[Object.assign(new Error('refused'),{code:'ECONNREFUSED'}),new Error('unknown failure')], [...Array.from({length:8},()=>Object.assign(new Error('refused'),{code:'ECONNREFUSED'})),Object.assign(new Error('reset'),{code:'ECONNRESET'})]]){ const unknown=connectionFailure(new AggregateError(errors),{attempt:1}); assert.equal(unknown.outcome,'unknown');assert.equal(unknown.retryable,false); } }); test('POST accepted then reset is unknown, is charged once and never automatically retried',async t=>{ const sockets=new Set();let posts=0; const server=http.createServer(async(request,response)=>{for await(const _chunk of request){}posts++;response.socket.destroy();}); server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));}); await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve)); t.after(async()=>{for(const socket of sockets)socket.destroy();await new Promise(resolve=>server.close(resolve));}); const provider=new Provider({transport:new ModelTransport({environment:{}}),retryPolicy:policy}),events=[];t.after(()=>provider.abortRequests()); await assert.rejects(provider.complete(config('http://127.0.0.1:'+server.address().port+'/v1'),[],null,null,event=>events.push(event)),error=>{ assert.equal(error.diagnostic.outcome,'unknown');assert.equal(error.diagnostic.retryable,false);assert.equal(error.diagnostic.failoverAllowed,false);return true; }); assert.equal(posts,1);const receipts=events.filter(event=>event.consumption);assert.equal(receipts.length,1);assert.equal(receipts[0].consumption.usageStatus,'unknown'); assert.equal(receipts[0].consumption.outcome,'unknown'); }); test('partial HTTP bodies retain original request id and bytes, and an unknown pool attempt never switches model',async t=>{ const f=fixture(t),prefix=Buffer.from('{"choices":[{"message":{"content":"owned partial 中文');let posts=0; const server=http.createServer(async(request,response)=>{ for await(const _chunk of request){}posts++; response.writeHead(200,{'Content-Type':'application/json','X-Request-ID':'owned-partial-http'});response.write(prefix); setTimeout(()=>response.destroy(),20); }); await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve)); t.after(()=>new Promise(resolve=>{server.closeAllConnections();server.close(resolve);})); const backup=await compatibleFixture(t,()=>completion([],'Must not be called')); const provider=new Provider({transport:new ModelTransport({environment:{}}),retryPolicy:policy}),hub=provider.modelHub(f.store); const first=hub.upsert({name:'owned partial',model:'actual-partial',baseUrl:'http://127.0.0.1:'+server.address().port+'/v1',requiresKey:false}); const second=hub.upsert({name:'owned backup',model:'actual-backup',baseUrl:backup.baseUrl,requiresKey:false}); const pool=hub.pool({name:'owned unknown pool',members:[{connectionId:first.id},{connectionId:second.id}]});hub.select({type:'pool',id:pool.id}); const runtime=new Runtime(f.store,provider);t.after(()=>runtime.stopAll()); runtime.start(f.session.id,'读取项目,不修改、不检查');await runtime.active.get(f.session.id).promise; assert.equal(f.session.status,'failed');assert.equal(posts,1);assert.equal(backup.requests.length,0); const failure=f.session.failure,attempt=hub.view().attempts[0],run=f.store.core.run.get(f.session.runId); assert.equal(hub.view().attempts.length,1);assert.equal(attempt.status,'unknown'); assert.equal(failure.network.stage,'response_body');assert.equal(failure.outcome,'unknown');assert.equal(failure.upstreamRequestId,'owned-partial-http'); assert.equal(failure.upstream.capture.complete,false);assert.equal(failure.upstream.capture.interrupted,true); const captured=f.store.artifactStore.read(f.store.owned('artifact',attempt.responseArtifactId,f.session.id)); assert.equal(captured,prefix.toString('utf8'));assert.equal(attempt.responseSha256,createHash('sha256').update(prefix).digest('hex')); assert.equal(run.consumption.length,1);assert.equal(run.consumption[0].outcome,'unknown');assert.equal(run.consumption[0].usageStatus,'unknown'); assert.equal(run.usage.requests,1);assert.equal(run.usage.unknownRequests,1);assert.equal(f.store.core.tool.size,0); }); test('response wait timeout after an accepted POST is unknown; cancellation closes the owned socket and permits explicit reuse',async t=>{ let posts=0,closed=0;const sockets=new Set(); const server=http.createServer(async(request,_response)=>{for await(const _chunk of request){}posts++;request.socket.once('close',()=>closed++);}); server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));}); await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve)); t.after(async()=>{for(const socket of sockets)socket.destroy();await new Promise(resolve=>server.close(resolve));}); const provider=new Provider({transport:new ModelTransport({environment:{}}),retryPolicy:{...policy,timeoutMs:100,totalTimeoutMs:100}});t.after(()=>provider.abortRequests()); const endpoint=config('http://127.0.0.1:'+server.address().port+'/v1'); await assert.rejects(provider.complete(endpoint,[],null),error=>error.diagnostic.outcome==='unknown'&&error.diagnostic.network.stage==='waiting_response'); assert.equal(posts,1);assert.equal(provider.lastRequest.attempts,1); provider.retryPolicy=policy;const controller=new AbortController(),pending=provider.complete(endpoint,[],null,controller.signal); await until(()=>posts===2);controller.abort(new Error('Owned user cancellation'));await assert.rejects(pending,/Owned user cancellation/); await provider.abortRequests();assert.equal(provider.activeRequests,0);assert.ok(closed>=1);assert.equal(provider.transport,null);provider.resumeRequests(); assert.equal(posts,2); const working=await compatibleFixture(t,()=>completion([],'Explicit reuse works')); assert.equal((await provider.complete(config(working.baseUrl),[],null)).message.content,'Explicit reuse works'); assert.equal(working.requests.length,1); });