@antseed/cli 0.1.168 → 0.1.170

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

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
 import test from 'node:test';
+import { ResourceRoutes } from './resource-routes.js';
 import { ANTSEED_BUYER_FAULT_ERROR_CODE, ANTSEED_FAULT_ATTRIBUTION_HEADER, CONNECTION_CAPABILITY_COOPERATIVE_CLOSE_V1, CONNECTION_CAPABILITY_RELAYS_SWEEPS_V1, adaptPeerFaultErrorResponse, buyerFault, computeTrustScore, } from '@antseed/node';
 import { DEFAULT_BUYER_PEER_REFRESH_INTERVAL_MS } from '../config/defaults.js';
 import { TeeVerification } from './tee-verification.js';
@@ -18,6 +19,149 @@ function makePeer(seed, providers) {
         providers,
     };
 }
+for (const provider of ['venice']) {
+    test(`native ${provider} routes concurrent jobs independently, persist before returning, and survive pin changes`, async () => {
+        const protocol = 'venice-video';
+        const resourceId = (suffix) => `task-${suffix}`;
+        const statusPath = '/api/v1/video/retrieve';
+        const directory = await mkdtemp(join(tmpdir(), 'native-video-routes-'));
+        try {
+            const peers = [makePeer('a', [provider]), makePeer('b', [provider])];
+            for (const [index, peer] of peers.entries()) {
+                peer.providerServiceApiProtocols = { [provider]: { services: { [`model-${index}`]: [protocol] } } };
+            }
+            const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter());
+            proxy._stateDir = directory;
+            proxy._stateFile = join(directory, 'buyer.state.json');
+            await writeFile(join(directory, 'buyer.state.json'), JSON.stringify({ unrelated: 'preserved' }));
+            const calls = [];
+            const send = async (peer, request) => {
+                calls.push({ peer: peer.peerId, path: request.path, service: request.headers['x-antseed-service'], provider: request.headers['x-antseed-provider'] });
+                if (request.method === 'POST' && peer === peers[0])
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                return { requestId: request.requestId, statusCode: 200, headers: { 'content-type': 'application/json' }, body: Buffer.from(JSON.stringify({ queue_id: resourceId(peer.peerId[0]) })) };
+            };
+            proxy._node.sendRequest = send;
+            proxy._node.sendRequestStream = send;
+            const submissions = await Promise.all([0, 1].map(index => invokeProxy(proxy, makeProxyRequest({ path: '/api/v1/video/queue', body: { model: `model-${index}`, duration: '8s', prompt: 'cat' } }))));
+            assert.deepEqual(submissions.map(result => result.statusCode), [200, 200]);
+            const state = JSON.parse(await readFile(join(directory, 'buyer.state.json'), 'utf8'));
+            assert.equal(state.unrelated, 'preserved');
+            assert.equal(state.resourceRoutes.length, 2);
+            const restored = new ResourceRoutes();
+            restored.hydrate(state.resourceRoutes);
+            const restarted = makeBuyerProxyWithPeers(peers, peers, permissiveRouter());
+            restarted._stateDir = directory;
+            restarted._stateFile = join(directory, 'buyer.state.json');
+            restarted._resourceRoutes = restored;
+            restarted._node.sendRequest = proxy._node.sendRequest;
+            restarted._node.sendRequestStream = proxy._node.sendRequestStream;
+            restarted._pinnedPeer = peers[1].peerId;
+            restarted._defaultRoutedModel = `${peers[1].peerId}@unrelated-chat-model`;
+            for (const [index, suffix] of ['a', 'b'].entries()) {
+                const result = await invokeProxy(restarted, makeProxyRequest({ method: 'POST', path: statusPath, body: { model: `model-${index}`, queue_id: resourceId(suffix) } }));
+                assert.equal(result.statusCode, 200);
+                assert.equal(calls.at(-1)?.peer, peers[index].peerId);
+                assert.equal(calls.at(-1)?.service, `model-${index}`);
+                assert.equal(calls.at(-1)?.provider, provider);
+            }
+            const recorded = await invokeProxy(restarted, makeProxyRequest({ method: 'POST', path: statusPath, body: { model: 'model-0', queue_id: resourceId('a') }, headers: { 'x-antseed-pin-peer': peers[1].peerId } }));
+            assert.equal(recorded.statusCode, 200);
+            assert.equal(calls.at(-1)?.peer, peers[0].peerId);
+            await proxy._stateWriteChain;
+            await restarted._stateWriteChain;
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true, maxRetries: 3 });
+        }
+    });
+}
+test('native video resolves antseed and peer-pinned models like images', async () => {
+    const cases = [
+        { provider: 'venice', protocol: 'venice-video', path: '/api/v1/video/queue', acceptance: { queue_id: 'queue' } },
+    ];
+    for (const { provider, protocol, path, acceptance } of cases) {
+        const peers = [makePeer('a', [provider]), makePeer('b', [provider])];
+        for (const peer of peers)
+            peer.providerServiceApiProtocols = { [provider]: { services: { 'video-model': [protocol] } } };
+        for (const model of ['antseed', `${peers[1].peerId}@video-model`]) {
+            const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter());
+            proxy._defaultRoutedModel = `${peers[1].peerId}@video-model`;
+            proxy._persistResourceRoutes = async () => { };
+            const sent = [];
+            proxy._node.sendRequest = async (selected, request) => {
+                const body = JSON.parse(Buffer.from(request.body).toString());
+                sent.push({ peer: selected.peerId, model: body.model, custom: body.custom });
+                return { requestId: request.requestId, statusCode: 200, headers: { 'content-type': 'application/json' }, body: Buffer.from(JSON.stringify(acceptance)) };
+            };
+            const response = await invokeProxy(proxy, makeProxyRequest({ path, body: { model, prompt: 'cat', duration: 5, custom: { prompt: '猫' } } }));
+            assert.equal(response.statusCode, 200, response.body);
+            assert.deepEqual(sent, [{ peer: peers[1].peerId, model: 'video-model', custom: { prompt: '猫' } }]);
+        }
+    }
+});
+test('native resource follow-ups fail when the recorded provider loses support instead of switching providers', async () => {
+    for (const provider of ['venice']) {
+        const protocol = 'venice-video';
+        const peer = makePeer('a', [provider, 'replacement']);
+        peer.providerServiceApiProtocols = { [provider]: { services: { other: [protocol] } }, replacement: { services: { 'video-model': [protocol] } } };
+        const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+        proxy._persistResourceRoutes = async () => { };
+        const resourceId = 'task';
+        proxy._resourceRoutes.record({ protocol, resourceId, sellerPeerId: peer.peerId, provider, service: 'video-model' });
+        let calls = 0;
+        proxy._node.sendRequest = async () => { calls += 1; throw new Error('must not dispatch'); };
+        const response = await invokeProxy(proxy, makeProxyRequest({ method: 'POST', path: '/api/v1/video/retrieve', body: { model: 'video-model', queue_id: resourceId } }));
+        assert.ok(response.statusCode >= 400, response.body);
+        assert.equal(calls, 0);
+    }
+});
+test('native video creates are not retried automatically', async () => {
+    const peers = [makePeer('a', ['venice']), makePeer('b', ['venice'])];
+    for (const peer of peers)
+        peer.providerServiceApiProtocols = { venice: { services: { model: ['venice-video'] } } };
+    const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter());
+    const sent = [];
+    proxy._node.sendRequest = async (_peer, request) => {
+        sent.push(request);
+        throw new Error('uncertain connection loss');
+    };
+    const result = await invokeProxy(proxy, makeProxyRequest({ path: '/api/v1/video/queue', body: { model: 'model', duration: '8s' } }));
+    assert.ok(result.statusCode >= 400);
+    assert.equal(sent.length, 1);
+    assert.equal(sent[0].headers['x-antseed-pin-peer'], undefined);
+});
+test('native video options are validated by the seller without buyer filtering or retries', async () => {
+    const peers = [makePeer('a', ['venice']), makePeer('b', ['venice'])];
+    for (const peer of peers)
+        peer.providerServiceApiProtocols = { venice: { services: { model: ['venice-video'] } } };
+    peers[0].reputationScore = 99;
+    peers[1].reputationScore = 70;
+    peers[0].providerServiceCapabilities = { venice: { services: { model: { video: { durationsSeconds: [5] } } } } };
+    peers[1].providerServiceCapabilities = { venice: { services: { model: { video: { durationsSeconds: [5, 10, 15] } } } } };
+    const proxy = makeBuyerProxyWithPeers(peers, peers, permissiveRouter());
+    proxy._persistResourceRoutes = async () => { };
+    const selected = [];
+    const forwarded = [];
+    const sellerError = { error: { code: 'unsupported_video_options', message: 'Seller does not support this duration' } };
+    proxy._node.sendRequest = async (peer, request) => {
+        selected.push(peer.peerId);
+        const body = JSON.parse(Buffer.from(request.body).toString());
+        forwarded.push(body);
+        if (body.duration === '15s') {
+            return { requestId: request.requestId, statusCode: 422, headers: { 'content-type': 'application/json' }, body: Buffer.from(JSON.stringify(sellerError)) };
+        }
+        return { requestId: request.requestId, statusCode: 200, headers: { 'content-type': 'application/json' }, body: Buffer.from(JSON.stringify({ id: 'task' })) };
+    };
+    const create = (duration) => invokeProxy(proxy, makeProxyRequest({ path: '/api/v1/video/queue', body: { model: 'model', duration: `${duration}s` } }));
+    assert.equal((await create(10)).statusCode, 200);
+    assert.deepEqual(selected, [peers[0].peerId]);
+    const rejected = await create(15);
+    assert.equal(rejected.statusCode, 422, rejected.body);
+    assert.deepEqual(JSON.parse(rejected.body), sellerError);
+    assert.deepEqual(selected, [peers[0].peerId, peers[0].peerId]);
+    assert.deepEqual(forwarded, [{ model: 'model', duration: '10s' }, { model: 'model', duration: '15s' }]);
+});
 test('existing required CLI verification rejects a failed pin without payment/inference and auto falls back to a verified seller', async () => {
     const rejected = makePeer('a', ['openai']);
     const accepted = makePeer('b', ['openai']);
@@ -53,7 +197,7 @@ test('existing required CLI verification rejects a failed pin without payment/in
     assert.deepEqual(dispatches, [accepted.peerId, accepted.peerId]);
 });
 function makeProxyRequest(options) {
-    const body = JSON.stringify(options.body ?? { model: 'gpt-4o', messages: [] });
+    const body = options.rawBody ?? JSON.stringify(options.body ?? { model: 'gpt-4o', messages: [] });
     const req = Readable.from([Buffer.from(body)]);
     req.method = options.method ?? 'POST';
     req.url = options.path ?? '/v1/chat/completions';
@@ -1147,6 +1291,18 @@ test('model-only routing does not fail over after a buyer-attributed failure', a
     assert.deepEqual(attempts, [first.peerId]);
     assert.equal(JSON.parse(res.body).error.code, ANTSEED_BUYER_FAULT_ERROR_CODE);
 });
+test('video validation and buyer budget failures return client errors without penalizing sellers', async () => {
+    for (const [code, status] of [['invalid-request', 400], ['buyer-budget-too-low', 422]]) {
+        const peer = makePeer('a', ['venice']);
+        peer.providerServiceApiProtocols = { venice: { services: { video: ['venice-video'] } } };
+        const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+        proxy._node.sendRequest = async () => { throw buyerFault('Invalid video request', code); };
+        const result = await invokeProxy(proxy, makeProxyRequest({ path: '/api/v1/video/queue', body: { model: 'video', prompt: 'boat' } }));
+        assert.equal(result.statusCode, status);
+        assert.equal(JSON.parse(result.body).error.code, ANTSEED_BUYER_FAULT_ERROR_CODE);
+        assert.equal(proxy._peerHealth.get(peer.peerId)?.failureStreak ?? 0, 0);
+    }
+});
 test('pinned proxy request reports when the pinned peer is not discoverable', async () => {
     const pinnedPeerId = 'a'.repeat(40);
     const otherPeer = makePeer('b', ['openai']);