@antseed/cli 0.1.194 → 0.1.196

package/dist/proxy/buyer-proxy.test.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
 import { mkdir, mkdtemp, readdir, readFile, rm, utimes, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -786,7 +787,7 @@ test('explicit routing-service target and tradeoff survive the local state-file
     const response = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody(selection) }));
     assert.equal(response.statusCode, 200, response.body);
     assert.deepEqual(JSON.parse(await readFile(stateFile, 'utf8')).defaultRouter, routeBody(selection).router);
-    const restarted = new BuyerProxy({ port: 0, dataDir: directory, node: { router: permissiveRouter() }, modelRoutingClient: client });
+    const restarted = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 }, port: 0, dataDir: directory, node: { router: permissiveRouter() }, modelRoutingClient: client });
     await restarted._reloadSessionOverrides();
     const restored = await invokeProxy(restarted, makeProxyRequest({ path: '/_antseed/route', method: 'GET' }));
     assert.deepEqual(JSON.parse(restored.body).router, routeBody(selection).router);
@@ -1594,7 +1595,7 @@ function listModelsWith(models = TEST_ROUTER_MODELS) {
     return async () => models.map(id => ({ id }));
 }
 function makeBuyerProxyWithPeers(initialPeers, refreshedPeers = initialPeers, router = null, now, routingPreferences, modelRoutingClient) {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         modelRoutingClient,
@@ -1602,8 +1603,7 @@ function makeBuyerProxyWithPeers(initialPeers, refreshedPeers = initialPeers, ro
             router,
         },
         ...(now ? { now } : {}),
-        ...(routingPreferences ? { routingPreferences } : {}),
-    });
+        ...(routingPreferences ? { routingPreferences } : {}), });
     proxy._getPeers = async (options) => options?.forceRefresh ? refreshedPeers : initialPeers;
     proxy._cacheLastUpdatedAtMs = Date.now();
     return proxy;
@@ -1650,7 +1650,7 @@ async function invokeProxy(proxy, req) {
     return res;
 }
 test('BuyerProxy defaults to the configured 5 min background refresh interval', () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -1658,16 +1658,15 @@ test('BuyerProxy defaults to the configured 5 min background refresh interval',
     assert.equal(proxy._bgRefreshIntervalMs, DEFAULT_BUYER_PEER_REFRESH_INTERVAL_MS);
 });
 test('BuyerProxy accepts a custom background refresh interval', () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
-        backgroundRefreshIntervalMs: 15_000,
-    });
+        backgroundRefreshIntervalMs: 15_000, });
     assert.equal(proxy._bgRefreshIntervalMs, 15_000);
 });
 test('BuyerProxy rewrites upstream 413 responses into a clear request size error', () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -1701,7 +1700,7 @@ test('BuyerProxy reloads model routing preferences from config', async (t) => {
             },
         },
     }));
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir,
         configPath,
@@ -1721,7 +1720,7 @@ test('BuyerProxy starts incremental discovery on startup', async (t) => {
     const dir = await mkdtemp(join(tmpdir(), 'antseed-buyer-proxy-'));
     t.after(() => rm(dir, { recursive: true, force: true }));
     let sweepCalls = 0;
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: dir,
         node: {
@@ -1729,8 +1728,7 @@ test('BuyerProxy starts incremental discovery on startup', async (t) => {
             on: () => undefined,
             startBackgroundPeerDiscoverySweep: () => { sweepCalls += 1; },
         },
-        backgroundRefreshIntervalMs: 60 * 60_000,
-    });
+        backgroundRefreshIntervalMs: 60 * 60_000, });
     proxy._refreshPeersNow = async () => [];
     await proxy.start();
     await proxy.stop();
@@ -1782,7 +1780,7 @@ test('sweep control endpoint validates and dispatches sequentially via the runni
     };
     const dispatches = [];
     const listeners = new Map();
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: {
@@ -1818,6 +1816,22 @@ test('sweep control endpoint validates and dispatches sequentially via the runni
     const missing = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: `/_antseed/sweep/0x${'bb'.repeat(32)}` }));
     assert.deepEqual(JSON.parse(missing.body), { ok: true, receipt: null });
 });
+test('peer refresh drops services a seller stopped advertising', () => {
+    const advertised = makePeer('a', ['venice-video']);
+    advertised.providerPricing = { 'venice-video': { defaults: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 }, services: { 'video-model': { inputUsdPerMillion: 0, outputUsdPerMillion: 0 } } } };
+    advertised.providerServiceApiProtocols = { 'venice-video': { services: { 'video-model': ['venice-video'] } } };
+    advertised.lastReachedAt = Date.now() - 1000;
+    const proxy = makeBuyerProxyWithPeers([]);
+    proxy._replacePeers([advertised]);
+    const unadvertised = makePeer('a', []);
+    proxy._replacePeers([unadvertised]);
+    const cached = proxy._cachedPeers;
+    assert.equal(cached.length, 1);
+    assert.deepEqual(cached[0].providers, []);
+    assert.equal(cached[0].providerPricing, undefined);
+    assert.equal(cached[0].providerServiceApiProtocols, undefined);
+    assert.equal(cached[0].lastReachedAt, advertised.lastReachedAt);
+});
 test('peer refresh control endpoint triggers immediate refresh', async () => {
     const refreshedPeer = makePeer('a', ['anthropic']);
     const proxy = makeBuyerProxyWithPeers([], [refreshedPeer]);
@@ -4133,7 +4147,7 @@ test('overrideRoutedModelInBody no-ops on a matching model, a missing model, or
 test('route control endpoint sets, persists, and returns the default routed model', async (t) => {
     const dir = await mkdtemp(join(tmpdir(), 'antseed-buyer-route-'));
     t.after(() => rm(dir, { recursive: true, force: true }));
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: dir,
         node: { router: null },
@@ -4164,7 +4178,7 @@ test('route control endpoint sets, persists, and returns the default routed mode
     assert.deepEqual(JSON.parse(cleared.body), { ok: true, model: null, router: null });
 });
 test('buyer-usage endpoint reports lastActivityAt, null until a request is dispatched', async () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null, getBuyerUsageTotals: () => ({ totalRequests: 0 }) },
@@ -4207,7 +4221,7 @@ test('rewritePeerPinnedServiceInBody returns original when body is not a JSON ob
 // ---------- Per-chat conversations (tracking, pins, control endpoints) ----------
 async function makeConversationProxy() {
     const dir = await mkdtemp(join(tmpdir(), 'antseed-buyer-conv-'));
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: dir,
         node: { router: null },
@@ -4625,7 +4639,7 @@ test('sweepStaleStateTmpFiles: tolerates a missing directory', async () => {
 });
 // ---------- Deposit watcher control plane ----------
 test('deposits/status reports no watcher until one is attached', async () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -4752,7 +4766,7 @@ test('deposits/status reports the recorded watcher-absence reason and payments h
         chainId: 8453,
         rpc: { state: 'unreachable', lastCheckedAt: 123, lastReadyAt: null, lastError: 'probe failed', attempts: 2 },
     };
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null, getPaymentsStatus: () => paymentsStatus },
@@ -4772,7 +4786,7 @@ test('deposits/status reports the recorded watcher-absence reason and payments h
     assert.match(watchBody.error, /payments are disabled/);
 });
 test('deposits/watch returns 503 when no watcher is attached', async () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -4782,7 +4796,7 @@ test('deposits/watch returns 503 when no watcher is attached', async () => {
     assert.equal(JSON.parse(res.body).ok, false);
 });
 test('deposits/watch promotes and demotes an attached watcher and returns its status', async () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -4813,7 +4827,7 @@ test('deposits/watch promotes and demotes an attached watcher and returns its st
     assert.deepEqual(JSON.parse(status.body), { ok: true, watcher: true, reason: null, payments: null, status: fakeStatus });
 });
 test('getSweepReceipt returns cached relayer receipts case-insensitively', () => {
-    const proxy = new BuyerProxy({
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
         port: 0,
         dataDir: '/tmp/antseed-test',
         node: { router: null },
@@ -4886,7 +4900,7 @@ test('switching a chat route while a request is in flight is not reverted when t
         oldPeer.providerServiceApiProtocols = { openai: { services: { 'gpt-5': ['openai-chat-completions'] } } };
         const newPeer = makePeer('b', ['openai']);
         newPeer.providerServiceApiProtocols = { openai: { services: { 'claude-sonnet': ['openai-chat-completions'] } } };
-        const proxy = new BuyerProxy({
+        const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 },
             port: 0,
             dataDir: dir,
             node: { router: permissiveRouter() },
@@ -4958,4 +4972,413 @@ test('switching a chat route while a request is in flight is not reverted when t
         await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
     }
 });
+/** Sellers of one model at trust 80: `cheap` slightly undercuts `pricier`; `extra` costs ten times as much. */
+function makeModelSellers() {
+    const seller = (seed, input, output) => {
+        const peer = makePeer(seed, ['openai']);
+        peer.reputationScore = 80;
+        peer.providerPricing = { openai: { defaults: { inputUsdPerMillion: input, outputUsdPerMillion: output }, services: { 'gpt-5': { inputUsdPerMillion: input, outputUsdPerMillion: output } } } };
+        peer.providerServiceApiProtocols = { openai: { services: { 'gpt-5': ['openai-chat-completions'] } } };
+        return peer;
+    };
+    return { cheap: seller('a', 1, 2), pricier: seller('b', 1, 2.4), extra: seller('c', 10, 20) };
+}
+function jsonResponse(requestId, statusCode, body) {
+    return { requestId, statusCode, headers: { 'content-type': 'application/json' }, body: Buffer.from(JSON.stringify(body)) };
+}
+const answer = (content = 'ok') => ({ choices: [{ message: { content }, finish_reason: 'stop' }] });
+const modelRequest = () => makeProxyRequest({ body: { model: 'gpt-5', messages: [] } });
+const sellerHealthOf = (proxy, peer, now) => proxy._sellerHealth.stats(peer.peerId, proxy._healthServiceKey('gpt-5'), now);
+test('a seller that rejects a request another seller serves loses its place to a slightly pricier seller', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return peer.peerId === cheap.peerId
+            ? jsonResponse(request.requestId, 422, { error: { type: 'invalid_request_error', message: 'unsupported parameter: top_k' } })
+            : jsonResponse(request.requestId, 200, answer());
+    };
+    const first = await invokeProxy(proxy, modelRequest());
+    assert.equal(first.statusCode, 200);
+    assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).failures, 1);
+    attempts.length = 0;
+    clock.advance(60_000);
+    assert.equal((await invokeProxy(proxy, modelRequest())).statusCode, 200);
+    assert.deepEqual(attempts, [pricier.peerId], 'the failing seller is no longer tried first');
+    const health = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/_antseed/peer-health' }));
+    const entry = JSON.parse(health.body).sellerHealth.find((row) => row.peerId === cheap.peerId);
+    assert.match(entry?.lastFailureReason ?? '', /HTTP 422/);
+});
+test('a stream that breaks after its headers does not prove an earlier rejection, and counts against the broken seller', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequestStream = async (peer, request, callbacks) => {
+        attempts.push(peer.peerId);
+        if (peer.peerId === cheap.peerId) {
+            const rejected = jsonResponse(request.requestId, 422, { error: { type: 'invalid_request_error', message: 'unsupported parameter' } });
+            callbacks.onResponseStart(rejected, { streaming: false });
+            return rejected;
+        }
+        callbacks.onResponseStart({ requestId: request.requestId, statusCode: 200, headers: { 'content-type': 'text/event-stream' }, body: new Uint8Array() }, { streaming: true });
+        callbacks.onResponseChunk({ requestId: request.requestId, data: Buffer.from('data: {"choices":[{"delta":{"content":"par"}}]}\n\n'), done: false });
+        throw new Error('connection reset by peer');
+    };
+    await invokeProxy(proxy, makeProxyRequest({ headers: { accept: 'text/event-stream' }, body: { model: 'gpt-5', messages: [], stream: true } }));
+    assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()), null, 'the rejection is unproven: nobody completed the request');
+    assert.equal(sellerHealthOf(proxy, pricier, clock.now()).failures, 1);
+    assert.equal(sellerHealthOf(proxy, pricier, clock.now()).successes, 0);
+});
+for (const [label, partialBytes] of [['short', 0], ['larger than 4 MiB', 5 * 1024 * 1024]])
+    test(`a stream whose provider fails after partial text is not a served answer (${label})`, async () => {
+        const clock = makeTestClock();
+        const { cheap, pricier } = makeModelSellers();
+        const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+        const attempts = [];
+        proxy._node.sendRequestStream = async (peer, request, callbacks) => {
+            attempts.push(peer.peerId);
+            if (peer.peerId === cheap.peerId) {
+                const rejected = jsonResponse(request.requestId, 422, { error: { type: 'invalid_request_error', message: 'unsupported parameter' } });
+                callbacks.onResponseStart(rejected, { streaming: false });
+                return rejected;
+            }
+            const headers = { 'content-type': 'text/event-stream' };
+            callbacks.onResponseStart({ requestId: request.requestId, statusCode: 200, headers, body: new Uint8Array() }, { streaming: true });
+            // The seller's wire behavior when its provider throws mid-stream: an
+            // error frame, then a normal terminal chunk.
+            const line = 'data: {"choices":[{"delta":{"content":"' + 'x'.repeat(1000) + '"}}]}\n\n';
+            const text = Buffer.from(partialBytes === 0 ? 'data: {"choices":[{"delta":{"content":"partial"}}]}\n\n' : line.repeat(Math.ceil(partialBytes / line.length)));
+            const errorFrame = Buffer.from('event: error\ndata: upstream failed\n\n');
+            callbacks.onResponseChunk({ requestId: request.requestId, data: text, done: false });
+            callbacks.onResponseChunk({ requestId: request.requestId, data: errorFrame, done: false });
+            callbacks.onResponseChunk({ requestId: request.requestId, data: new Uint8Array(0), done: true });
+            return { requestId: request.requestId, statusCode: 200, headers, body: Buffer.concat([text, errorFrame]) };
+        };
+        await invokeProxy(proxy, makeProxyRequest({ headers: { accept: 'text/event-stream' }, body: { model: 'gpt-5', messages: [], stream: true } }));
+        assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+        assert.equal(sellerHealthOf(proxy, cheap, clock.now()), null, 'the rejection is unproven: nobody completed the request');
+        assert.equal(sellerHealthOf(proxy, pricier, clock.now()).failures, 1);
+        assert.equal(sellerHealthOf(proxy, pricier, clock.now()).successes, 0);
+    });
+test('a rejection every seller shares reaches the client after one extra seller and counts against nobody', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier, extra } = makeModelSellers();
+    const peers = [cheap, pricier, extra];
+    const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 400, { error: { type: 'invalid_request_error', message: 'messages must not be empty' } });
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 400);
+    assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()), null);
+    assert.equal(sellerHealthOf(proxy, pricier, clock.now()), null);
+});
+test('a pinned seller keeps its rejection and it does not count against it', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 422, { error: { type: 'invalid_request_error', message: 'nope' } });
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        headers: { 'x-antseed-pin-peer': cheap.peerId },
+        body: { model: 'gpt-5', messages: [] },
+    }));
+    assert.equal(res.statusCode, 422);
+    assert.deepEqual(attempts, [cheap.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()), null);
+});
+test('a seller whose signed response fails verification falls behind; buyer-side mismatches are ignored', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const node = Object.assign(new EventEmitter(), { router: permissiveRouter() });
+    const proxy = new BuyerProxy({ adaptiveRouting: { spreadTolerance: 0, explorationRate: 0 }, port: 0, dataDir: '/tmp/antseed-test', node: node, now: clock.now, routingPreferences: priceAndTrustPreferences });
+    proxy._getPeers = async () => [cheap, pricier];
+    proxy._cacheLastUpdatedAtMs = Date.now();
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    node.emit('response-auth', { requestId: 'r1', sellerPeerId: cheap.peerId, advertisedService: 'gpt-5', verified: false, verificationError: 'channel_id_mismatch' });
+    await invokeProxy(proxy, modelRequest());
+    assert.deepEqual(attempts, [cheap.peerId]);
+    node.emit('response-auth', { requestId: 'r2', sellerPeerId: cheap.peerId, advertisedService: 'gpt-5', verified: false, verificationError: 'response_hash_mismatch' });
+    attempts.length = 0;
+    await invokeProxy(proxy, modelRequest());
+    assert.deepEqual(attempts, [pricier.peerId]);
+});
+test('failures fade with time, with no timer: a seller that failed a while ago is first again', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    for (let i = 0; i < 3; i += 1)
+        proxy._recordSellerFailure(cheap.peerId, 'gpt-5', 'HTTP 503');
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    await invokeProxy(proxy, modelRequest());
+    assert.deepEqual(attempts, [pricier.peerId]);
+    attempts.length = 0;
+    clock.advance(2 * 60 * 60_000);
+    await invokeProxy(proxy, modelRequest());
+    assert.deepEqual(attempts, [cheap.peerId]);
+});
+test('any failure another seller then serves counts against the failing seller: a 403, a dropped request', async () => {
+    for (const failure of ['403', 'transport']) {
+        const clock = makeTestClock();
+        const { cheap, pricier } = makeModelSellers();
+        const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+        const attempts = [];
+        proxy._node.sendRequest = async (peer, request) => {
+            attempts.push(peer.peerId);
+            if (peer.peerId !== cheap.peerId)
+                return jsonResponse(request.requestId, 200, answer());
+            if (failure === 'transport')
+                throw new Error('connection reset by peer');
+            return jsonResponse(request.requestId, 403, { error: { message: 'forbidden' } });
+        };
+        assert.equal((await invokeProxy(proxy, modelRequest())).statusCode, 200, failure);
+        assert.deepEqual(attempts, [cheap.peerId, pricier.peerId], failure);
+        attempts.length = 0;
+        clock.advance(30_000);
+        assert.equal((await invokeProxy(proxy, modelRequest())).statusCode, 200, failure);
+        assert.deepEqual(attempts, [pricier.peerId], `${failure}: the failing seller is no longer tried first`);
+    }
+});
+test('an empty answer is retried on one more seller, and counts against the empty one when that one answers', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer(peer.peerId === cheap.peerId ? '' : 'ok'));
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 200);
+    assert.equal(JSON.parse(res.body).choices[0].message.content, 'ok');
+    assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).failures, 1);
+    assert.equal(sellerHealthOf(proxy, pricier, clock.now()).successes, 1);
+});
+test('a refusal is an answer: not retried and not counted against the seller', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, {
+            id: 'r', object: 'chat.completion', model: 'gpt-5',
+            choices: [{ index: 0, message: { role: 'assistant', content: null, refusal: 'I can not help with that.' }, finish_reason: 'stop' }],
+        });
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 200);
+    assert.equal(JSON.parse(res.body).choices[0].message.refusal, 'I can not help with that.');
+    assert.deepEqual(attempts, [cheap.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).failures, 0);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).successes, 1);
+});
+test('a legacy completion is an answer: not retried and not counted against the seller', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, {
+            id: 'c', object: 'text_completion', model: 'gpt-5',
+            choices: [{ index: 0, text: 'Hello', finish_reason: 'stop' }],
+        });
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [cheap.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).failures, 0);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()).successes, 1);
+});
+test('when every seller answers empty, the client gets the answer and nobody is counted against', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier, extra } = makeModelSellers();
+    const peers = [cheap, pricier, extra];
+    const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer(''));
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+    assert.equal(sellerHealthOf(proxy, cheap, clock.now()), null);
+});
+test('traffic is spread across sellers close in cost, not sent to one', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier, extra } = makeModelSellers();
+    const peers = [cheap, pricier, extra];
+    let draw = 0;
+    const proxy = new BuyerProxy({
+        adaptiveRouting: { random: () => { draw = (draw + 0.37) % 1; return draw; }, explorationRate: 0 },
+        port: 0, dataDir: '/tmp/antseed-test', node: { router: permissiveRouter() }, now: clock.now, routingPreferences: priceAndTrustPreferences,
+    });
+    proxy._getPeers = async () => peers;
+    proxy._cacheLastUpdatedAtMs = Date.now();
+    const served = new Map();
+    proxy._node.sendRequest = async (peer, request) => {
+        served.set(peer.peerId, (served.get(peer.peerId) ?? 0) + 1);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    for (let i = 0; i < 20; i += 1)
+        await invokeProxy(proxy, modelRequest());
+    assert.ok((served.get(cheap.peerId) ?? 0) > 0 && (served.get(pricier.peerId) ?? 0) > 0, JSON.stringify([...served]));
+    assert.equal(served.get(extra.peerId) ?? 0, 0, 'a seller ten times the price gets no share');
+});
+test('a seller far slower than usual is given up on so the next seller can answer', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    for (let i = 0; i < 3; i += 1)
+        proxy._recordSellerSuccess(cheap.peerId, 'gpt-5', { firstTokenMs: 100, outputTokens: 0, streamed: false });
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request, options) => {
+        attempts.push(peer.peerId);
+        if (peer.peerId !== cheap.peerId)
+            return jsonResponse(request.requestId, 200, answer());
+        return new Promise((_resolve, reject) => {
+            options.signal.addEventListener('abort', () => reject(options.signal.reason), { once: true });
+        });
+    };
+    const timers = [];
+    const realSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = (fn, ms) => {
+        // The per-attempt timeout (at least 30 s): fire it now instead of waiting.
+        if (ms >= 30_000) {
+            timers.push(fn);
+            return { unref() { } };
+        }
+        return realSetTimeout(fn, ms);
+    };
+    try {
+        const pending = invokeProxy(proxy, modelRequest());
+        while (timers.length === 0)
+            await new Promise((resolve) => realSetTimeout(resolve, 1));
+        timers.shift()();
+        const res = await pending;
+        assert.equal(res.statusCode, 200);
+        assert.deepEqual(attempts, [cheap.peerId, pricier.peerId]);
+        assert.match(sellerHealthOf(proxy, cheap, clock.now()).lastFailureReason, /no answer within \d+s/);
+    }
+    finally {
+        ;
+        globalThis.setTimeout = realSetTimeout;
+    }
+});
+test('seller health survives a restart', async () => {
+    const dataDir = await mkdtemp(join(tmpdir(), 'antseed-health-'));
+    try {
+        const clock = makeTestClock();
+        const first = new BuyerProxy({ port: 0, dataDir, node: { router: null }, now: clock.now });
+        first._recordSellerFailure('a'.repeat(40), 'gpt-5', 'HTTP 403');
+        await first.stop();
+        const second = new BuyerProxy({ port: 0, dataDir, node: { router: null }, now: clock.now });
+        await second._hydratePeersFromStateFile();
+        assert.equal(second._peerLatency('a'.repeat(40), 'gpt-5'), null);
+        assert.equal(second._sellerHealth.stats('a'.repeat(40), second._healthServiceKey('gpt-5'), clock.now()).failures, 1);
+    }
+    finally {
+        await rm(dataDir, { recursive: true, force: true });
+    }
+});
+test('requests of one identified conversation stay on one seller; others spread', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = new BuyerProxy({
+        adaptiveRouting: { random: Math.random, explorationRate: 0 },
+        port: 0, dataDir: '/tmp/antseed-test', node: { router: permissiveRouter() }, now: clock.now, routingPreferences: priceAndTrustPreferences,
+    });
+    proxy._getPeers = async () => [cheap, pricier];
+    proxy._cacheLastUpdatedAtMs = Date.now();
+    const served = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        served.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    const turn = (cacheKey, n) => makeProxyRequest({
+        body: { model: 'gpt-5', messages: [{ role: 'user', content: `turn ${n}` }], ...(cacheKey ? { prompt_cache_key: cacheKey } : {}) },
+    });
+    for (let n = 0; n < 8; n += 1)
+        await invokeProxy(proxy, turn('conversation-1', n));
+    assert.equal(new Set(served).size, 1, 'every turn on the seller holding the cache');
+    served.length = 0;
+    for (let n = 0; n < 30; n += 1)
+        await invokeProxy(proxy, turn(`conversation-${n + 2}`, 0));
+    assert.equal(new Set(served).size, 2, 'different conversations still spread');
+});
+test('spreading stays on sellers with an open channel instead of reserving on new ones', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = new BuyerProxy({
+        adaptiveRouting: { random: Math.random },
+        port: 0, dataDir: '/tmp/antseed-test',
+        node: { router: permissiveRouter(), getActiveBuyerChannels: () => [{ peerId: pricier.peerId }] },
+        now: clock.now, routingPreferences: priceAndTrustPreferences,
+    });
+    proxy._getPeers = async () => [cheap, pricier];
+    proxy._cacheLastUpdatedAtMs = Date.now();
+    const served = new Set();
+    proxy._node.sendRequest = async (peer, request) => {
+        served.add(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    for (let i = 0; i < 20; i += 1)
+        await invokeProxy(proxy, modelRequest());
+    assert.deepEqual([...served], [pricier.peerId]);
+});
+test('a seller already holding as many of our requests as it advertises it can take is not chosen first', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    cheap.maxConcurrency = 1;
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return jsonResponse(request.requestId, 200, answer());
+    };
+    proxy._inFlightBySeller.set(cheap.peerId, 1);
+    await invokeProxy(proxy, modelRequest());
+    assert.deepEqual(attempts, [pricier.peerId]);
+    assert.equal(proxy._inFlightBySeller.get(pricier.peerId) ?? 0, 0, 'in-flight counts are released');
+});
+test('a seller that answers on its own retry after a 429 is not counted against', async () => {
+    const clock = makeTestClock();
+    const { cheap, pricier } = makeModelSellers();
+    const proxy = makeBuyerProxyWithPeers([cheap, pricier], [cheap, pricier], permissiveRouter(), clock.now, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return attempts.length === 1
+            ? { requestId: request.requestId, statusCode: 429, headers: { 'content-type': 'application/json', 'retry-after': '0' }, body: Buffer.from('{"error":{"message":"busy"}}') }
+            : jsonResponse(request.requestId, 200, answer());
+    };
+    const res = await invokeProxy(proxy, modelRequest());
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [cheap.peerId, cheap.peerId]);
+    const health = sellerHealthOf(proxy, cheap, clock.now());
+    assert.equal(health.successes, 1);
+    assert.equal(health.failures, 0);
+});
 //# sourceMappingURL=buyer-proxy.test.js.map