@antseed/cli 0.1.25 → 0.1.27

package/dist/proxy/buyer-proxy.js

@@ -4,7 +4,7 @@ import { watch } from 'node:fs';
 import { readFile, writeFile, rename, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { detectRequestModelApiProtocol, inferProviderDefaultModelApiProtocols, selectTargetProtocolForRequest, transformAnthropicMessagesRequestToOpenAIChat, transformOpenAIChatResponseToAnthropicMessage, transformOpenAIResponsesRequestToOpenAIChat, transformOpenAIChatResponseToOpenAIResponses, } from './model-api-adapter.js';
+import { detectRequestServiceApiProtocol, inferProviderDefaultServiceApiProtocols, selectTargetProtocolForRequest, transformAnthropicMessagesRequestToOpenAIChat, transformOpenAIChatResponseToAnthropicMessage, transformOpenAIResponsesRequestToOpenAIChat, transformOpenAIChatResponseToOpenAIResponses, } from './service-api-adapter.js';
 const DAEMON_STATE_FILE = join(homedir(), '.antseed', 'daemon.state.json');
 const BUYER_STATE_FILE = join(homedir(), '.antseed', 'buyer.state.json');
 const DEBUG = () => ['1', 'true', 'yes', 'on'].includes((process.env['ANTSEED_DEBUG'] ?? '').trim().toLowerCase());
@@ -12,31 +12,6 @@ function log(...args) {
     if (DEBUG())
         console.log('[proxy]', ...args);
 }
-const CLAUDE_PROVIDER_PREFERENCE = ['claude-oauth', 'anthropic', 'claude-code'];
-function inferPreferredProvidersForRequest(requestProtocol, requestedModel) {
-    const model = requestedModel?.trim().toLowerCase() ?? '';
-    if (model.length === 0) {
-        return [];
-    }
-    const providers = [];
-    const pushProvider = (value) => {
-        const provider = value?.trim().toLowerCase();
-        if (!provider || provider.length === 0 || providers.includes(provider)) {
-            return;
-        }
-        providers.push(provider);
-    };
-    const slashIndex = model.indexOf('/');
-    if (slashIndex > 0) {
-        pushProvider(model.slice(0, slashIndex));
-    }
-    if (requestProtocol === 'anthropic-messages' || model.startsWith('claude-') || model.includes('claude')) {
-        for (const provider of CLAUDE_PROVIDER_PREFERENCE) {
-            pushProvider(provider);
-        }
-    }
-    return providers;
-}
 function getExplicitProviderOverride(request) {
     const provider = request.headers['x-antseed-provider']?.trim().toLowerCase();
     return provider && provider.length > 0 ? provider : null;
@@ -55,36 +30,36 @@ function getPreferredPeerIdHint(request) {
     }
     return header;
 }
-function getPeerProviderProtocols(peer, provider, requestedModel) {
-    const normalizedRequestedModel = requestedModel?.trim();
-    const fromMetadata = peer.providerModelApiProtocols?.[provider]?.models;
+function getPeerProviderProtocols(peer, provider, requestedService) {
+    const normalizedRequestedService = requestedService?.trim();
+    const fromMetadata = peer.providerServiceApiProtocols?.[provider]?.services;
     if (fromMetadata) {
-        if (normalizedRequestedModel) {
-            const directMatchKey = Object.keys(fromMetadata).find((model) => model.toLowerCase() === normalizedRequestedModel.toLowerCase());
+        if (normalizedRequestedService) {
+            const directMatchKey = Object.keys(fromMetadata).find((key) => key.toLowerCase() === normalizedRequestedService.toLowerCase());
             if (directMatchKey && fromMetadata[directMatchKey]?.length) {
-                log(`Model match: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${normalizedRequestedModel}" `
+                log(`Service match: peer ${peer.peerId.slice(0, 8)} provider=${provider} service="${normalizedRequestedService}" `
                     + `→ [${fromMetadata[directMatchKey].join(',')}]`);
                 return Array.from(new Set(fromMetadata[directMatchKey]));
             }
             if (Object.keys(fromMetadata).length > 0) {
-                log(`Model strict-miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${normalizedRequestedModel}" `
+                log(`Service strict-miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} service="${normalizedRequestedService}" `
                     + 'not in metadata; excluding from route candidates.');
                 return [];
             }
         }
         const merged = Object.values(fromMetadata).flat();
         if (merged.length > 0) {
-            if (requestedModel) {
-                log(`Model hint miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${requestedModel}" not in metadata; falling back to provider protocol set [${Array.from(new Set(merged)).join(',')}]`);
+            if (requestedService) {
+                log(`Service hint miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} service="${requestedService}" not in metadata; falling back to provider protocol set [${Array.from(new Set(merged)).join(',')}]`);
             }
             return Array.from(new Set(merged));
         }
     }
-    const inferred = inferProviderDefaultModelApiProtocols(provider);
+    const inferred = inferProviderDefaultServiceApiProtocols(provider);
     log(`No metadata: peer ${peer.peerId.slice(0, 8)} provider=${provider} → inferred [${inferred.join(',')}]`);
     return inferred;
 }
-function resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitProvider) {
+function resolvePeerRoutePlan(peer, requestProtocol, requestedService, explicitProvider) {
     const providers = peer.providers
         .map((provider) => provider.trim().toLowerCase())
         .filter((provider) => provider.length > 0);
@@ -101,7 +76,7 @@ function resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitPro
     }
     let transformedFallback = null;
     for (const provider of candidates) {
-        const supportedProtocols = getPeerProviderProtocols(peer, provider, requestedModel);
+        const supportedProtocols = getPeerProviderProtocols(peer, provider, requestedService);
         const selection = selectTargetProtocolForRequest(requestProtocol, supportedProtocols);
         if (!selection) {
             continue;
@@ -115,7 +90,7 @@ function resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitPro
     }
     return transformedFallback;
 }
-export function selectCandidatePeersForRouting(peers, requestProtocol, requestedModel, explicitProvider) {
+export function selectCandidatePeersForRouting(peers, requestProtocol, requestedService, explicitProvider) {
     const routePlanByPeerId = new Map();
     if (!requestProtocol && !explicitProvider) {
         return {
@@ -124,7 +99,7 @@ export function selectCandidatePeersForRouting(peers, requestProtocol, requested
         };
     }
     const candidatePeers = peers.filter((peer) => {
-        const plan = resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitProvider);
+        const plan = resolvePeerRoutePlan(peer, requestProtocol, requestedService, explicitProvider);
         if (!plan)
             return false;
         routePlanByPeerId.set(peer.peerId, plan);
@@ -269,16 +244,16 @@ function pickProviderForPeer(peer, request) {
     }
     return 'unknown';
 }
-function extractRequestedModel(request) {
+function extractRequestedService(request) {
     const contentType = (request.headers['content-type'] ?? request.headers['Content-Type'] ?? '').toLowerCase();
     if (!contentType.includes('application/json')) {
         return null;
     }
     try {
         const parsed = JSON.parse(new TextDecoder().decode(request.body));
-        const model = parsed.model;
-        if (typeof model === 'string' && model.trim().length > 0) {
-            return model.trim();
+        const service = parsed.service ?? parsed.model;
+        if (typeof service === 'string' && service.trim().length > 0) {
+            return service.trim();
         }
         return null;
     }
@@ -374,7 +349,7 @@ function summarizeRequestShape(request) {
     const accept = (request.headers['accept'] ?? request.headers['Accept'] ?? '').toLowerCase();
     const providerHeader = request.headers['x-antseed-provider'] ?? 'none';
     const preferPeerHeader = request.headers['x-antseed-prefer-peer'] ?? 'none';
-    const model = extractRequestedModel(request) ?? 'none';
+    const service = extractRequestedService(request) ?? 'none';
     const wantsStreaming = requestWantsStreaming(request.headers, request.body);
     const baseParts = [
         `method=${request.method}`,
@@ -384,7 +359,7 @@ function summarizeRequestShape(request) {
         `contentType=${contentType || 'none'}`,
         `accept=${accept || 'none'}`,
         `stream=${String(wantsStreaming)}`,
-        `model=${model}`,
+        `service=${service}`,
         `bodyBytes=${String(request.body.length)}`,
     ];
     const jsonBody = decodeJsonBody(request.body);
@@ -460,14 +435,14 @@ function setPeerIdentityHeaders(headers, selectedPeer) {
         headers['x-antseed-peer-providers'] = selectedPeer.providers.join(',');
     }
 }
-function resolvePeerPricing(peer, provider, model) {
+function resolvePeerPricing(peer, provider, service) {
     const providerPricing = peer.providerPricing?.[provider];
     if (providerPricing) {
-        const modelPricing = model ? providerPricing.models?.[model] : undefined;
-        if (modelPricing) {
+        const servicePricing = service ? providerPricing.services?.[service] : undefined;
+        if (servicePricing) {
             return {
-                inputUsdPerMillion: toFiniteNumberOrNull(modelPricing.inputUsdPerMillion),
-                outputUsdPerMillion: toFiniteNumberOrNull(modelPricing.outputUsdPerMillion),
+                inputUsdPerMillion: toFiniteNumberOrNull(servicePricing.inputUsdPerMillion),
+                outputUsdPerMillion: toFiniteNumberOrNull(servicePricing.outputUsdPerMillion),
             };
         }
         return {
@@ -482,8 +457,8 @@ function resolvePeerPricing(peer, provider, model) {
 }
 function computeResponseTelemetry(request, responseHeaders, responseBody, selectedPeer) {
     const provider = pickProviderForPeer(selectedPeer, request);
-    const model = extractRequestedModel(request);
-    const pricing = resolvePeerPricing(selectedPeer, provider, model);
+    const service = extractRequestedService(request);
+    const pricing = resolvePeerPricing(selectedPeer, provider, service);
     const contentType = (responseHeaders['content-type'] ?? '').toLowerCase();
     const usageFromBody = contentType.includes('text/event-stream')
         ? parseSseUsage(responseBody)
@@ -512,7 +487,7 @@ function computeResponseTelemetry(request, responseHeaders, responseBody, select
         usage,
         pricing: {
             provider,
-            model,
+            service,
             inputUsdPerMillion: pricing.inputUsdPerMillion,
             outputUsdPerMillion: pricing.outputUsdPerMillion,
         },
@@ -529,8 +504,8 @@ function attachAntseedTelemetryHeaders(upstreamHeaders, selectedPeer, telemetry,
     setFiniteNumberHeader(headers, 'x-antseed-peer-current-load', selectedPeer.currentLoad);
     setFiniteNumberHeader(headers, 'x-antseed-peer-max-concurrency', selectedPeer.maxConcurrency);
     headers['x-antseed-provider'] = telemetry.pricing.provider;
-    if (telemetry.pricing.model) {
-        headers['x-antseed-model'] = telemetry.pricing.model;
+    if (telemetry.pricing.service) {
+        headers['x-antseed-service'] = telemetry.pricing.service;
     }
     setFiniteNumberHeader(headers, 'x-antseed-input-usd-per-million', telemetry.pricing.inputUsdPerMillion);
     setFiniteNumberHeader(headers, 'x-antseed-output-usd-per-million', telemetry.pricing.outputUsdPerMillion);
@@ -646,7 +621,7 @@ export class BuyerProxy {
     _bgRefreshIntervalMs;
     _peerCacheTtlMs;
     _pinnedPeer;
-    _pinnedModel;
+    _pinnedService;
     _stateFileWatcher = null;
     _stateWatchDebounce = null;
     _cachedPeers = [];
@@ -663,7 +638,7 @@ export class BuyerProxy {
         this._bgRefreshIntervalMs = config.backgroundRefreshIntervalMs ?? 5 * 60_000;
         this._peerCacheTtlMs = Math.max(0, config.peerCacheTtlMs ?? 30_000);
         this._pinnedPeer = config.pinnedPeerId?.toLowerCase() ?? null;
-        this._pinnedModel = config.pinnedModel?.trim() ?? null;
+        this._pinnedService = config.pinnedService?.trim() ?? null;
         this._server = createServer((req, res) => {
             this._handleRequest(req, res).catch((err) => {
                 log('Unhandled error:', err);
@@ -726,15 +701,15 @@ export class BuyerProxy {
         try {
             const raw = await readFile(BUYER_STATE_FILE, 'utf-8');
             const parsed = JSON.parse(raw);
-            const pinnedModel = typeof parsed.pinnedModel === 'string' && parsed.pinnedModel.trim().length > 0
-                ? parsed.pinnedModel.trim()
+            const pinnedService = typeof parsed.pinnedService === 'string' && parsed.pinnedService.trim().length > 0
+                ? parsed.pinnedService.trim()
                 : null;
             const pinnedPeer = typeof parsed.pinnedPeerId === 'string' && parsed.pinnedPeerId.trim().length > 0
                 ? parsed.pinnedPeerId.trim().toLowerCase()
                 : null;
-            this._pinnedModel = pinnedModel;
+            this._pinnedService = pinnedService;
             this._pinnedPeer = pinnedPeer;
-            log(`Session overrides reloaded: model=${pinnedModel ?? 'none'} peer=${pinnedPeer ?? 'none'}`);
+            log(`Session overrides reloaded: service=${pinnedService ?? 'none'} peer=${pinnedPeer ?? 'none'}`);
         }
         catch {
             // state file unreadable; keep current values
@@ -752,11 +727,11 @@ export class BuyerProxy {
             catch {
                 // file doesn't exist yet
             }
-            // When stopping, preserve whatever pinnedModel/pinnedPeerId is already
+            // When stopping, preserve whatever pinnedService/pinnedPeerId is already
             // in the file — the debounce may have been cancelled before
             // _reloadSessionOverrides could commit the latest CLI-written values.
             const sessionOverrides = state === 'connected'
-                ? { pinnedModel: this._pinnedModel, pinnedPeerId: this._pinnedPeer }
+                ? { pinnedService: this._pinnedService, pinnedPeerId: this._pinnedPeer }
                 : {};
             const data = {
                 ...existing,
@@ -819,7 +794,7 @@ export class BuyerProxy {
             }
         }
     }
-    _buildRouteKey(path, requestProtocol, requestedModel, explicitProvider) {
+    _buildRouteKey(path, requestProtocol, requestedService, explicitProvider) {
         const normalizedPath = path.split('?')[0]?.trim().toLowerCase() ?? '/';
         const pathGroup = (normalizedPath.startsWith('/v1/messages')
             ? '/v1/messages'
@@ -833,7 +808,7 @@ export class BuyerProxy {
         return [
             pathGroup,
             requestProtocol ?? 'unknown-protocol',
-            requestedModel ?? 'unknown-model',
+            requestedService ?? 'unknown-service',
             explicitProvider ?? 'auto-provider',
         ].join('|');
     }
@@ -991,14 +966,14 @@ export class BuyerProxy {
             body: new Uint8Array(body),
         };
         // Snapshot both session overrides together before any await so a concurrent
-        // _reloadSessionOverrides() cannot produce a model/peer mismatch mid-request.
-        const effectivePinnedModel = this._pinnedModel;
+        // _reloadSessionOverrides() cannot produce a service/peer mismatch mid-request.
+        const effectivePinnedService = this._pinnedService;
         const effectivePinnedPeer = this._pinnedPeer;
-        if (effectivePinnedModel) {
-            const { body: rewrittenBody, headers: rewrittenHeaders } = rewriteModelInBody(serializedReq.body, serializedReq.headers, effectivePinnedModel);
+        if (effectivePinnedService) {
+            const { body: rewrittenBody, headers: rewrittenHeaders } = rewriteModelInBody(serializedReq.body, serializedReq.headers, effectivePinnedService);
             if (rewrittenBody !== serializedReq.body) {
                 serializedReq = { ...serializedReq, body: rewrittenBody, headers: rewrittenHeaders };
-                log(`Model override applied: ${effectivePinnedModel}`);
+                log(`Service override applied: ${effectivePinnedService}`);
             }
         }
         const clientAbortController = new AbortController();
@@ -1027,15 +1002,15 @@ export class BuyerProxy {
             res.end('No sellers available on the network. Is a seeder running?');
             return;
         }
-        const requestProtocol = detectRequestModelApiProtocol(serializedReq);
-        const requestedModel = extractRequestedModel(serializedReq);
-        log(`Routing: protocol=${requestProtocol ?? 'null'} model=${requestedModel ?? 'null'}`);
+        const requestProtocol = detectRequestServiceApiProtocol(serializedReq);
+        const requestedService = extractRequestedService(serializedReq);
+        log(`Routing: protocol=${requestProtocol ?? 'null'} service=${requestedService ?? 'null'}`);
         const explicitProvider = getExplicitProviderOverride(serializedReq);
         const explicitPeerId = getExplicitPeerIdOverride(serializedReq, effectivePinnedPeer ?? undefined);
         const preferredPeerId = getPreferredPeerIdHint(serializedReq);
         log(`Routing hints: provider=${explicitProvider ?? 'auto'} pin-peer=${explicitPeerId ?? 'none'} prefer-peer=${preferredPeerId ?? 'none'}`);
-        const routeKey = this._buildRouteKey(serializedReq.path, requestProtocol, requestedModel, explicitProvider);
-        const selectPeers = (candidateSources) => selectCandidatePeersForRouting(candidateSources, requestProtocol, requestedModel, explicitProvider);
+        const routeKey = this._buildRouteKey(serializedReq.path, requestProtocol, requestedService, explicitProvider);
+        const selectPeers = (candidateSources) => selectCandidatePeersForRouting(candidateSources, requestProtocol, requestedService, explicitProvider);
         let hasForcedRefresh = false;
         const refreshPeerSelection = async (reason) => {
             if (hasForcedRefresh) {
@@ -1069,21 +1044,6 @@ export class BuyerProxy {
             }
             return;
         }
-        const preferredProviders = explicitProvider
-            ? []
-            : inferPreferredProvidersForRequest(requestProtocol, requestedModel);
-        let hasPreferredProviderCandidate = preferredProviders.length > 0
-            && routingPeers.some((peer) => {
-                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
-                return Boolean(provider && preferredProviders.includes(provider));
-            });
-        if (preferredProviders.length > 0 && !hasPreferredProviderCandidate) {
-            await refreshPeerSelection(`missing preferred providers [${preferredProviders.join(',')}]`);
-            hasPreferredProviderCandidate = routingPeers.some((peer) => {
-                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
-                return Boolean(provider && preferredProviders.includes(provider));
-            });
-        }
         if (routingPeers.length === 0) {
             const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
             res.writeHead(502, { 'content-type': 'text/plain' });
@@ -1110,9 +1070,9 @@ export class BuyerProxy {
                 const peerDiscovered = discoveredPeers.some((peer) => peer.peerId.toLowerCase() === explicitPeerId);
                 const protocolLabel = requestProtocol ? `protocol=${requestProtocol}` : 'protocol=unknown';
                 const providerLabel = explicitProvider ? `provider=${explicitProvider}` : 'provider=auto';
-                const modelLabel = requestedModel ? `model=${requestedModel}` : 'model=none';
+                const serviceLabel = requestedService ? `service=${requestedService}` : 'service=none';
                 const mismatchHint = peerDiscovered
-                    ? `Peer is discoverable but filtered as incompatible (${protocolLabel}, ${providerLabel}, ${modelLabel}).`
+                    ? `Peer is discoverable but filtered as incompatible (${protocolLabel}, ${providerLabel}, ${serviceLabel}).`
                     : 'Peer is not discoverable right now.';
                 log(`Pinned peer ${explicitPeerId.slice(0, 12)}... not found in candidate list (${source})`);
                 res.writeHead(502, { 'content-type': 'text/plain' });
@@ -1120,7 +1080,7 @@ export class BuyerProxy {
                 return;
             }
             log(`Using pinned peer ${selectedPeer.peerId.slice(0, 12)}...`);
-            const result = await this._dispatchToPeer(res, serializedReq, selectedPeer, routeKey, pinnedRoutePlans, requestProtocol, requestedModel, explicitProvider, router, RETRYABLE_STATUS_CODES, clientAbortController.signal);
+            const result = await this._dispatchToPeer(res, serializedReq, selectedPeer, routeKey, pinnedRoutePlans, requestProtocol, requestedService, explicitProvider, router, RETRYABLE_STATUS_CODES, clientAbortController.signal);
             if (!result.done) {
                 this._forgetSuccessfulPeer(routeKey, selectedPeer.peerId);
                 // Pinned peer returned a retryable error, but we don't retry — send error to client
@@ -1132,28 +1092,11 @@ export class BuyerProxy {
         // Non-pinned: retry with failover on provider errors
         const MAX_ATTEMPTS = 3;
         const triedPeerIds = new Set();
-        const restrictFailoverToPreferredProviders = preferredProviders.length > 0 && hasPreferredProviderCandidate;
-        if (restrictFailoverToPreferredProviders) {
-            log(`Provider-family preference active (attempt 1): [${preferredProviders.join(',')}]`);
-        }
         let lastStatusCode = 502;
         let lastResponseBody = null;
         let lastResponseHeaders = { 'content-type': 'text/plain' };
         for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-            const limitToPreferredProviders = restrictFailoverToPreferredProviders && attempt === 0;
-            if (restrictFailoverToPreferredProviders && attempt === 1) {
-                log('Preferred provider attempt failed; expanding failover to all compatible providers.');
-            }
-            const availableCandidates = routingPeers.filter((peer) => {
-                if (triedPeerIds.has(peer.peerId)) {
-                    return false;
-                }
-                if (!limitToPreferredProviders) {
-                    return true;
-                }
-                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
-                return Boolean(provider && preferredProviders.includes(provider));
-            });
+            const availableCandidates = routingPeers.filter((peer) => !triedPeerIds.has(peer.peerId));
             if (availableCandidates.length === 0)
                 break;
             let selectedPeer = null;
@@ -1169,7 +1112,7 @@ export class BuyerProxy {
                 }
             }
             // Fallback to the latest globally successful peer.
-            if (!selectedPeer && attempt === 0 && this._lastSuccessfulPeerId && !requestedModel) {
+            if (!selectedPeer && attempt === 0 && this._lastSuccessfulPeerId && !requestedService) {
                 const remembered = availableCandidates.find((peer) => peer.peerId === this._lastSuccessfulPeerId) ?? null;
                 if (remembered) {
                     selectedPeer = remembered;
@@ -1184,22 +1127,6 @@ export class BuyerProxy {
                     log(`Preferring requested peer ${selectedPeer.peerId.slice(0, 12)}...`);
                 }
             }
-            // Strongly prefer providers that match the requested model family (e.g. claude-* -> claude/anthropic providers).
-            if (!selectedPeer && attempt === 0 && preferredProviders.length > 0) {
-                const providerMatchedPeers = availableCandidates.filter((peer) => {
-                    const plannedProvider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
-                    return plannedProvider ? preferredProviders.includes(plannedProvider) : false;
-                });
-                if (providerMatchedPeers.length > 0) {
-                    selectedPeer = router
-                        ? router.selectPeer(serializedReq, providerMatchedPeers)
-                        : providerMatchedPeers[0] ?? null;
-                    if (selectedPeer) {
-                        const plannedProvider = routingPlans.get(selectedPeer.peerId)?.provider ?? 'unknown';
-                        log(`Preferring model-matched provider "${plannedProvider}" for model "${requestedModel ?? 'unknown'}"`);
-                    }
-                }
-            }
             // Prefer local peers on first attempt
             if (!selectedPeer && attempt === 0) {
                 const localPeers = availableCandidates.filter((peer) => isLoopbackPeer(peer));
@@ -1214,7 +1141,7 @@ export class BuyerProxy {
             }
             // Prefer peers that can serve the request protocol directly without adapter transform.
             if (!selectedPeer && requestProtocol === 'anthropic-messages') {
-                const shouldPreferDirect = !requestedModel || /claude|anthropic/i.test(requestedModel);
+                const shouldPreferDirect = !requestedService || /claude|anthropic/i.test(requestedService);
                 if (shouldPreferDirect) {
                     const directPeers = availableCandidates.filter((peer) => {
                         const plan = routingPlans.get(peer.peerId);
@@ -1240,7 +1167,7 @@ export class BuyerProxy {
             if (!selectedPeer)
                 break;
             triedPeerIds.add(selectedPeer.peerId);
-            const result = await this._dispatchToPeer(res, serializedReq, selectedPeer, routeKey, routingPlans, requestProtocol, requestedModel, explicitProvider, router, RETRYABLE_STATUS_CODES, clientAbortController.signal);
+            const result = await this._dispatchToPeer(res, serializedReq, selectedPeer, routeKey, routingPlans, requestProtocol, requestedService, explicitProvider, router, RETRYABLE_STATUS_CODES, clientAbortController.signal);
             if (result.done)
                 return;
             this._forgetSuccessfulPeer(routeKey, selectedPeer.peerId);
@@ -1272,9 +1199,9 @@ export class BuyerProxy {
      * was sent to the client (success or non-retryable error), or retry info if the
      * caller should try another peer.
      */
-    async _dispatchToPeer(res, serializedReq, selectedPeer, routeKey, routePlanByPeerId, requestProtocol, requestedModel, explicitProvider, router, retryableStatusCodes, requestSignal) {
+    async _dispatchToPeer(res, serializedReq, selectedPeer, routeKey, routePlanByPeerId, requestProtocol, requestedService, explicitProvider, router, retryableStatusCodes, requestSignal) {
         const selectedRoutePlan = routePlanByPeerId.get(selectedPeer.peerId)
-            ?? resolvePeerRoutePlan(selectedPeer, requestProtocol, requestedModel, explicitProvider);
+            ?? resolvePeerRoutePlan(selectedPeer, requestProtocol, requestedService, explicitProvider);
         if (!selectedRoutePlan) {
             return { done: false, statusCode: 502, responseBody: Buffer.from('No compatible provider route'), responseHeaders: { 'content-type': 'text/plain' }, errorMessage: null };
         }
@@ -1488,11 +1415,11 @@ export class BuyerProxy {
                     tokens: 0,
                 });
             }
-            // Avoid poisoning routing cache from control-plane model enumeration failures.
-            // Some peers can time out on /v1/models while still serving inference paths.
+            // Avoid poisoning routing cache from control-plane service enumeration failures.
+            // Some peers can time out on /v1/models (service probe) while still serving inference paths.
             const normalizedPath = requestForPeer.path.toLowerCase();
-            const isControlPlaneModelsRequest = normalizedPath.startsWith('/v1/models');
-            if (isControlPlaneModelsRequest) {
+            const isControlPlaneServicesRequest = normalizedPath.startsWith('/v1/models');
+            if (isControlPlaneServicesRequest) {
                 log(`Skipping peer eviction for control-plane failure on ${requestForPeer.path}`);
             }
             else if (connectionChurnError) {