@antseed/cli 0.1.24 → 0.1.26

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, } 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());
@@ -13,9 +13,9 @@ function log(...args) {
         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) {
+function inferPreferredProvidersForRequest(requestProtocol, requestedService) {
+    const service = requestedService?.trim().toLowerCase() ?? '';
+    if (service.length === 0) {
         return [];
     }
     const providers = [];
@@ -26,11 +26,11 @@ function inferPreferredProvidersForRequest(requestProtocol, requestedModel) {
         }
         providers.push(provider);
     };
-    const slashIndex = model.indexOf('/');
+    const slashIndex = service.indexOf('/');
     if (slashIndex > 0) {
-        pushProvider(model.slice(0, slashIndex));
+        pushProvider(service.slice(0, slashIndex));
     }
-    if (requestProtocol === 'anthropic-messages' || model.startsWith('claude-') || model.includes('claude')) {
+    if (requestProtocol === 'anthropic-messages' || service.startsWith('claude-') || service.includes('claude')) {
         for (const provider of CLAUDE_PROVIDER_PREFERENCE) {
             pushProvider(provider);
         }
@@ -55,36 +55,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 +101,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 +115,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 +124,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 +269,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 +374,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 +384,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 +460,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 +482,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 +512,7 @@ function computeResponseTelemetry(request, responseHeaders, responseBody, select
         usage,
         pricing: {
             provider,
-            model,
+            service,
             inputUsdPerMillion: pricing.inputUsdPerMillion,
             outputUsdPerMillion: pricing.outputUsdPerMillion,
         },
@@ -529,8 +529,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 +646,7 @@ export class BuyerProxy {
     _bgRefreshIntervalMs;
     _peerCacheTtlMs;
     _pinnedPeer;
-    _pinnedModel;
+    _pinnedService;
     _stateFileWatcher = null;
     _stateWatchDebounce = null;
     _cachedPeers = [];
@@ -663,7 +663,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 +726,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 +752,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,19 +819,21 @@ 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'
             : normalizedPath.startsWith('/v1/chat/completions')
                 ? '/v1/chat/completions'
-                : normalizedPath.startsWith('/v1/models')
-                    ? '/v1/models'
-                    : normalizedPath);
+                : normalizedPath.startsWith('/v1/responses')
+                    ? '/v1/responses'
+                    : normalizedPath.startsWith('/v1/models')
+                        ? '/v1/models'
+                        : normalizedPath);
         return [
             pathGroup,
             requestProtocol ?? 'unknown-protocol',
-            requestedModel ?? 'unknown-model',
+            requestedService ?? 'unknown-service',
             explicitProvider ?? 'auto-provider',
         ].join('|');
     }
@@ -989,14 +991,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();
@@ -1025,15 +1027,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,7 +1071,7 @@ export class BuyerProxy {
         }
         const preferredProviders = explicitProvider
             ? []
-            : inferPreferredProvidersForRequest(requestProtocol, requestedModel);
+            : inferPreferredProvidersForRequest(requestProtocol, requestedService);
         let hasPreferredProviderCandidate = preferredProviders.length > 0
             && routingPeers.some((peer) => {
                 const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
@@ -1108,9 +1110,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' });
@@ -1118,7 +1120,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
@@ -1167,7 +1169,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;
@@ -1182,7 +1184,7 @@ 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).
+            // Strongly prefer providers that match the requested service 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();
@@ -1194,7 +1196,7 @@ export class BuyerProxy {
                         : providerMatchedPeers[0] ?? null;
                     if (selectedPeer) {
                         const plannedProvider = routingPlans.get(selectedPeer.peerId)?.provider ?? 'unknown';
-                        log(`Preferring model-matched provider "${plannedProvider}" for model "${requestedModel ?? 'unknown'}"`);
+                        log(`Preferring service-matched provider "${plannedProvider}" for service "${requestedService ?? 'unknown'}"`);
                     }
                 }
             }
@@ -1212,7 +1214,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);
@@ -1238,7 +1240,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);
@@ -1270,9 +1272,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 };
         }
@@ -1309,6 +1311,28 @@ export class BuyerProxy {
                 });
                 forceDisableUpstreamStreaming = true;
             }
+            else if (requestProtocol === 'openai-responses'
+                && selectedRoutePlan.selection.targetProtocol === 'openai-chat-completions') {
+                log(`Applying protocol adapter openai-responses -> openai-chat-completions via provider "${selectedRoutePlan.provider}"`);
+                const transformed = transformOpenAIResponsesRequestToOpenAIChat(requestForPeer);
+                if (!transformed) {
+                    res.writeHead(502, { 'content-type': 'text/plain' });
+                    res.end('Failed to transform Responses API request for selected provider protocol');
+                    return { done: true };
+                }
+                requestForPeer = {
+                    ...transformed.request,
+                    headers: {
+                        ...transformed.request.headers,
+                        'x-antseed-provider': selectedRoutePlan.provider,
+                    },
+                };
+                adaptResponse = (response) => transformOpenAIChatResponseToOpenAIResponses(response, {
+                    fallbackModel: transformed.requestedModel,
+                    streamRequested: transformed.streamRequested,
+                });
+                forceDisableUpstreamStreaming = true;
+            }
             else {
                 res.writeHead(502, { 'content-type': 'text/plain' });
                 res.end('Unsupported protocol transformation path');
@@ -1464,11 +1488,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) {