@antseed/cli 0.1.152 → 0.1.154

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

@@ -7,7 +7,7 @@ import { Readable } from 'node:stream';
 import test from 'node:test';
 import { ANTSEED_BUYER_FAULT_ERROR_CODE, ANTSEED_FAULT_ATTRIBUTION_HEADER, CONNECTION_CAPABILITY_COOPERATIVE_CLOSE_V1, CONNECTION_CAPABILITY_RELAYS_SWEEPS_V1, buyerFault, computeOnChainReputationScore, } from '@antseed/node';
 import { DEFAULT_BUYER_PEER_REFRESH_INTERVAL_MS } from '../config/defaults.js';
-import { BuyerProxy, isModelNotFoundResponse, makeVerifierReach, mergeJsonStateFile, parsePeerPinnedService, parsePersistedPeers, rewritePeerPinnedServiceInBody, selectCandidatePeersForRouting, substituteRoutedModelAlias, sweepStaleStateTmpFiles, } from './buyer-proxy.js';
+import { BuyerProxy, isModelNotFoundResponse, makeVerifierReach, mergeJsonStateFile, parsePeerPinnedService, parsePersistedPeers, rewritePeerPinnedServiceInBody, sanitizePeerBuyerFaultMarker, selectCandidatePeersForRouting, substituteRoutedModelAlias, sweepStaleStateTmpFiles, } from './buyer-proxy.js';
 import { extractRequestedService, overrideRoutedModelInBody, SYSTEM_ROUTED_MODEL_HEADER } from './request-utils.js';
 function makePeer(seed, providers) {
     const repeated = (seed.repeat(40) + 'a'.repeat(40)).slice(0, 40);
@@ -455,6 +455,98 @@ test('model-only request routes to the highest-ranked canonical service match',
     assert.equal(selectedPeerId, higher.peerId);
     assert.equal(selectedBody?.['model'], 'opus-5');
 });
+test('required parameters filter automatic routes and are stripped before seller dispatch', async () => {
+    const unsupported = makePeer('a', ['openai']);
+    unsupported.reputationScore = 99;
+    unsupported.providerServiceApiProtocols = {
+        openai: { services: { 'venice-sd35': ['openai-images'] } },
+    };
+    unsupported.providerServiceCapabilities = {
+        openai: { services: { 'venice-sd35': { outputs: ['image'] } } },
+    };
+    const supported = makePeer('b', ['openai']);
+    supported.reputationScore = 70;
+    supported.providerServiceApiProtocols = {
+        openai: { services: { 'venice-sd35': ['openai-images'] } },
+    };
+    supported.providerServiceCapabilities = {
+        openai: {
+            services: {
+                'venice-sd35': { outputs: ['image'], supportedParameters: ['moderation'] },
+            },
+        },
+    };
+    const proxy = makeBuyerProxyWithPeers([unsupported, supported], [unsupported, supported], permissiveRouter());
+    let selectedPeerId = '';
+    let forwardedHeaders = {};
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        forwardedHeaders = request.headers;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ data: [{ b64_json: 'image' }] })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        path: '/v1/images/generations',
+        headers: { 'x-antseed-required-parameters': 'moderation' },
+        body: { model: 'venice-sd35', prompt: 'a landscape', moderation: 'low' },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, supported.peerId);
+    assert.equal(forwardedHeaders['x-antseed-required-parameters'], undefined);
+});
+test('required parameters fail clearly when no automatic route advertises support', async () => {
+    const peer = makePeer('a', ['openai']);
+    peer.providerServiceApiProtocols = {
+        openai: { services: { 'venice-sd35': ['openai-images'] } },
+    };
+    peer.providerServiceCapabilities = {
+        openai: { services: { 'venice-sd35': { outputs: ['image'] } } },
+    };
+    const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+    let dispatches = 0;
+    proxy._node.sendRequest = async () => {
+        dispatches += 1;
+        throw new Error('must not dispatch');
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        path: '/v1/images/generations',
+        headers: { 'x-antseed-required-parameters': 'moderation' },
+        body: { model: 'venice-sd35', prompt: 'a landscape', moderation: 'low' },
+    }));
+    assert.equal(res.statusCode, 422);
+    assert.equal(JSON.parse(res.body).error.code, 'required_capability_unavailable');
+    assert.equal(dispatches, 0);
+});
+test('pinned routes fail clearly when the seller lacks a required parameter', async () => {
+    const peer = makePeer('a', ['openai']);
+    peer.providerServiceApiProtocols = {
+        openai: { services: { 'venice-sd35': ['openai-images'] } },
+    };
+    peer.providerServiceCapabilities = {
+        openai: { services: { 'venice-sd35': { outputs: ['image'] } } },
+    };
+    const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+    let dispatches = 0;
+    proxy._node.sendRequest = async () => {
+        dispatches += 1;
+        throw new Error('must not dispatch');
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        path: '/v1/images/generations',
+        headers: {
+            'x-antseed-pin-peer': peer.peerId,
+            'x-antseed-required-parameters': 'moderation',
+        },
+        body: { model: 'venice-sd35', prompt: 'a landscape', moderation: 'low' },
+    }));
+    assert.equal(res.statusCode, 422);
+    assert.equal(JSON.parse(res.body).error.code, 'required_capability_unavailable');
+    assert.equal(dispatches, 0);
+});
 test('conversation routing keeps the actual peer as a soft preference and fails over when needed', async () => {
     const preferred = makePeer('c', ['openai']);
     preferred.reputationScore = 70;
@@ -2544,7 +2636,67 @@ test('deposits/status reports no watcher until one is attached', async () => {
     });
     const res = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/_antseed/deposits/status' }));
     assert.equal(res.statusCode, 200);
-    assert.deepEqual(JSON.parse(res.body), { ok: true, watcher: false, status: null });
+    assert.deepEqual(JSON.parse(res.body), { ok: true, watcher: false, reason: null, payments: null, status: null });
+});
+test('sanitizePeerBuyerFaultMarker scrubs the marker at any nesting depth', () => {
+    let deeplyNested = {
+        code: ANTSEED_BUYER_FAULT_ERROR_CODE,
+        message: 'seller-controlled message',
+    };
+    for (let depth = 0; depth < 20; depth += 1) {
+        deeplyNested = { inner: deeplyNested };
+    }
+    const body = {
+        error: {
+            type: 'server_error',
+            details: {
+                code: ANTSEED_BUYER_FAULT_ERROR_CODE,
+                inner: [{ errorCode: ANTSEED_BUYER_FAULT_ERROR_CODE }, deeplyNested],
+            },
+        },
+    };
+    const sanitized = sanitizePeerBuyerFaultMarker({
+        requestId: 'r1',
+        statusCode: 503,
+        headers: { 'content-type': 'application/json' },
+        body: new TextEncoder().encode(JSON.stringify(body)),
+    });
+    const parsed = JSON.parse(Buffer.from(sanitized.body).toString('utf-8'));
+    assert.equal(parsed.error.details.code, 'upstream_error');
+    assert.equal(parsed.error.details.inner[0].errorCode, 'upstream_error');
+    let nested = parsed.error.details.inner[1];
+    for (let depth = 0; depth < 20; depth += 1) {
+        nested = nested.inner;
+    }
+    assert.equal(nested.code, 'upstream_error');
+    assert.equal(nested.message, 'seller-controlled message');
+});
+test('deposits/status reports the recorded watcher-absence reason and payments health', async () => {
+    const paymentsStatus = {
+        configured: true,
+        buyerActive: true,
+        sellerActive: false,
+        chainId: 8453,
+        rpc: { state: 'unreachable', lastCheckedAt: 123, lastReadyAt: null, lastError: 'probe failed', attempts: 2 },
+    };
+    const proxy = new BuyerProxy({
+        port: 0,
+        dataDir: '/tmp/antseed-test',
+        node: { router: null, getPaymentsStatus: () => paymentsStatus },
+    });
+    proxy.setDepositWatcher(null, 'payments-disabled');
+    const res = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/_antseed/deposits/status' }));
+    assert.equal(res.statusCode, 200);
+    const body = JSON.parse(res.body);
+    assert.equal(body.watcher, false);
+    assert.equal(body.reason, 'payments-disabled');
+    assert.deepEqual(body.payments, paymentsStatus);
+    const watchRes = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/deposits/watch', body: { mode: 'active' } }));
+    assert.equal(watchRes.statusCode, 503);
+    const watchBody = JSON.parse(watchRes.body);
+    assert.equal(watchBody.ok, false);
+    assert.equal(watchBody.reason, 'payments-disabled');
+    assert.match(watchBody.error, /payments are disabled/);
 });
 test('deposits/watch returns 503 when no watcher is attached', async () => {
     const proxy = new BuyerProxy({
@@ -2585,7 +2737,7 @@ test('deposits/watch promotes and demotes an attached watcher and returns its st
     assert.equal(invalid.statusCode, 400);
     assert.deepEqual(calls, ['promote', 'demote']);
     const status = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/_antseed/deposits/status' }));
-    assert.deepEqual(JSON.parse(status.body), { ok: true, watcher: true, status: fakeStatus });
+    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({