@antseed/cli 0.1.189 → 0.1.191

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

@@ -21,15 +21,15 @@ function makePeer(seed, providers) {
         providers,
     };
 }
-test('the buyer switches between a model and a model-routing service without replacing the plugin', async () => {
+test('the buyer switches between a model and a routing service without replacing the plugin', async () => {
     const inferencePeer = makeRankedRoutingFixture().peers[0];
     const routingPeer = makePeer('d', ['alpha']);
     routingPeer.metadata = {
         peerId: routingPeer.peerId, version: 12, timestamp: Date.now(), signature: '', region: 'test',
         providers: [{ provider: 'alpha', services: ['alpha-route'], maxConcurrency: 1, currentLoad: 0,
                 defaultPricing: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 },
-                serviceApiProtocols: { 'alpha-route': ['model-routing'] },
-                serviceUnitBillingModels: { 'alpha-route': { 'model-routing': {
+                serviceApiProtocols: { 'alpha-route': ['irp-suggest'] },
+                serviceUnitBillingModels: { 'alpha-route': { 'irp-suggest': {
                             version: 1, components: [{ unit: 'completed_requests', priceUsd: 0.001 }],
                         } } },
             }],
@@ -73,8 +73,18 @@ test('the buyer switches between a model and a model-routing service without rep
     assert.equal((await setModel()).statusCode, 200);
     assert.equal((await infer()).statusCode, 200);
     assert.equal(requests.length, 1);
-    const selection = { kind: 'router', service: { peerId: routingPeer.peerId, provider: 'alpha', serviceId: 'alpha-route' }, costQualityTradeoff: 1 };
+    const selection = { kind: 'router', service: { peerId: routingPeer.peerId, provider: 'alpha', serviceId: 'alpha-route' }, options: { cost_quality_tradeoff: 1 } };
+    // Options are checked against the router's advertised protocol (irp-suggest) when it is saved.
+    for (const options of [{ cost_quality_tradeoff: 11 }, { cost_quality_tradeoff: 2.5 }, { tier: 'fast' }]) {
+        const refused = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ ...selection, options }) }));
+        assert.equal(refused.statusCode, 400, refused.body);
+    }
     assert.equal((await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody(selection) }))).statusCode, 200);
+    // ...and per request, before any ranking is bought.
+    const badRequest = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }], routing: { cost_quality_tradeoff: 11 } } }));
+    assert.equal(badRequest.statusCode, 400, badRequest.body);
+    assert.equal(JSON.parse(badRequest.body).error.code, 'invalid_routing');
+    assert.equal(requests.length, 1);
     const routed = await infer();
     assert.equal(routed.statusCode, 200, routed.body);
     assert.deepEqual(requests.map(request => request.path.split('?')[0]), ['/v1/chat/completions', '/v1/routing/models', '/v1/routing/rank', '/v1/chat/completions']);
@@ -138,7 +148,7 @@ test('the buyer and chat router selections pass their cost/quality tradeoff to t
     routingPeer.metadata = { peerId: routingPeer.peerId, version: 12, region: 'test', timestamp: Date.now(), signature: '',
         providers: [{ provider: 'alternative', services: ['route'], maxConcurrency: 1, currentLoad: 0,
                 defaultPricing: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 },
-                serviceApiProtocols: { route: ['model-routing'] },
+                serviceApiProtocols: { route: ['irp-suggest'] },
             }] };
     const contexts = [];
     const client = {
@@ -166,31 +176,31 @@ test('the buyer and chat router selections pass their cost/quality tradeoff to t
     };
     const target = { peerId: routingPeer.peerId, provider: 'alternative', serviceId: 'route' };
     const select = (costQualityTradeoff) => invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route',
-        body: routeBody({ kind: 'router', service: target, ...(costQualityTradeoff !== undefined ? { costQualityTradeoff } : {}) }) }));
+        body: routeBody({ kind: 'router', service: target, ...(costQualityTradeoff !== undefined ? { options: { cost_quality_tradeoff: costQualityTradeoff } } : {}) }) }));
     const chosen = await select(0);
     assert.equal(chosen.statusCode, 200, chosen.body);
     const response = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(response.statusCode, 200, response.body);
     assert.equal(contexts.length, 1);
     assert.equal(inferenceCalls, 1);
-    assert.equal(contexts[0].costQualityTradeoff, 0);
+    assert.equal(contexts[0].options?.cost_quality_tradeoff, 0);
     assert.deepEqual(contexts[0].routingService, target);
     assert.equal((await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ kind: 'router', service: target }) }))).statusCode, 200);
     store.touch({ tool: 'vpr', sessionKey: 'client-chat' });
     const selectChat = (costQualityTradeoff) => invokeProxy(proxy, makeProxyRequest({
-        path: '/_antseed/conversations/update', body: { id: 'vpr:client-chat', routingSelection: { kind: 'router', service: target, costQualityTradeoff } },
+        path: '/_antseed/conversations/update', body: { id: 'vpr:client-chat', routingSelection: { kind: 'router', service: target, options: { cost_quality_tradeoff: costQualityTradeoff } } },
     }));
     assert.equal((await selectChat(10)).statusCode, 200);
     const chatResponse = await invokeProxy(proxy, makeProxyRequest({ headers: { 'x-vpr-session-id': 'client-chat' },
         body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }] },
     }));
     assert.equal(chatResponse.statusCode, 200, chatResponse.body);
-    assert.equal(contexts[1].costQualityTradeoff, 10);
+    assert.equal(contexts[1].options?.cost_quality_tradeoff, 10);
     assert.deepEqual(contexts[1].routingService, target);
     assert.equal((await select()).statusCode, 200);
     const defaultResponse = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(defaultResponse.statusCode, 200, defaultResponse.body);
-    assert.equal(contexts[2].costQualityTradeoff, undefined);
+    assert.equal(contexts[2].options?.cost_quality_tradeoff, undefined);
     assert.equal(contexts.length, 3);
     assert.equal(inferenceCalls, 3);
 });
@@ -279,7 +289,7 @@ function setRouter(proxy, selection) {
     proxy._defaultRoutedModel = null;
     proxy._defaultRouter = selection;
 }
-/** `POST /_antseed/route` body: `{ model }` for a model, `{ router: { service, costQualityTradeoff } }` for a router. */
+/** `POST /_antseed/route` body: `{ model }` for a model, `{ router: { service, options } }` for a router. */
 function routeBody(selection) {
     if (selection.kind === 'model')
         return { model: selection.model ?? '' };
@@ -287,7 +297,7 @@ function routeBody(selection) {
     return { router };
 }
 function chatRouterSelection(peer, costQualityTradeoff) {
-    return { kind: 'router', service: { peerId: peer.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, costQualityTradeoff };
+    return { kind: 'router', service: { peerId: peer.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, options: { cost_quality_tradeoff: costQualityTradeoff } };
 }
 async function makeConversationRoutingFixture(context) {
     const fixture = makeRankedRoutingFixture([]);
@@ -320,18 +330,18 @@ test('chats keep independent routing-service targets and tradeoffs while unconfi
     assert.equal((await update('chat-b', second)).statusCode, 200);
     for (const session of ['chat-a', 'chat-b', 'chat-c'])
         assert.equal((await request(session)).statusCode, 200);
-    assert.deepEqual(captured.map(entry => [entry.routingService, entry.costQualityTradeoff]), [first, second, chatRouterSelection('c', 5)].map(selection => [selection.service, selection.costQualityTradeoff]));
+    assert.deepEqual(captured.map(entry => [entry.routingService, entry.options?.cost_quality_tradeoff]), [first, second, chatRouterSelection('c', 5)].map(selection => [selection.service, selection.options?.cost_quality_tradeoff]));
     setRouter(proxy, chatRouterSelection('f', 3));
     for (const session of ['chat-a', 'chat-b', 'chat-c'])
         assert.equal((await request(session)).statusCode, 200);
-    assert.deepEqual(captured.slice(3).map(entry => [entry.routingService, entry.costQualityTradeoff]), [first, second, chatRouterSelection('f', 3)].map(selection => [selection.service, selection.costQualityTradeoff]));
+    assert.deepEqual(captured.slice(3).map(entry => [entry.routingService, entry.options?.cost_quality_tradeoff]), [first, second, chatRouterSelection('f', 3)].map(selection => [selection.service, selection.options?.cost_quality_tradeoff]));
     assert.equal(store.get('vpr:chat-c')?.routingSelection, null);
     const get = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/conversations/vpr%3Achat-a', method: 'GET' }));
     assert.deepEqual(JSON.parse(get.body).conversation.routingSelection, first);
     assert.equal((await update('chat-a', null)).statusCode, 200);
     assert.equal((await request('chat-a')).statusCode, 200);
     assert.deepEqual(captured.at(-1).routingService, chatRouterSelection('f', 3).service);
-    assert.equal(captured.at(-1).costQualityTradeoff, 3);
+    assert.equal(captured.at(-1).options?.cost_quality_tradeoff, 3);
 });
 test('chat routing overrides beat the buyer model default, inherit into children, and yield to explicit model pins', async (context) => {
     const { proxy, peers, calls, captured, update, request, store } = await makeConversationRoutingFixture(context);
@@ -362,7 +372,7 @@ test('chat routing updates reject malformed selections without partially changin
     assert.equal((await update('chat-a', selection)).statusCode, 200);
     for (const invalid of [[], { kind: 'model', model: 'model-a' }, { kind: 'router' },
         { ...selection, service: { ...selection.service, peerId: 'invalid' } },
-        { ...selection, costQualityTradeoff: 11 }, { ...selection, costQualityTradeoff: 2.5 }, { ...selection, preferences: { tradeoff: '9' } }]) {
+        { ...selection, options: { cost_quality_tradeoff: {} } }, { ...selection, options: [] }, { ...selection, costQualityTradeoff: 5 }, { ...selection, preferences: { tradeoff: '9' } }]) {
         assert.equal((await update('chat-a', invalid)).statusCode, 400);
         assert.deepEqual(store.get('vpr:chat-a')?.routingSelection, selection);
     }
@@ -382,7 +392,7 @@ test('persisted chat overrides route after reload and fail closed when the route
     await store.flush();
     proxy._conversations = new ConversationStore(directory);
     assert.equal((await request('chat-a')).statusCode, 200);
-    assert.equal(captured[0].costQualityTradeoff, selection.costQualityTradeoff);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, selection.options?.cost_quality_tradeoff);
     client.listModels = listModelsWith(['model-z']);
     proxy._routingModels.invalidate(selection.service);
     assert.equal((await request('chat-a')).statusCode, 422);
@@ -421,15 +431,15 @@ test('chat and buyer selection changes leave in-flight requests using their orig
     for (const response of await Promise.all([first, second, inherited]))
         assert.equal(response.statusCode, 200);
 });
-/** A peer advertising one `model-routing` service, `alpha-route`. */
+/** A peer advertising one `irp-suggest` routing service, `alpha-route`. */
 function makeRoutingPeer(seed) {
     const peer = makePeer(seed, ['alpha']);
     peer.metadata = {
         peerId: peer.peerId, version: 12, timestamp: Date.now(), signature: '', region: 'test',
         providers: [{ provider: 'alpha', services: ['alpha-route'], maxConcurrency: 1, currentLoad: 0,
                 defaultPricing: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 },
-                serviceApiProtocols: { 'alpha-route': ['model-routing'] },
-                serviceUnitBillingModels: { 'alpha-route': { 'model-routing': {
+                serviceApiProtocols: { 'alpha-route': ['irp-suggest'] },
+                serviceUnitBillingModels: { 'alpha-route': { 'irp-suggest': {
                             version: 1, components: [{ unit: 'completed_requests', priceUsd: 0.001 }],
                         } } },
             }],
@@ -457,7 +467,7 @@ test('a routing service pinned as the model ranks and serves the request without
     assert.equal(response.statusCode, 200, response.body);
     assert.equal(calls.routing, 1);
     assert.deepEqual(captured[0].routingService, target);
-    assert.equal(captured[0].costQualityTradeoff, undefined);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, undefined);
     assert.equal(calls.requests.length, 1);
     assert.equal(calls.requests[0].peer.peerId, peers[0].peerId);
     assert.equal(JSON.parse(Buffer.from(calls.requests[0].request.body).toString()).model, 'model-a');
@@ -468,7 +478,7 @@ test('the body routing object sets the tradeoff for a pinned router and never re
             model, messages: [{ role: 'user', content: 'Hello' }], routing: { cost_quality_tradeoff: 7 },
         } }));
     assert.equal(response.statusCode, 200, response.body);
-    assert.equal(captured[0].costQualityTradeoff, 7);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, 7);
     const sent = JSON.parse(Buffer.from(calls.requests[0].request.body).toString());
     assert.equal('routing' in sent, false);
     const direct = await invokeProxy(proxy, makeProxyRequest({ body: {
@@ -482,28 +492,28 @@ test('the body routing object sets the tradeoff for a pinned router and never re
 });
 test('the body routing tradeoff overrides the buyer default router tradeoff', async () => {
     const { proxy, captured } = makePinnedRouterFixture();
-    setRouter(proxy, { kind: 'router', service: { peerId: 'd'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, costQualityTradeoff: 1 });
+    setRouter(proxy, { kind: 'router', service: { peerId: 'd'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, options: { cost_quality_tradeoff: 1 } });
     const response = await invokeProxy(proxy, makeProxyRequest({ body: {
             model: 'antseed', messages: [{ role: 'user', content: 'Hello' }], routing: { cost_quality_tradeoff: 9 },
         } }));
     assert.equal(response.statusCode, 200, response.body);
-    assert.equal(captured[0].costQualityTradeoff, 9);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, 9);
 });
 test('a pinned router without a routing object uses the saved settings for that router only', async () => {
     const { proxy, peers, captured, target, model } = makePinnedRouterFixture();
-    setRouter(proxy, { kind: 'router', service: target, costQualityTradeoff: 3, allowedModels: [{ provider: 'openai', serviceId: 'model-b' }] });
+    setRouter(proxy, { kind: 'router', service: target, options: { cost_quality_tradeoff: 3 }, allowedModels: [{ provider: 'openai', serviceId: 'model-b' }] });
     const saved = await invokeProxy(proxy, makeProxyRequest({ body: { model, messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(saved.statusCode, 200, saved.body);
-    assert.equal(captured[0].costQualityTradeoff, 3);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, 3);
     assert.deepEqual([...new Set(captured[0].candidates.map((candidate) => candidate.serviceId))], ['model-b']);
     const overridden = await invokeProxy(proxy, makeProxyRequest({ body: { model, messages: [{ role: 'user', content: 'Hello' }], routing: { cost_quality_tradeoff: 9 } } }));
     assert.equal(overridden.statusCode, 200, overridden.body);
-    assert.equal(captured[1].costQualityTradeoff, 9);
+    assert.equal(captured[1].options?.cost_quality_tradeoff, 9);
     assert.deepEqual([...new Set(captured[1].candidates.map((candidate) => candidate.serviceId))], ['model-b']);
-    setRouter(proxy, { kind: 'router', service: { ...target, peerId: 'e'.repeat(40) }, costQualityTradeoff: 3, allowedModels: [{ provider: 'openai', serviceId: 'model-b' }] });
+    setRouter(proxy, { kind: 'router', service: { ...target, peerId: 'e'.repeat(40) }, options: { cost_quality_tradeoff: 3 }, allowedModels: [{ provider: 'openai', serviceId: 'model-b' }] });
     const other = await invokeProxy(proxy, makeProxyRequest({ body: { model, messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(other.statusCode, 200, other.body);
-    assert.equal(captured[2].costQualityTradeoff, undefined);
+    assert.equal(captured[2].options?.cost_quality_tradeoff, undefined);
     assert.ok(captured[2].candidates.some((candidate) => candidate.serviceId === 'model-a'));
     assert.ok(peers.length > 0);
 });
@@ -514,7 +524,7 @@ test('a router pinned as the default route serves the antseed alias through that
     assert.equal(response.statusCode, 200, response.body);
     assert.equal(calls.routing, 1);
     assert.deepEqual(captured[0].routingService, target);
-    assert.equal(captured[0].costQualityTradeoff, 6);
+    assert.equal(captured[0].options?.cost_quality_tradeoff, 6);
     assert.equal(calls.requests[0].peer.peerId, peers[0].peerId);
     assert.equal(JSON.parse(Buffer.from(calls.requests[0].request.body).toString()).model, 'model-a');
 });
@@ -569,7 +579,7 @@ test('a chat\'s own router wins over a router pinned as the default route', asyn
     assert.equal(chatTurn.statusCode, 200, chatTurn.body);
     const plain = await turn();
     assert.equal(plain.statusCode, 200, plain.body);
-    assert.deepEqual(captured.map((entry) => [entry.routingService.peerId, entry.costQualityTradeoff]), [[chatRouter.peerId, 9], [routingPeer.peerId, undefined]]);
+    assert.deepEqual(captured.map((entry) => [entry.routingService.peerId, entry.options?.cost_quality_tradeoff]), [[chatRouter.peerId, 9], [routingPeer.peerId, undefined]]);
     assert.equal(calls.routing, 2);
 });
 test('an automatic chat route never turns a seller into a router pin', async (context) => {
@@ -675,28 +685,28 @@ test('a pinned service that is not the peer\'s routing service is a normal selle
     assert.equal(calls.routing, 0);
     assert.equal(calls.requests[0].peer.peerId, peers[1].peerId);
 });
-test('routing selection carries the tradeoff, rejects invalid values and preserves model mode', async () => {
+test('routing selection carries router options, rejects malformed ones and preserves model mode', async () => {
     const { proxy, calls } = makeRankedRoutingFixture([200, 200, 200, 200]);
     const client = proxy._modelRoutingClient;
     const captured = [];
     const select = client.selectRoute;
     client.selectRoute = (request, peers, context) => {
-        captured.push({ tradeoff: context.costQualityTradeoff, target: context.routingService });
+        captured.push({ tradeoff: context.options?.cost_quality_tradeoff, target: context.routingService });
         return select(request, peers, context);
     };
     proxy._mergeStateFile = async () => { };
     setDefaultModel(proxy, 'stale-model');
     const service = { peerId: 'd'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' };
-    const selected = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ kind: 'router', service, costQualityTradeoff: 9 }) }));
+    const selected = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ kind: 'router', service, options: { cost_quality_tradeoff: 9 } }) }));
     assert.equal(selected.statusCode, 200, selected.body);
     const first = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(first.statusCode, 200, first.body);
     assert.deepEqual(captured[0], { tradeoff: 9, target: service });
-    const updated = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ kind: 'router', service, costQualityTradeoff: 1 }) }));
+    const updated = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody({ kind: 'router', service, options: { cost_quality_tradeoff: 1 } }) }));
     assert.equal(updated.statusCode, 200, updated.body);
     await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [{ role: 'user', content: 'Hello' }] } }));
     assert.equal(captured[1].tradeoff, 1);
-    for (const selection of [{ kind: 'router', service, costQualityTradeoff: -1 }, { kind: 'router', service, costQualityTradeoff: '5' }, { kind: 'router', service, preferences: { tradeoff: '9' } }]) {
+    for (const selection of [{ kind: 'router', service, options: { cost_quality_tradeoff: null } }, { kind: 'router', service, options: 'cheap' }, { kind: 'router', service, preferences: { tradeoff: '9' } }]) {
         const invalid = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: routeBody(selection) }));
         assert.equal(invalid.statusCode, 400, invalid.body);
     }
@@ -772,7 +782,7 @@ test('explicit routing-service target and tradeoff survive the local state-file
     const client = proxy._modelRoutingClient;
     const stateFile = join(directory, 'buyer.state.json');
     proxy._stateFile = stateFile;
-    const selection = { kind: 'router', service: { peerId: 'c'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, costQualityTradeoff: 9 };
+    const selection = { kind: 'router', service: { peerId: 'c'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' }, options: { cost_quality_tradeoff: 9 } };
     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);
@@ -809,7 +819,7 @@ test('config reload updates eligibility policy without replacing the active rout
     proxy._configPath = path;
     proxy._mergeStateFile = async () => { assert.fail('Config reload must not persist selection'); };
     const service = { peerId: 'c'.repeat(40), provider: 'alpha', serviceId: 'alpha-route' };
-    const activeSelection = { kind: 'router', service, costQualityTradeoff: 5 };
+    const activeSelection = { kind: 'router', service, options: { cost_quality_tradeoff: 5 } };
     setRouter(proxy, activeSelection);
     for (const maxInputUsdPerMillion of [15, 25]) {
         const routingPreferences = { ...priceAndTrustPreferences, maxInputUsdPerMillion };
@@ -905,7 +915,7 @@ test('changing model selection affects the next request without cancelling the c
     assert.equal(next.statusCode, 200);
     assert.equal(JSON.parse(Buffer.from(calls.requests[1].request.body).toString()).model, 'model-b');
 });
-test('client disconnect still cancels a pending model-routing decision', { timeout: 5_000 }, async () => {
+test('client disconnect still cancels a pending routing decision', { timeout: 5_000 }, async () => {
     const { proxy, calls } = makeRankedRoutingFixture([200]);
     const client = proxy._modelRoutingClient;
     let started;
@@ -1301,7 +1311,7 @@ test('ordinary requests keep attributing spend after the conversation already ex
     assert.equal(conversation.requestCount, 2);
     assert.equal(conversation.inputTokens, '8');
 });
-test('model and model-routing requests use the same duplicate tracking guard', () => {
+test('model and routing requests use the same duplicate tracking guard', () => {
     const proxy = makeBuyerProxyWithPeers([]);
     for (const purpose of [undefined, 'routing']) {
         const requestId = randomUUID();
@@ -4136,7 +4146,7 @@ test('route control endpoint sets, persists, and returns the default routed mode
     assert.equal(automaticPersisted['defaultRoutedModel'], 'gpt-4o');
     const invalid = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: { model: 'not-a-peer@gpt-4o' } }));
     assert.equal(invalid.statusCode, 400);
-    const router = { service: { peerId: validPeerId, provider: 'alpha', serviceId: 'alpha-route' }, costQualityTradeoff: 5 };
+    const router = { service: { peerId: validPeerId, provider: 'alpha', serviceId: 'alpha-route' }, options: { cost_quality_tradeoff: 5 } };
     const routed = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: { router } }));
     assert.deepEqual(JSON.parse(routed.body), { ok: true, model: null, router });
     const routedPersisted = JSON.parse(await readFile(join(dir, 'buyer.state.json'), 'utf-8'));