@antseed/cli 0.1.147 → 0.1.149

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

@@ -5,7 +5,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 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, } from '@antseed/node';
+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 { overrideRoutedModelInBody, SYSTEM_ROUTED_MODEL_HEADER } from './request-utils.js';
@@ -58,7 +58,7 @@ function makeProxyResponse() {
         },
     };
 }
-function makeBuyerProxyWithPeers(initialPeers, refreshedPeers = initialPeers, router = null, now) {
+function makeBuyerProxyWithPeers(initialPeers, refreshedPeers = initialPeers, router = null, now, routingPreferences) {
     const proxy = new BuyerProxy({
         port: 0,
         dataDir: '/tmp/antseed-test',
@@ -66,11 +66,19 @@ function makeBuyerProxyWithPeers(initialPeers, refreshedPeers = initialPeers, ro
             router,
         },
         ...(now ? { now } : {}),
+        ...(routingPreferences ? { routingPreferences } : {}),
     });
     proxy._getPeers = async (options) => options?.forceRefresh ? refreshedPeers : initialPeers;
     proxy._cacheLastUpdatedAtMs = Date.now();
     return proxy;
 }
+const priceAndTrustPreferences = {
+    preferFreePeers: false,
+    maxInputUsdPerMillion: 25,
+    minTrustScore: 60,
+    allowedPeerIds: [],
+    blockedPeerIds: [],
+};
 /**
  * A hand-cranked clock for peer-health tests.
  *
@@ -122,6 +130,38 @@ test('BuyerProxy accepts a custom background refresh interval', () => {
     });
     assert.equal(proxy._bgRefreshIntervalMs, 15_000);
 });
+test('BuyerProxy reloads model routing preferences from config', async (t) => {
+    const dataDir = await mkdtemp(join(tmpdir(), 'antseed-routing-config-'));
+    const configPath = join(dataDir, 'config.json');
+    t.after(() => rm(dataDir, { recursive: true, force: true }));
+    const allowedPeerId = 'a'.repeat(40);
+    await writeFile(configPath, JSON.stringify({
+        buyer: {
+            routingPreferences: {
+                preferFreePeers: true,
+                maxInputUsdPerMillion: 8,
+                minTrustScore: 72,
+                allowedPeerIds: [allowedPeerId],
+                blockedPeerIds: [],
+            },
+        },
+    }));
+    const proxy = new BuyerProxy({
+        port: 0,
+        dataDir,
+        configPath,
+        routingPreferences: priceAndTrustPreferences,
+        node: { router: null },
+    });
+    await proxy._reloadRoutingPreferences();
+    assert.deepEqual(proxy._routingPreferences, {
+        preferFreePeers: true,
+        maxInputUsdPerMillion: 8,
+        minTrustScore: 72,
+        allowedPeerIds: [allowedPeerId],
+        blockedPeerIds: [],
+    });
+});
 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 }));
@@ -330,6 +370,52 @@ test('selectCandidatePeersForRouting in lenient mode prefers exact service match
     assert.ok(plan, 'expected a route plan for the lenient-kept peer');
     assert.equal(plan.provider, 'local-llm');
     assert.equal(plan.selection?.requiresTransform, false);
+    assert.equal(plan.serviceId, 'llama');
+});
+test('selectCandidatePeersForRouting derives protocol from the selected cheapest alias', () => {
+    const peer = makePeer('a', ['openai', 'claude-oauth']);
+    peer.providerPricing = {
+        openai: { defaults: { inputUsdPerMillion: 5, outputUsdPerMillion: 25 }, services: { 'claude-opus-5': { inputUsdPerMillion: 5, outputUsdPerMillion: 25 } } },
+        'claude-oauth': { defaults: { inputUsdPerMillion: 1, outputUsdPerMillion: 5 }, services: { 'opus-5': { inputUsdPerMillion: 1, outputUsdPerMillion: 5 } } },
+    };
+    peer.providerServiceApiProtocols = {
+        openai: { services: { 'claude-opus-5': ['openai-chat-completions'] } },
+        'claude-oauth': { services: { 'opus-5': ['anthropic-messages'] } },
+    };
+    const result = selectCandidatePeersForRouting([peer], 'openai-chat-completions', 'Claude Opus 5', null);
+    const plan = result.routePlanByPeerId.get(peer.peerId);
+    assert.ok(plan);
+    assert.equal(plan.provider, 'claude-oauth');
+    assert.equal(plan.serviceId, 'opus-5');
+    assert.equal(plan.selection?.targetProtocol, 'anthropic-messages');
+    assert.equal(plan.selection?.requiresTransform, true);
+});
+test('selectCandidatePeersForRouting prefers a full service over a cheaper coding-only alias', () => {
+    const peer = makePeer('a', ['anthropic', 'claude-oauth']);
+    peer.providerPricing = {
+        anthropic: { defaults: { inputUsdPerMillion: 5, outputUsdPerMillion: 25 }, services: { 'claude-opus-5': { inputUsdPerMillion: 5, outputUsdPerMillion: 25 } } },
+        'claude-oauth': { defaults: { inputUsdPerMillion: 1, outputUsdPerMillion: 5 }, services: { 'opus-5-coding-only': { inputUsdPerMillion: 1, outputUsdPerMillion: 5 } } },
+    };
+    peer.providerServiceApiProtocols = {
+        anthropic: { services: { 'claude-opus-5': ['anthropic-messages'] } },
+        'claude-oauth': { services: { 'opus-5-coding-only': ['anthropic-messages'] } },
+    };
+    const result = selectCandidatePeersForRouting([peer], 'anthropic-messages', 'opus-5', null);
+    const plan = result.routePlanByPeerId.get(peer.peerId);
+    assert.ok(plan);
+    assert.equal(plan.provider, 'anthropic');
+    assert.equal(plan.serviceId, 'claude-opus-5');
+});
+test('selectCandidatePeersForRouting excludes coding-only-only peers from unrestricted requests', () => {
+    const peer = makePeer('a', ['claude-oauth']);
+    peer.providerServiceApiProtocols = {
+        'claude-oauth': { services: { 'opus-5-coding-only': ['anthropic-messages'] } },
+    };
+    const unrestricted = selectCandidatePeersForRouting([peer], 'anthropic-messages', 'opus-5', null);
+    assert.equal(unrestricted.candidatePeers.length, 0);
+    const explicit = selectCandidatePeersForRouting([peer], 'anthropic-messages', 'opus-5-coding-only', null);
+    assert.equal(explicit.candidatePeers.length, 1);
+    assert.equal(explicit.routePlanByPeerId.get(peer.peerId)?.serviceId, 'opus-5-coding-only');
 });
 test('selectCandidatePeersForRouting can still include peers without service protocol metadata', () => {
     const peerWithoutMetadata = makePeer('a', ['openai']);
@@ -337,6 +423,545 @@ test('selectCandidatePeersForRouting can still include peers without service pro
     assert.equal(result.candidatePeers.length, 1);
     assert.equal(result.candidatePeers[0]?.peerId, peerWithoutMetadata.peerId);
 });
+test('model-only request routes to the highest-reputation canonical service match', async () => {
+    const lower = makePeer('a', ['anthropic']);
+    lower.reputationScore = 40;
+    lower.providerServiceApiProtocols = {
+        anthropic: { services: { 'Claude Opus 5': ['anthropic-messages'] } },
+    };
+    const higher = makePeer('b', ['anthropic']);
+    higher.reputationScore = 90;
+    higher.providerServiceApiProtocols = {
+        anthropic: { services: { 'opus-5': ['anthropic-messages'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([lower, higher], [lower, higher], permissiveRouter());
+    let selectedPeerId = '';
+    let selectedBody = null;
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        path: '/v1/messages',
+        body: { model: 'claude-opus-5', max_tokens: 32, messages: [] },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, higher.peerId);
+    assert.equal(selectedBody?.['model'], 'opus-5');
+});
+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;
+    preferred.providerServiceApiProtocols = {
+        openai: { services: { 'kimi-k3': ['openai-chat-completions'] } },
+    };
+    const rankedFirst = makePeer('d', ['openai']);
+    rankedFirst.reputationScore = 95;
+    rankedFirst.providerServiceApiProtocols = {
+        openai: { services: { 'Kimi K3': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([rankedFirst, preferred], [rankedFirst, preferred], permissiveRouter());
+    const attempts = [];
+    let preferredReachable = true;
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        assert.equal(request.headers['x-antstation-session-id'], undefined);
+        assert.equal(request.headers['x-antseed-prefer-peer'], undefined);
+        return {
+            requestId: request.requestId,
+            statusCode: peer.peerId === preferred.peerId && !preferredReachable ? 503 : 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const conversationHeaders = {
+        'x-antstation-session-id': 'conversation-soft-affinity',
+        'x-antseed-prefer-peer': preferred.peerId,
+    };
+    await invokeProxy(proxy, makeProxyRequest({
+        headers: conversationHeaders,
+        body: { model: 'kimi-k3', messages: [{ role: 'user', content: 'hello' }] },
+    }));
+    assert.deepEqual(attempts, [preferred.peerId]);
+    preferredReachable = false;
+    attempts.length = 0;
+    await invokeProxy(proxy, makeProxyRequest({
+        headers: { 'x-antstation-session-id': 'conversation-soft-affinity' },
+        body: { model: 'kimi-k3', messages: [{ role: 'user', content: 'again' }] },
+    }));
+    assert.deepEqual(attempts, [preferred.peerId, rankedFirst.peerId]);
+    const stored = proxy._conversations.get('antstation:conversation-soft-affinity');
+    assert.equal(stored?.pinnedModel, `${rankedFirst.peerId}@Kimi K3`);
+    assert.equal(stored?.lastModel, `${rankedFirst.peerId}@Kimi K3`);
+    attempts.length = 0;
+    await invokeProxy(proxy, makeProxyRequest({
+        headers: { 'x-antstation-session-id': 'conversation-soft-affinity' },
+        body: { model: 'kimi-k3', messages: [{ role: 'user', content: 'third' }] },
+    }));
+    assert.equal(attempts[0], rankedFirst.peerId);
+    const route = await invokeProxy(proxy, makeProxyRequest({
+        method: 'GET',
+        path: `/_antseed/conversations/${encodeURIComponent('antstation:conversation-soft-affinity')}`,
+    }));
+    assert.equal(route.statusCode, 200);
+    assert.equal(JSON.parse(route.body).conversation.lastModel, `${rankedFirst.peerId}@Kimi K3`);
+});
+test('model-only request applies a cached-input pricing reputation penalty', async () => {
+    const priced = makePeer('a', ['openai']);
+    priced.reputationScore = 75;
+    priced.providerPricing = {
+        openai: {
+            defaults: { inputUsdPerMillion: 2, outputUsdPerMillion: 4 },
+            services: {
+                'cache-model': { inputUsdPerMillion: 2, outputUsdPerMillion: 4, cachedInputUsdPerMillion: 0.2 },
+            },
+        },
+    };
+    priced.providerServiceApiProtocols = {
+        openai: { services: { 'cache-model': ['openai-chat-completions'] } },
+    };
+    const unpriced = makePeer('b', ['openai']);
+    unpriced.reputationScore = 90;
+    unpriced.providerPricing = {
+        openai: {
+            defaults: { inputUsdPerMillion: 1, outputUsdPerMillion: 2 },
+            services: { 'cache-model': { inputUsdPerMillion: 1, outputUsdPerMillion: 2 } },
+        },
+    };
+    unpriced.providerServiceApiProtocols = {
+        openai: { services: { 'cache-model': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([unpriced, priced], [unpriced, priced], permissiveRouter());
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'cache-model', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, priced.peerId);
+});
+test('model-only cached-input pricing penalty does not bury a substantially stronger peer', async () => {
+    const priced = makePeer('a', ['openai']);
+    priced.reputationScore = 20;
+    priced.providerPricing = {
+        openai: {
+            defaults: { inputUsdPerMillion: 2, outputUsdPerMillion: 4 },
+            services: {
+                'cache-model': { inputUsdPerMillion: 2, outputUsdPerMillion: 4, cachedInputUsdPerMillion: 0.2 },
+            },
+        },
+    };
+    priced.providerServiceApiProtocols = {
+        openai: { services: { 'cache-model': ['openai-chat-completions'] } },
+    };
+    const unpriced = makePeer('b', ['openai']);
+    unpriced.reputationScore = 100;
+    unpriced.providerServiceApiProtocols = {
+        openai: { services: { 'cache-model': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([priced, unpriced], [priced, unpriced], permissiveRouter());
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'cache-model', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, unpriced.peerId);
+});
+test('model-only request keeps reputation ordering when cached-input pricing is absent for all peers', async () => {
+    const lower = makePeer('a', ['openai']);
+    lower.reputationScore = 20;
+    lower.providerServiceApiProtocols = {
+        openai: { services: { 'no-cache-model': ['openai-chat-completions'] } },
+    };
+    const higher = makePeer('b', ['openai']);
+    higher.reputationScore = 100;
+    higher.providerServiceApiProtocols = {
+        openai: { services: { 'no-cache-model': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([lower, higher], [lower, higher], permissiveRouter());
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'no-cache-model', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, higher.peerId);
+});
+test('model-only request routes through a legacy peer-wide service announcement', async () => {
+    const peer = makePeer('a', ['openai']);
+    peer.services = ['gpt-5.6-terra'];
+    const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+    let selectedPeerId = '';
+    let selectedBody = null;
+    proxy._node.sendRequest = async (selectedPeer, request) => {
+        selectedPeerId = selectedPeer.peerId;
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        body: { model: 'gpt-56-terra', messages: [] },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, peer.peerId);
+    assert.equal(selectedBody?.['model'], 'gpt-5.6-terra');
+});
+test('model-only request routes when the request path has no detectable protocol', async () => {
+    const peer = makePeer('a', ['openai']);
+    peer.providerServiceApiProtocols = {
+        openai: { services: { 'embedding-model': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+    let selectedBody = null;
+    proxy._node.sendRequest = async (_peer, request) => {
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from('{}'),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        path: '/v1/models/custom-operation',
+        body: { model: 'embedding-model', input: 'hello' },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedBody?.['model'], 'embedding-model');
+});
+test('model-only request uses the cheapest duplicate service advertised by one peer', async () => {
+    const peer = makePeer('a', ['openai']);
+    peer.providerPricing = {
+        openai: {
+            defaults: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 },
+            services: {
+                'gpt-5.6-sol': { inputUsdPerMillion: 5, outputUsdPerMillion: 10 },
+                'gpt-56-sol': { inputUsdPerMillion: 1, outputUsdPerMillion: 2 },
+            },
+        },
+    };
+    peer.providerServiceApiProtocols = {
+        openai: {
+            services: {
+                'gpt-5.6-sol': ['openai-chat-completions'],
+                'gpt-56-sol': ['openai-chat-completions'],
+            },
+        },
+    };
+    const proxy = makeBuyerProxyWithPeers([peer], [peer], permissiveRouter());
+    let selectedBody = null;
+    proxy._node.sendRequest = async (_peer, request) => {
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        body: { model: 'gpt-5.6-sol', messages: [] },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedBody?.['model'], 'gpt-56-sol');
+});
+test('antseed alias with a model-only default route uses automatic peer selection', async () => {
+    const lower = makePeer('a', ['openai']);
+    lower.reputationScore = 40;
+    lower.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-56-sol': ['openai-chat-completions'] } },
+    };
+    const higher = makePeer('b', ['openai']);
+    higher.reputationScore = 90;
+    higher.providerServiceApiProtocols = {
+        openai: { services: { 'openai-gpt-56-sol': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([lower, higher], [lower, higher], permissiveRouter());
+    proxy._defaultRoutedModel = 'gpt-5.6-sol';
+    let selectedPeerId = '';
+    let selectedBody = null;
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'antseed', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, higher.peerId);
+    assert.equal(selectedBody?.['model'], 'openai-gpt-56-sol');
+});
+test('model-only routing skips higher-reputation peers rejected by buyer policy', async () => {
+    const allowed = makePeer('a', ['openai']);
+    allowed.reputationScore = 60;
+    allowed.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const rejected = makePeer('b', ['openai']);
+    rejected.reputationScore = 95;
+    rejected.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const router = {
+        allowsPeerForPolicy: (_request, peer) => peer.peerId === allowed.peerId,
+        onResult: () => { },
+    };
+    const proxy = makeBuyerProxyWithPeers([allowed, rejected], [allowed, rejected], router);
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ ok: true })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt-5', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, allowed.peerId);
+});
+test('/models order and model-only dispatch use the same Price + Trust ranking', async () => {
+    const cobaltRelay = makePeer('a', ['openai']);
+    cobaltRelay.reputationScore = 99;
+    cobaltRelay.providerPricing = {
+        openai: { defaults: { inputUsdPerMillion: 1.88, outputUsdPerMillion: 9.38 } },
+    };
+    cobaltRelay.providerServiceApiProtocols = {
+        openai: { services: { 'kimi-k3': ['openai-chat-completions'] } },
+    };
+    const emberRoute = makePeer('b', ['openai']);
+    emberRoute.reputationScore = 96;
+    emberRoute.providerPricing = {
+        openai: { defaults: { inputUsdPerMillion: 0.9, outputUsdPerMillion: 2.7 } },
+    };
+    emberRoute.providerServiceApiProtocols = {
+        openai: { services: { 'Kimi K3': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([cobaltRelay, emberRoute], [cobaltRelay, emberRoute], permissiveRouter(), undefined, priceAndTrustPreferences);
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const modelsRes = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/kimi-k3' }));
+    const peerOrder = JSON.parse(modelsRes.body).peers
+        .map((peer) => peer.peerId);
+    const completionRes = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'kimi-k3', messages: [] } }));
+    assert.equal(modelsRes.statusCode, 200);
+    assert.deepEqual(peerOrder, [emberRoute.peerId, cobaltRelay.peerId]);
+    assert.equal(completionRes.statusCode, 200);
+    assert.equal(selectedPeerId, emberRoute.peerId);
+});
+test('Price + Trust routing falls back after the preferred cheaper peer fails', async () => {
+    const cobaltRelay = makePeer('a', ['openai']);
+    cobaltRelay.reputationScore = 99;
+    cobaltRelay.providerPricing = {
+        openai: { defaults: { inputUsdPerMillion: 1.88, outputUsdPerMillion: 9.38 } },
+    };
+    cobaltRelay.providerServiceApiProtocols = {
+        openai: { services: { 'kimi-k3': ['openai-chat-completions'] } },
+    };
+    const emberRoute = makePeer('b', ['openai']);
+    emberRoute.reputationScore = 96;
+    emberRoute.providerPricing = {
+        openai: { defaults: { inputUsdPerMillion: 0.9, outputUsdPerMillion: 2.7 } },
+    };
+    emberRoute.providerServiceApiProtocols = {
+        openai: { services: { 'Kimi K3': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([cobaltRelay, emberRoute], [cobaltRelay, emberRoute], permissiveRouter(), undefined, priceAndTrustPreferences);
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return {
+            requestId: request.requestId,
+            statusCode: peer.peerId === emberRoute.peerId ? 503 : 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'kimi-k3', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [emberRoute.peerId, cobaltRelay.peerId]);
+});
+test('model-only routing falls back to the next reputable peer after a retryable failure', async () => {
+    const first = makePeer('a', ['openai']);
+    first.reputationScore = 95;
+    first.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const second = makePeer('b', ['openai']);
+    second.reputationScore = 80;
+    second.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([first, second], [first, second], permissiveRouter());
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return {
+            requestId: request.requestId,
+            statusCode: peer.peerId === first.peerId ? 503 : 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt5', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [first.peerId, second.peerId]);
+    assert.equal(JSON.parse(res.body).peerId, second.peerId);
+});
+test('model-only routing retries a rate-limited peer before falling back', async () => {
+    const first = makePeer('a', ['openai']);
+    first.reputationScore = 95;
+    first.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const second = makePeer('b', ['openai']);
+    second.reputationScore = 80;
+    second.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([first, second], [first, second], permissiveRouter());
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        const firstAttempts = attempts.filter((peerId) => peerId === first.peerId).length;
+        const statusCode = peer.peerId === first.peerId && firstAttempts < 3 ? 429 : 200;
+        return {
+            requestId: request.requestId,
+            statusCode,
+            headers: { 'content-type': 'application/json', 'retry-after': '0' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt-5', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [first.peerId, first.peerId, first.peerId]);
+});
+test('model-only routing falls back after three rate-limit responses from one peer', async () => {
+    const first = makePeer('a', ['openai']);
+    first.reputationScore = 95;
+    first.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const second = makePeer('b', ['openai']);
+    second.reputationScore = 80;
+    second.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([first, second], [first, second], permissiveRouter());
+    const attempts = [];
+    proxy._node.sendRequest = async (peer, request) => {
+        attempts.push(peer.peerId);
+        return {
+            requestId: request.requestId,
+            statusCode: peer.peerId === first.peerId ? 429 : 200,
+            headers: { 'content-type': 'application/json', 'retry-after': '0' },
+            body: Buffer.from(JSON.stringify({ peerId: peer.peerId })),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt-5', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(attempts, [first.peerId, first.peerId, first.peerId, second.peerId]);
+});
+test('model-only routing skips a cooling-down peer when another offer is ready', async () => {
+    const clock = makeTestClock();
+    const cooling = makePeer('a', ['openai']);
+    cooling.reputationScore = 95;
+    cooling.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const ready = makePeer('b', ['openai']);
+    ready.reputationScore = 70;
+    ready.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([cooling, ready], [cooling, ready], permissiveRouter(), clock.now);
+    proxy._peerHealth.set(cooling.peerId, {
+        failureStreak: 3,
+        windowStartedAt: clock.now(),
+        episodeStartedAt: clock.now(),
+        cooldownUntil: clock.now() + 60_000,
+        lastFailureAt: clock.now(),
+        lastSuccessAt: 0,
+        lastReason: 'seller-5xx',
+    });
+    let selectedPeerId = '';
+    proxy._node.sendRequest = async (peer, request) => {
+        selectedPeerId = peer.peerId;
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from('{}'),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt-5', messages: [] } }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedPeerId, ready.peerId);
+});
+test('model-only routing does not fail over after a buyer-attributed failure', async () => {
+    const first = makePeer('a', ['openai']);
+    first.reputationScore = 95;
+    first.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5': ['openai-chat-completions'] } },
+    };
+    const second = makePeer('b', ['openai']);
+    second.reputationScore = 80;
+    second.providerServiceApiProtocols = {
+        openai: { services: { 'GPT 5': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([first, second], [first, second], permissiveRouter());
+    const attempts = [];
+    proxy._node.sendRequest = async (peer) => {
+        attempts.push(peer.peerId);
+        throw buyerFault('Buyer has insufficient deposits', 'buyer-deposits-insufficient');
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ body: { model: 'gpt-5', messages: [] } }));
+    assert.equal(res.statusCode, 503);
+    assert.deepEqual(attempts, [first.peerId]);
+    assert.equal(JSON.parse(res.body).error.code, ANTSEED_BUYER_FAULT_ERROR_CODE);
+});
 test('pinned proxy request reports when the pinned peer is not discoverable', async () => {
     const pinnedPeerId = 'a'.repeat(40);
     const otherPeer = makePeer('b', ['openai']);
@@ -351,6 +976,52 @@ test('pinned proxy request reports when the pinned peer is not discoverable', as
     assert.match(res.body, /is not reachable right now/);
     assert.match(res.body, /It may be offline, not announcing, or temporarily unreachable/);
 });
+test('pinned proxy request rewrites a canonical alias to the advertised service id', async () => {
+    const pinnedPeer = makePeer('a', ['openai']);
+    pinnedPeer.providerServiceApiProtocols = {
+        openai: { services: { 'gpt-5.6-sol': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([pinnedPeer], [pinnedPeer], permissiveRouter());
+    let selectedBody = null;
+    proxy._node.sendRequest = async (_peer, request) => {
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from('{}'),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        headers: { 'x-antseed-pin-peer': pinnedPeer.peerId },
+        body: { model: 'gpt-56-sol', messages: [] },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedBody?.['model'], 'gpt-5.6-sol');
+});
+test('pinned proxy request dispatches when stale metadata misses the requested model', async () => {
+    const pinnedPeer = makePeer('a', ['openai']);
+    pinnedPeer.providerServiceApiProtocols = {
+        openai: { services: { 'known-model': ['openai-chat-completions'] } },
+    };
+    const proxy = makeBuyerProxyWithPeers([pinnedPeer], [pinnedPeer], permissiveRouter());
+    let selectedBody = null;
+    proxy._node.sendRequest = async (_peer, request) => {
+        selectedBody = parseJsonBody(request.body);
+        return {
+            requestId: request.requestId,
+            statusCode: 200,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from('{}'),
+        };
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({
+        headers: { 'x-antseed-pin-peer': pinnedPeer.peerId },
+        body: { model: 'new-helper-model', messages: [] },
+    }));
+    assert.equal(res.statusCode, 200);
+    assert.equal(selectedBody?.['model'], 'new-helper-model');
+});
 test('pinned proxy request reports explicit provider mismatch separately', async () => {
     const pinnedPeer = makePeer('a', ['local-llm']);
     const proxy = makeBuyerProxyWithPeers([pinnedPeer]);
@@ -661,29 +1332,126 @@ test('a non-standard seller 5xx proves reachability and restarts the failure str
     assert.equal(healthOf(proxy, peer)?.cooldownUntil, 0);
     assert.equal(healthOf(proxy, peer)?.failureStreak, 1);
 });
-test('a successful control-plane response clears a stale cooldown', async () => {
-    const clock = makeTestClock();
-    const peer = makePeer('a', ['openai']);
-    const other = makePeer('b', ['openai']);
-    const proxy = makeBuyerProxyWithPeers([peer, other], [peer, other], permissiveRouter(), clock.now);
-    proxy._cachedPeers = [peer, other];
-    proxy._rememberSuccessfulPeer(other.peerId);
-    proxy._node.sendRequest = async () => { throw new Error('Request timed out'); };
-    await failRepeatedly(proxy, peer, clock);
-    assert.ok(healthOf(proxy, peer)?.cooldownUntil > clock.now());
-    proxy._node.sendRequest = async (_peer, request) => ({
-        requestId: request.requestId,
-        statusCode: 200,
-        headers: { 'content-type': 'application/json' },
-        body: Buffer.from('{"data":[]}'),
+function makeNetworkModelPeers() {
+    const textPeer = makePeer('a', ['openai']);
+    textPeer.providerPricing = {
+        openai: {
+            defaults: { inputUsdPerMillion: 1, outputUsdPerMillion: 2 },
+            services: { 'qwen3-coder': { inputUsdPerMillion: 3, outputUsdPerMillion: 4 } },
+        },
+    };
+    textPeer.providerServiceApiProtocols = {
+        openai: { services: { 'qwen3-coder': ['openai-responses'] } },
+    };
+    textPeer.providerServiceCapabilities = {
+        openai: {
+            services: {
+                'qwen3-coder': {
+                    contextWindow: 128_000,
+                    maxOutputTokens: 32_000,
+                    inputs: ['text', 'image'],
+                    outputs: ['text'],
+                    reasoning: true,
+                    toolUse: true,
+                    structuredOutput: true,
+                    supportedParameters: ['temperature', 'tools'],
+                },
+            },
+        },
+    };
+    textPeer.providerServiceCategories = {
+        openai: { services: { 'qwen3-coder': ['chat', 'reasoning'] } },
+    };
+    const imagePeer = makePeer('b', ['openai']);
+    imagePeer.providerServiceApiProtocols = {
+        openai: { services: { 'flux-1-schnell': ['openai-images'] } },
+    };
+    const aliasPeer = makePeer('c', ['anthropic']);
+    aliasPeer.providerServiceApiProtocols = {
+        anthropic: { services: { 'Claude Opus 5': ['anthropic-messages'] } },
+    };
+    const secondAliasPeer = makePeer('d', ['anthropic']);
+    secondAliasPeer.providerServiceApiProtocols = {
+        anthropic: { services: { 'opus-5': ['anthropic-messages'] } },
+    };
+    return [textPeer, imagePeer, aliasPeer, secondAliasPeer];
+}
+test('GET /v1/models is answered locally with the network-wide model list', async () => {
+    const peers = makeNetworkModelPeers();
+    const proxy = makeBuyerProxyWithPeers(peers);
+    let forwarded = 0;
+    proxy._node.sendRequest = async () => {
+        forwarded += 1;
+        throw new Error('must not reach a peer');
+    };
+    const res = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models' }));
+    assert.equal(res.statusCode, 200);
+    // The port-reuse probe in `buyer start` identifies the proxy by this header.
+    assert.ok(res.headers['x-antseed-request-id']);
+    const body = JSON.parse(res.body);
+    assert.equal(body.object, 'list');
+    assert.deepEqual(body.data.map((model) => model.id), ['Claude Opus 5', 'flux-1-schnell', 'qwen3-coder']);
+    const opus = body.data[0];
+    assert.equal(opus.name, 'Claude Opus 5');
+    assert.deepEqual(opus.peers.map((peer) => peer.serviceId), ['Claude Opus 5', 'opus-5']);
+    const flux = body.data[1];
+    assert.equal(flux.type, 'image');
+    assert.equal(flux.peers[0]?.peerId, peers[1]?.peerId);
+    const qwen = body.data[2];
+    assert.equal(qwen.name, 'Qwen3 Coder');
+    assert.equal(qwen.type, 'text');
+    assert.deepEqual(qwen.supported_protocols, ['openai-responses']);
+    assert.equal(qwen.context_length, 128_000);
+    assert.equal(qwen.max_output_tokens, 32_000);
+    assert.deepEqual(qwen.architecture, {
+        input_modalities: ['image', 'text'],
+        output_modalities: ['text'],
     });
-    await invokeProxy(proxy, makeProxyRequest({
-        method: 'GET',
-        path: '/v1/models',
-        headers: { 'x-antseed-pin-peer': peer.peerId },
-    }));
-    assert.equal(healthOf(proxy, peer)?.cooldownUntil, 0);
-    assert.equal(healthOf(proxy, peer)?.failureStreak, 0);
+    assert.deepEqual(qwen.capabilities, {
+        reasoning: true,
+        tool_use: true,
+        structured_output: true,
+    });
+    assert.deepEqual(qwen.supported_parameters, ['temperature', 'tools']);
+    assert.equal(qwen.capability_coverage.context_length, 1);
+    assert.equal(qwen.peers[0]?.protocol, 'openai-responses');
+    assert.deepEqual(qwen.peers[0]?.categories, ['chat', 'reasoning']);
+    assert.equal(qwen.peers[0]?.capabilities?.contextWindow, 128_000);
+    assert.equal(qwen.peers[0]?.inputUsdPerMillion, 3);
+    assert.equal(forwarded, 0);
+});
+test('GET /v1/models?type= filters by model type and rejects unknown types', async () => {
+    const proxy = makeBuyerProxyWithPeers(makeNetworkModelPeers());
+    const images = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models?type=images' }));
+    assert.equal(images.statusCode, 200);
+    assert.deepEqual(JSON.parse(images.body).data.map((model) => model.id), ['flux-1-schnell']);
+    const text = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models?type=text' }));
+    assert.deepEqual(JSON.parse(text.body).data.map((model) => model.id), ['Claude Opus 5', 'qwen3-coder']);
+    const bad = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models?type=audio' }));
+    assert.equal(bad.statusCode, 400);
+    assert.equal(JSON.parse(bad.body).error.param, 'type');
+});
+test('GET /v1/models/:id looks up a single model across the network', async () => {
+    const proxy = makeBuyerProxyWithPeers(makeNetworkModelPeers());
+    const hit = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/QWEN3-coder' }));
+    assert.equal(hit.statusCode, 200);
+    const hitBody = JSON.parse(hit.body);
+    assert.equal(hitBody.id, 'qwen3-coder');
+    assert.equal(hitBody.context_length, 128_000);
+    assert.equal(hitBody.peers[0]?.capabilities?.toolUse, true);
+    const hitWithIgnoredType = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/QWEN3-coder?type=audio' }));
+    assert.equal(hitWithIgnoredType.statusCode, 200);
+    assert.equal(JSON.parse(hitWithIgnoredType.body).id, 'qwen3-coder');
+    const aliasHit = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/opus-5' }));
+    assert.equal(aliasHit.statusCode, 200);
+    assert.equal(JSON.parse(aliasHit.body).id, 'Claude Opus 5');
+    const miss = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/does-not-exist' }));
+    assert.equal(miss.statusCode, 404);
+    assert.equal(JSON.parse(miss.body).error.code, 'model_not_found');
+    const malformed = await invokeProxy(proxy, makeProxyRequest({ method: 'GET', path: '/v1/models/gpt%zz' }));
+    assert.equal(malformed.statusCode, 404);
+    assert.equal(malformed.headers['content-type'], 'application/json');
+    assert.equal(JSON.parse(malformed.body).error.code, 'model_not_found');
 });
 test('a buyer-side outage rolls back the cooldowns it caused', async () => {
     const clock = makeTestClock();
@@ -756,34 +1524,6 @@ test('POST /_antseed/peer-health/clear rejects a malformed peer id', async () =>
     }));
     assert.equal(res.statusCode, 400);
 });
-test('/v1/models retryable response reports router success', async () => {
-    const peer = makePeer('a', ['openai']);
-    const routerResults = [];
-    const router = {
-        allowsPeerForPolicy: () => true,
-        onResult: (_peer, result) => {
-            routerResults.push(result);
-        },
-    };
-    const proxy = makeBuyerProxyWithPeers([peer], [peer], router);
-    proxy._node.sendRequest = async (_peer, request) => ({
-        requestId: request.requestId,
-        statusCode: 500,
-        headers: { 'content-type': 'text/plain' },
-        body: Buffer.from('model probe failed'),
-    });
-    const res = await invokeProxy(proxy, makeProxyRequest({
-        method: 'GET',
-        path: '/v1/models',
-        headers: {
-            'x-antseed-pin-peer': peer.peerId,
-        },
-    }));
-    assert.equal(res.statusCode, 500);
-    assert.match(res.body, /model probe failed/);
-    assert.equal(routerResults.length, 1);
-    assert.equal(routerResults[0]?.success, true);
-});
 test('non-stream transformed responses requests force upstream stream without streaming to client', async () => {
     const peer = makePeer('a', ['openai-responses']);
     peer.providerServiceApiProtocols = {
@@ -1108,6 +1848,27 @@ test('parsePersistedPeers preserves provider metadata so routing filters still w
     assert.equal(result.candidatePeers[0]?.peerId, validPeerId);
     assert.equal(result.routePlanByPeerId.get(validPeerId)?.provider, 'claude-oauth');
 });
+test('parsePersistedPeers re-derives on-chain reputation from persisted stats', () => {
+    const persisted = {
+        discoveredPeers: [
+            {
+                peerId: validPeerId,
+                providers: ['claude-oauth'],
+                lastSeen: NOW - 5_000,
+                onChainStakeUsdcMicros: 2_000_000,
+                onChainChannelCount: 20,
+                onChainGhostCount: 0,
+                onChainTotalVolumeUsdcMicros: 100_000_000,
+                onChainLastSettledAtSec: Math.floor((NOW - 60_000) / 1000),
+                onChainStakedAtSec: Math.floor((NOW - 40 * 86_400_000) / 1000),
+            },
+        ],
+    };
+    const [peer] = parsePersistedPeers(persisted, NOW);
+    assert.ok(peer);
+    assert.equal(peer.onChainReputationScore, computeOnChainReputationScore(peer, NOW));
+    assert.ok((peer.onChainReputationScore ?? 0) > 0);
+});
 test('parsePersistedPeers restores sellerContract into peer.metadata', () => {
     // Regression: dropping sellerContract through the persistence layer caused
     // SellerAddressResolver to fall back to peerIdToAddress, so the buyer signed
@@ -1333,7 +2094,12 @@ test('route control endpoint sets, persists, and returns the default routed mode
     assert.deepEqual(JSON.parse(get.body), { ok: true, model: `${validPeerId}@gpt-4o` });
     const persisted = JSON.parse(await readFile(join(dir, 'buyer.state.json'), 'utf-8'));
     assert.equal(persisted['defaultRoutedModel'], `${validPeerId}@gpt-4o`);
-    const invalid = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: { model: 'gpt-4o' } }));
+    const automatic = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: { model: 'gpt-4o' } }));
+    assert.equal(automatic.statusCode, 200);
+    assert.deepEqual(JSON.parse(automatic.body), { ok: true, model: 'gpt-4o' });
+    const automaticPersisted = JSON.parse(await readFile(join(dir, 'buyer.state.json'), 'utf-8'));
+    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 cleared = await invokeProxy(proxy, makeProxyRequest({ path: '/_antseed/route', body: { model: '' } }));
     assert.deepEqual(JSON.parse(cleared.body), { ok: true, model: null });
@@ -1399,7 +2165,7 @@ test('per-chat pin overrides the default routed model for the antseed alias', as
         proxy._defaultRoutedModel = defaultRoute;
         const store = proxy._conversations;
         store.touch({ tool: 'codex-exec', sessionKey: 'sess-1' });
-        store.setPinnedModel('codex-exec:sess-1', pinnedRoute);
+        store.setPinnedModel('codex-exec:sess-1', pinnedRoute, 'user');
         await invokeProxy(proxy, makeProxyRequest({
             path: '/v1/responses',
             headers: { originator: 'codex_exec', 'session-id': 'sess-1' },
@@ -1446,7 +2212,7 @@ test('chat pin overrides a system-proxy-routed model on intercepted requests', a
         }));
         assert.equal(store.get('claude-code:cc-1')?.pinnedModel, proxyRoute);
         // The user re-pins the chat from the desktop (float / chats view).
-        store.setPinnedModel('claude-code:cc-1', pinnedRoute);
+        store.setPinnedModel('claude-code:cc-1', pinnedRoute, 'user');
         // Later requests still arrive with the proxy-assigned model; the pin wins.
         await invokeProxy(proxy, makeProxyRequest({
             path: '/v1/messages',
@@ -1542,9 +2308,15 @@ test('conversation control endpoints list, rename, pin, reject bad pins, delete'
         }));
         assert.equal(rename.statusCode, 200);
         assert.equal(store.get('opencode:ses_x')?.label, 'Login refactor');
+        const automaticPin = await invokeProxy(proxy, makeProxyRequest({
+            path: '/_antseed/conversations/update',
+            body: { id: 'opencode:ses_x', pinnedModel: 'gpt-5.6-sol', peerSource: 'auto' },
+        }));
+        assert.equal(automaticPin.statusCode, 200);
+        assert.equal(store.getPinnedModel('opencode', 'ses_x'), 'gpt-5.6-sol');
         const badPin = await invokeProxy(proxy, makeProxyRequest({
             path: '/_antseed/conversations/update',
-            body: { id: 'opencode:ses_x', pinnedModel: 'not-a-route' },
+            body: { id: 'opencode:ses_x', pinnedModel: 'not-a-peer@gpt-5.6-sol' },
         }));
         assert.equal(badPin.statusCode, 400);
         const goodPin = await invokeProxy(proxy, makeProxyRequest({