@antseed/cli 0.1.173 → 0.1.175

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

@@ -3263,6 +3263,32 @@ test('adaptPeerFaultErrorResponse upgrades a generic wrapper for a pinned route'
         'Original Response: {"message":"Insufficient balance or no resource package. Please recharge.","status":429}',
     ].join('\n'));
 });
+test('adaptPeerFaultErrorResponse keeps string errors and validation details', () => {
+    const response = adaptPeerFaultErrorResponse({
+        requestId: 'req-venice-details',
+        statusCode: 400,
+        headers: { 'content-type': 'application/json' },
+        body: Buffer.from(JSON.stringify({
+            error: 'Invalid request parameters',
+            details: { _errors: [], audio: { _errors: ['Audio is not configurable for this model'] } },
+        })),
+    }, 'venice-video', { pinned: true });
+    const parsed = JSON.parse(Buffer.from(response.body).toString('utf8'));
+    assert.equal(parsed.error.type, 'Invalid request parameters');
+    assert.equal(parsed.error.peer_message, 'Invalid request parameters: audio: Audio is not configurable for this model');
+    assert.equal(parsed.error.peer_status, 400);
+    assert.match(parsed.error.message, /audio: Audio is not configurable for this model/);
+});
+test('adaptPeerFaultErrorResponse falls back to JSON for unstructured details', () => {
+    const response = adaptPeerFaultErrorResponse({
+        requestId: 'req-raw-details',
+        statusCode: 400,
+        headers: { 'content-type': 'application/json' },
+        body: Buffer.from(JSON.stringify({ error: 'Bad input', details: { field: 'resolution' } })),
+    }, 'venice-video');
+    const parsed = JSON.parse(Buffer.from(response.body).toString('utf8'));
+    assert.equal(parsed.error.peer_message, 'Bad input: {"field":"resolution"}');
+});
 test('adaptPeerFaultErrorResponse preserves payment-required control messages', () => {
     const body = Buffer.from(JSON.stringify({
         error: 'payment_required',
@@ -3358,4 +3384,83 @@ test('getSweepReceipt returns cached relayer receipts case-insensitively', () =>
     assert.equal(proxy.getSweepReceipt(nonce.toLowerCase()), receipt);
     assert.equal(proxy.getSweepReceipt('0x' + '00'.repeat(32)), null);
 });
+test('switching a chat route while a request is in flight is not reverted when that request completes', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'antseed-buyer-route-race-'));
+    try {
+        const oldPeer = makePeer('a', ['openai']);
+        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({
+            port: 0,
+            dataDir: dir,
+            node: { router: permissiveRouter() },
+        });
+        proxy._getPeers = async () => [oldPeer, newPeer];
+        proxy._cacheLastUpdatedAtMs = Date.now();
+        proxy._defaultRoutedModel = 'gpt-5';
+        const attempts = [];
+        let holdNext = false;
+        let releaseHeld = null;
+        let markDispatched = null;
+        const dispatched = new Promise((resolve) => { markDispatched = resolve; });
+        proxy._node.sendRequest = async (peer, request) => {
+            attempts.push(peer.peerId);
+            if (holdNext) {
+                holdNext = false;
+                markDispatched?.();
+                await new Promise((resolve) => { releaseHeld = resolve; });
+            }
+            return {
+                requestId: request.requestId,
+                statusCode: 200,
+                headers: { 'content-type': 'application/json' },
+                body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+            };
+        };
+        const headers = { 'x-vpr-session-id': 'route-race' };
+        const chatId = 'vpr:route-race';
+        const store = proxy._conversations;
+        // Turn 1 settles the chat on the old route as soft (auto) affinity.
+        const first = await invokeProxy(proxy, makeProxyRequest({
+            headers,
+            body: { model: 'antseed', messages: [{ role: 'user', content: 'first turn' }] },
+        }));
+        assert.equal(first.statusCode, 200);
+        assert.equal(store.get(chatId)?.pinnedModel, `${oldPeer.peerId}@gpt-5`);
+        assert.equal(store.get(chatId)?.peerSource, 'auto');
+        // Turn 2 is held open upstream on the old route.
+        holdNext = true;
+        const inFlight = invokeProxy(proxy, makeProxyRequest({
+            headers,
+            body: { model: 'antseed', messages: [{ role: 'user', content: 'long turn' }] },
+        }));
+        await dispatched;
+        // The user switches the chat's model mid-flight.
+        const update = await invokeProxy(proxy, makeProxyRequest({
+            path: '/_antseed/conversations/update',
+            body: { id: chatId, pinnedModel: 'claude-sonnet', peerSource: 'auto' },
+        }));
+        assert.equal(update.statusCode, 200);
+        releaseHeld?.();
+        const finished = await inFlight;
+        assert.equal(finished.statusCode, 200);
+        assert.equal(store.get(chatId)?.pinnedModel, 'claude-sonnet');
+        assert.equal(store.get(chatId)?.peerSource, 'auto');
+        assert.equal(store.get(chatId)?.lastModel, `${oldPeer.peerId}@gpt-5`);
+        // The next turn routes to the newly selected model.
+        attempts.length = 0;
+        const next = await invokeProxy(proxy, makeProxyRequest({
+            headers,
+            body: { model: 'antseed', messages: [{ role: 'user', content: 'after switch' }] },
+        }));
+        assert.equal(next.statusCode, 200);
+        assert.deepEqual(attempts, [newPeer.peerId]);
+        assert.equal(store.get(chatId)?.pinnedModel, `${newPeer.peerId}@claude-sonnet`);
+        await store.flush();
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+    }
+});
 //# sourceMappingURL=buyer-proxy.test.js.map