124 lines
11 KiB
JavaScript
124 lines
11 KiB
JavaScript
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);
|
|
});
|