@antseed/cli 0.1.43 → 0.1.44

package/dist/proxy/buyer-proxy.js

@@ -4,610 +4,65 @@ 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 { createOpenAIChatToAnthropicStreamingAdapter, createOpenAIChatToResponsesStreamingAdapter, createOpenAIResponsesToChatStreamingAdapter, detectRequestServiceApiProtocol, inferProviderDefaultServiceApiProtocols, selectTargetProtocolForRequest, transformAnthropicMessagesRequestToOpenAIChat, transformOpenAIChatRequestToOpenAIResponses, transformOpenAIChatResponseToAnthropicMessage, transformOpenAIChatResponseToOpenAIResponses, transformOpenAIResponsesRequestToOpenAIChat, transformOpenAIResponsesResponseToOpenAIChat, } from './service-api-adapter.js';
-const DAEMON_STATE_FILE = join(homedir(), '.antseed', 'daemon.state.json');
+import { createOpenAIChatToAnthropicStreamingAdapter, createOpenAIChatToResponsesStreamingAdapter, createOpenAIResponsesToChatStreamingAdapter, detectRequestServiceApiProtocol, transformAnthropicMessagesRequestToOpenAIChat, transformOpenAIChatRequestToOpenAIResponses, transformOpenAIChatResponseToAnthropicMessage, transformOpenAIChatResponseToOpenAIResponses, transformOpenAIResponsesRequestToOpenAIChat, transformOpenAIResponsesResponseToOpenAIChat, } from './service-api-adapter.js';
+import { DEBUG, log, extractRequestedService, summarizeRequestShape, summarizeErrorResponse, requestWantsStreaming, rewriteServiceInBody, isConnectionChurnError, isConnectionHealthy, isLoopbackPeer, } from './request-utils.js';
+import { getExplicitProviderOverride, getExplicitPeerIdOverride, getPreferredPeerIdHint, resolvePeerRoutePlan, selectCandidatePeersForRouting, } from './routing.js';
+import { computeResponseTelemetry, attachAntseedTelemetryHeaders, attachStreamingAntseedHeaders, } from './telemetry.js';
+// Re-export for backward compatibility (used by tests and other consumers)
+export { selectCandidatePeersForRouting } from './routing.js';
+export { rewriteServiceInBody } from './request-utils.js';
 const BUYER_STATE_FILE = join(homedir(), '.antseed', 'buyer.state.json');
-const DEBUG = () => ['1', 'true', 'yes', 'on'].includes((process.env['ANTSEED_DEBUG'] ?? '').trim().toLowerCase());
-function log(...args) {
-    if (DEBUG())
-        console.log('[proxy]', ...args);
-}
-function getExplicitProviderOverride(request) {
-    const provider = request.headers['x-antseed-provider']?.trim().toLowerCase();
-    return provider && provider.length > 0 ? provider : null;
-}
-function getExplicitPeerIdOverride(request, sessionPinnedPeerId) {
-    // Per-request header takes priority over session pin
-    const header = request.headers['x-antseed-pin-peer']?.trim().toLowerCase();
-    if (header && header.length > 0)
-        return header;
-    return sessionPinnedPeerId?.toLowerCase() ?? null;
-}
-function getPreferredPeerIdHint(request) {
-    const header = request.headers['x-antseed-prefer-peer']?.trim().toLowerCase();
-    if (!header || header.length === 0) {
-        return null;
-    }
-    return header;
-}
-function getPeerProviderProtocols(peer, provider, requestedService) {
-    const normalizedRequestedService = requestedService?.trim();
-    const fromMetadata = peer.providerServiceApiProtocols?.[provider]?.services;
-    if (fromMetadata) {
-        if (normalizedRequestedService) {
-            const directMatchKey = Object.keys(fromMetadata).find((key) => key.toLowerCase() === normalizedRequestedService.toLowerCase());
-            if (directMatchKey && fromMetadata[directMatchKey]?.length) {
-                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(`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 (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 = inferProviderDefaultServiceApiProtocols(provider);
-    log(`No metadata: peer ${peer.peerId.slice(0, 8)} provider=${provider} → inferred [${inferred.join(',')}]`);
-    return inferred;
-}
-function resolvePeerRoutePlan(peer, requestProtocol, requestedService, explicitProvider) {
-    const providers = peer.providers
-        .map((provider) => provider.trim().toLowerCase())
-        .filter((provider) => provider.length > 0);
-    if (providers.length === 0) {
-        return null;
-    }
-    if (explicitProvider && !providers.includes(explicitProvider)) {
-        return null;
-    }
-    const candidates = explicitProvider ? [explicitProvider] : providers;
-    if (!requestProtocol) {
-        const provider = candidates[0];
-        return provider ? { provider, selection: null } : null;
-    }
-    let transformedFallback = null;
-    for (const provider of candidates) {
-        const supportedProtocols = getPeerProviderProtocols(peer, provider, requestedService);
-        const selection = selectTargetProtocolForRequest(requestProtocol, supportedProtocols);
-        if (!selection) {
-            continue;
-        }
-        if (!selection.requiresTransform) {
-            return { provider, selection };
-        }
-        if (!transformedFallback) {
-            transformedFallback = { provider, selection };
-        }
-    }
-    return transformedFallback;
-}
-export function selectCandidatePeersForRouting(peers, requestProtocol, requestedService, explicitProvider) {
-    const routePlanByPeerId = new Map();
-    if (!requestProtocol && !explicitProvider) {
-        return {
-            candidatePeers: peers,
-            routePlanByPeerId,
-        };
-    }
-    const candidatePeers = peers.filter((peer) => {
-        const plan = resolvePeerRoutePlan(peer, requestProtocol, requestedService, explicitProvider);
-        if (!plan)
-            return false;
-        routePlanByPeerId.set(peer.peerId, plan);
-        return true;
-    });
-    return {
-        candidatePeers,
-        routePlanByPeerId,
-    };
-}
-function parseTokenCount(value) {
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return 0;
-    }
-    return Math.floor(parsed);
-}
-function parseUsageObject(value) {
-    if (!value || typeof value !== 'object') {
-        return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    }
-    const usage = value;
-    const total = parseTokenCount(usage.totalTokens ?? usage.total_tokens ?? usage.total_token_count);
-    let input = parseTokenCount(usage.inputTokens
-        ?? usage.input_tokens
-        ?? usage.promptTokens
-        ?? usage.prompt_tokens
-        ?? usage.input_token_count
-        ?? usage.prompt_token_count
-        ?? usage.cache_creation_input_tokens
-        ?? usage.cache_read_input_tokens);
-    let output = parseTokenCount(usage.outputTokens
-        ?? usage.output_tokens
-        ?? usage.completionTokens
-        ?? usage.completion_tokens
-        ?? usage.output_token_count
-        ?? usage.completion_token_count);
-    if (total > 0) {
-        if (input === 0 && output === 0) {
-            output = total;
-        }
-        else if (output === 0 && input > 0 && total >= input) {
-            output = total - input;
-        }
-        else if (input === 0 && output > 0 && total >= output) {
-            input = total - output;
-        }
-    }
-    return {
-        inputTokens: input,
-        outputTokens: output,
-        totalTokens: input + output,
-    };
-}
-function estimateTokensFromBytes(inputBytes, outputBytes) {
-    const inputTokens = Math.max(1, Math.round(Math.max(0, inputBytes) / 4));
-    const outputTokens = Math.max(1, Math.round(Math.max(0, outputBytes) / 4));
-    return {
-        inputTokens,
-        outputTokens,
-        totalTokens: inputTokens + outputTokens,
-        source: 'estimated',
-    };
-}
-function parseSseUsage(body) {
-    const text = new TextDecoder().decode(body);
-    const lines = text.split('\n');
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let totalTokens = 0;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('data:'))
-            continue;
-        const payload = trimmed.slice(5).trim();
-        if (payload.length === 0 || payload === '[DONE]')
-            continue;
-        let parsed;
-        try {
-            parsed = JSON.parse(payload);
-        }
-        catch {
-            continue;
-        }
-        const directUsage = parseUsageObject(parsed.usage);
-        if (directUsage.totalTokens > 0) {
-            inputTokens = Math.max(inputTokens, directUsage.inputTokens);
-            outputTokens = Math.max(outputTokens, directUsage.outputTokens);
-            totalTokens = Math.max(totalTokens, directUsage.totalTokens);
-        }
-        const message = parsed.message;
-        const messageUsage = parseUsageObject(message && typeof message === 'object' ? message.usage : undefined);
-        if (messageUsage.totalTokens > 0) {
-            inputTokens = Math.max(inputTokens, messageUsage.inputTokens);
-            outputTokens = Math.max(outputTokens, messageUsage.outputTokens);
-            totalTokens = Math.max(totalTokens, messageUsage.totalTokens);
-        }
-    }
-    if (totalTokens <= 0) {
-        totalTokens = inputTokens + outputTokens;
-    }
-    return { inputTokens, outputTokens, totalTokens };
-}
-function parseJsonUsage(body) {
-    try {
-        const parsed = JSON.parse(new TextDecoder().decode(body));
-        const direct = parseUsageObject(parsed.usage);
-        if (direct.totalTokens > 0) {
-            return direct;
-        }
-        const message = parsed.message;
-        if (message && typeof message === 'object') {
-            const nested = parseUsageObject(message.usage);
-            if (nested.totalTokens > 0) {
-                return nested;
-            }
-        }
-        const result = parsed.result;
-        if (result && typeof result === 'object') {
-            const nested = parseUsageObject(result.usage);
-            if (nested.totalTokens > 0) {
-                return nested;
-            }
-        }
-        return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    }
-    catch {
-        return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    }
-}
-function pickProviderForPeer(peer, request) {
-    const explicit = getExplicitProviderOverride(request);
-    if (explicit) {
-        return explicit;
-    }
-    if (request.path.startsWith('/v1/messages') && peer.providers.includes('anthropic')) {
-        return 'anthropic';
-    }
-    const first = peer.providers[0]?.trim();
-    if (first && first.length > 0) {
-        return first.toLowerCase();
-    }
-    return 'unknown';
-}
-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 service = parsed.service ?? parsed.model;
-        if (typeof service === 'string' && service.trim().length > 0) {
-            return service.trim();
-        }
-        return null;
-    }
-    catch {
-        return null;
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
+function adaptOpenAICompatibleErrorResponse(response, requestProtocol) {
+    if (response.statusCode !== 402) {
+        return response;
     }
-}
-function decodeJsonBody(body) {
-    if (!body || body.length === 0) {
-        return null;
+    if (requestProtocol !== 'openai-responses' && requestProtocol !== 'openai-chat-completions') {
+        return response;
     }
+    let parsed = null;
     try {
-        const parsed = JSON.parse(new TextDecoder().decode(body));
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return null;
-        }
-        return parsed;
+        parsed = JSON.parse(Buffer.from(response.body).toString('utf-8'));
     }
     catch {
-        return null;
-    }
-}
-function summarizeMessageShape(messagesRaw) {
-    if (!Array.isArray(messagesRaw)) {
-        return 'msgShape=none';
-    }
-    const roleCounts = new Map();
-    const contentKindCounts = new Map();
-    const blockTypeCounts = new Map();
-    let invalidMessages = 0;
-    let firstRole = 'none';
-    let lastRole = 'none';
-    const bump = (map, key) => {
-        map.set(key, (map.get(key) ?? 0) + 1);
-    };
-    for (const entry of messagesRaw) {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-            invalidMessages += 1;
-            continue;
-        }
-        const message = entry;
-        const role = typeof message.role === 'string' && message.role.trim().length > 0
-            ? message.role.trim().toLowerCase()
-            : 'invalid-role';
-        bump(roleCounts, role);
-        if (firstRole === 'none') {
-            firstRole = role;
-        }
-        lastRole = role;
-        const content = message.content;
-        if (typeof content === 'string') {
-            bump(contentKindCounts, 'string');
-            continue;
-        }
-        if (Array.isArray(content)) {
-            bump(contentKindCounts, 'array');
-            for (const block of content) {
-                if (!block || typeof block !== 'object' || Array.isArray(block)) {
-                    bump(blockTypeCounts, 'invalid');
-                    continue;
-                }
-                const blockType = typeof block.type === 'string'
-                    ? String(block.type).trim().toLowerCase()
-                    : 'missing-type';
-                bump(blockTypeCounts, blockType || 'missing-type');
-            }
-            continue;
-        }
-        if (content && typeof content === 'object') {
-            bump(contentKindCounts, 'object');
-            continue;
-        }
-        bump(contentKindCounts, 'other');
-    }
-    const joinMap = (map) => ([...map.entries()]
-        .sort((left, right) => left[0].localeCompare(right[0]))
-        .map(([key, value]) => `${key}:${String(value)}`)
-        .join(','));
-    const roleSummary = joinMap(roleCounts) || 'none';
-    const contentSummary = joinMap(contentKindCounts) || 'none';
-    const blockSummary = joinMap(blockTypeCounts) || 'none';
-    return [
-        `msgShape=roles{${roleSummary}}`,
-        `content{${contentSummary}}`,
-        `blocks{${blockSummary}}`,
-        `firstRole=${firstRole}`,
-        `lastRole=${lastRole}`,
-        `invalidMsgs=${String(invalidMessages)}`,
-    ].join(' ');
-}
-function summarizeRequestShape(request) {
-    const contentType = (request.headers['content-type'] ?? request.headers['Content-Type'] ?? '').toLowerCase();
-    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 service = extractRequestedService(request) ?? 'none';
-    const wantsStreaming = requestWantsStreaming(request.headers, request.body);
-    const baseParts = [
-        `method=${request.method}`,
-        `path=${request.path}`,
-        `provider=${providerHeader}`,
-        `preferPeer=${preferPeerHeader}`,
-        `contentType=${contentType || 'none'}`,
-        `accept=${accept || 'none'}`,
-        `stream=${String(wantsStreaming)}`,
-        `service=${service}`,
-        `bodyBytes=${String(request.body.length)}`,
-    ];
-    const jsonBody = decodeJsonBody(request.body);
-    if (!jsonBody) {
-        return baseParts.join(' ');
-    }
-    const messagesRaw = jsonBody.messages;
-    const toolsRaw = jsonBody.tools;
-    const messageCount = Array.isArray(messagesRaw) ? messagesRaw.length : 0;
-    const toolCount = Array.isArray(toolsRaw) ? toolsRaw.length : 0;
-    const maxTokens = Number(jsonBody.max_tokens ?? jsonBody.maxTokens);
-    const keys = Object.keys(jsonBody).sort().join(',');
-    baseParts.push(`messages=${String(messageCount)}`);
-    baseParts.push(`tools=${String(toolCount)}`);
-    if (Number.isFinite(maxTokens) && maxTokens > 0) {
-        baseParts.push(`maxTokens=${String(Math.floor(maxTokens))}`);
-    }
-    if (keys.length > 0) {
-        baseParts.push(`keys=[${keys}]`);
-    }
-    baseParts.push(summarizeMessageShape(messagesRaw));
-    return baseParts.join(' ');
-}
-function summarizeErrorResponse(response) {
-    const contentType = (response.headers['content-type'] ?? '').toLowerCase();
-    if (!response.body || response.body.length === 0) {
-        return 'empty response body';
-    }
-    const raw = new TextDecoder().decode(response.body).trim();
-    if (raw.length === 0) {
-        return 'empty response body';
-    }
-    if (contentType.includes('application/json')) {
-        try {
-            const parsed = JSON.parse(raw);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                const object = parsed;
-                const nestedError = object.error && typeof object.error === 'object' && !Array.isArray(object.error)
-                    ? object.error
-                    : null;
-                const message = ((typeof nestedError?.message === 'string' && nestedError.message)
-                    || (typeof object.message === 'string' && object.message)
-                    || (typeof object.detail === 'string' && object.detail));
-                if (message) {
-                    return `message="${message}"`;
-                }
-            }
-        }
-        catch {
-            // fall through to raw snippet
-        }
-    }
-    const compact = raw.replace(/\s+/g, ' ');
-    const maxChars = 280;
-    const snippet = compact.length > maxChars ? `${compact.slice(0, maxChars)}...` : compact;
-    return `body="${snippet}"`;
-}
-function toFiniteNumberOrNull(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : null;
-}
-function setFiniteNumberHeader(headers, name, value) {
-    const finite = toFiniteNumberOrNull(value);
-    if (finite !== null) {
-        headers[name] = String(finite);
-    }
-}
-function setPeerIdentityHeaders(headers, selectedPeer) {
-    headers['x-antseed-peer-id'] = selectedPeer.peerId;
-    if (selectedPeer.publicAddress) {
-        headers['x-antseed-peer-address'] = selectedPeer.publicAddress;
-    }
-    if (selectedPeer.providers.length > 0) {
-        headers['x-antseed-peer-providers'] = selectedPeer.providers.join(',');
+        return response;
     }
-}
-function resolvePeerPricing(peer, provider, service) {
-    const providerPricing = peer.providerPricing?.[provider];
-    if (providerPricing) {
-        const servicePricing = service ? providerPricing.services?.[service] : undefined;
-        if (servicePricing) {
-            return {
-                inputUsdPerMillion: toFiniteNumberOrNull(servicePricing.inputUsdPerMillion),
-                outputUsdPerMillion: toFiniteNumberOrNull(servicePricing.outputUsdPerMillion),
-            };
-        }
-        return {
-            inputUsdPerMillion: toFiniteNumberOrNull(providerPricing.defaults.inputUsdPerMillion),
-            outputUsdPerMillion: toFiniteNumberOrNull(providerPricing.defaults.outputUsdPerMillion),
-        };
+    if (!parsed || parsed.error !== 'payment_required') {
+        return response;
     }
-    return {
-        inputUsdPerMillion: toFiniteNumberOrNull(peer.defaultInputUsdPerMillion),
-        outputUsdPerMillion: toFiniteNumberOrNull(peer.defaultOutputUsdPerMillion),
+    const wrappedError = {
+        error: {
+            ...parsed,
+            type: 'payment_required',
+            message: JSON.stringify(parsed),
+        },
     };
-}
-function computeResponseTelemetry(request, responseHeaders, responseBody, selectedPeer) {
-    const provider = pickProviderForPeer(selectedPeer, request);
-    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)
-        : parseJsonUsage(responseBody);
-    let usage;
-    if (usageFromBody.totalTokens > 0) {
-        usage = {
-            inputTokens: usageFromBody.inputTokens,
-            outputTokens: usageFromBody.outputTokens,
-            totalTokens: usageFromBody.totalTokens,
-            source: 'usage',
-        };
-    }
-    else {
-        usage = estimateTokensFromBytes(request.body.length, responseBody.length);
-    }
-    let estimatedCostUsd = null;
-    if (pricing.inputUsdPerMillion !== null &&
-        pricing.outputUsdPerMillion !== null &&
-        Number.isFinite(pricing.inputUsdPerMillion) &&
-        Number.isFinite(pricing.outputUsdPerMillion)) {
-        estimatedCostUsd =
-            (usage.inputTokens * pricing.inputUsdPerMillion + usage.outputTokens * pricing.outputUsdPerMillion) / 1_000_000;
-    }
     return {
-        usage,
-        pricing: {
-            provider,
-            service,
-            inputUsdPerMillion: pricing.inputUsdPerMillion,
-            outputUsdPerMillion: pricing.outputUsdPerMillion,
+        ...response,
+        headers: {
+            ...response.headers,
+            'content-type': 'application/json',
         },
-        estimatedCostUsd,
+        body: Buffer.from(JSON.stringify(wrappedError)),
     };
 }
-function attachAntseedTelemetryHeaders(upstreamHeaders, selectedPeer, telemetry, requestId, latencyMs) {
-    const headers = { ...upstreamHeaders };
-    headers['x-antseed-request-id'] = requestId;
-    headers['x-antseed-latency-ms'] = String(Math.max(0, Math.floor(latencyMs)));
-    setPeerIdentityHeaders(headers, selectedPeer);
-    setFiniteNumberHeader(headers, 'x-antseed-peer-reputation', selectedPeer.reputationScore);
-    setFiniteNumberHeader(headers, 'x-antseed-peer-trust-score', selectedPeer.trustScore);
-    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.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);
-    headers['x-antseed-token-source'] = telemetry.usage.source;
-    headers['x-antseed-input-tokens'] = String(telemetry.usage.inputTokens);
-    headers['x-antseed-output-tokens'] = String(telemetry.usage.outputTokens);
-    headers['x-antseed-total-tokens'] = String(telemetry.usage.totalTokens);
-    if (telemetry.estimatedCostUsd !== null && Number.isFinite(telemetry.estimatedCostUsd)) {
-        headers['x-antseed-estimated-cost-usd'] = telemetry.estimatedCostUsd.toFixed(6);
-    }
-    return headers;
-}
-function attachStreamingAntseedHeaders(upstreamHeaders, selectedPeer, requestId) {
-    const headers = { ...upstreamHeaders };
-    headers['x-antseed-request-id'] = requestId;
-    setPeerIdentityHeaders(headers, selectedPeer);
-    return headers;
-}
-function requestWantsStreaming(headers, body) {
-    const accept = (headers['accept'] ?? headers['Accept'] ?? '').toLowerCase();
-    if (accept.includes('text/event-stream')) {
-        return true;
-    }
-    const contentType = (headers['content-type'] ?? headers['Content-Type'] ?? '').toLowerCase();
-    if (!contentType.includes('application/json') || body.length === 0) {
-        return false;
-    }
-    try {
-        const parsed = JSON.parse(new TextDecoder().decode(body));
-        return parsed.stream === true;
-    }
-    catch {
-        return false;
-    }
-}
-function isConnectionChurnError(message) {
-    return /connection .*?\b(closed|failed)\s+during request\b/i.test(message);
-}
-function isConnectionHealthy(state) {
-    if (!state) {
-        return false;
-    }
-    const normalized = String(state).toLowerCase();
-    return normalized === 'open' || normalized === 'authenticated' || normalized === 'connecting';
-}
-function extractHostFromAddress(address) {
-    const trimmed = address.trim();
-    if (trimmed.length === 0)
-        return '';
-    if (trimmed.startsWith('[')) {
-        const end = trimmed.indexOf(']');
-        return end > 1 ? trimmed.slice(1, end).toLowerCase() : '';
-    }
-    const idx = trimmed.lastIndexOf(':');
-    if (idx > 0) {
-        return trimmed.slice(0, idx).toLowerCase();
-    }
-    return trimmed.toLowerCase();
-}
-function isLoopbackHost(host) {
-    return host === '127.0.0.1' || host === 'localhost' || host === '::1';
-}
-function isLoopbackPeer(peer) {
-    if (!peer.publicAddress) {
-        return false;
-    }
-    const host = extractHostFromAddress(peer.publicAddress);
-    return isLoopbackHost(host);
-}
-/**
- * Rewrite the `service` (and `model` for upstream LLM API compat) fields in a JSON request body.
- * Also updates `content-length` if present in headers.
- * Returns the original body/headers unchanged if the body is not JSON,
- * is empty, or cannot be parsed.
- */
-export function rewriteServiceInBody(body, headers, service) {
-    const contentType = (headers['content-type'] ?? headers['Content-Type'] ?? '').toLowerCase();
-    if (!contentType.includes('application/json') || body.length === 0) {
-        return { body, headers };
-    }
-    try {
-        const parsed = JSON.parse(new TextDecoder().decode(body));
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return { body, headers };
-        }
-        const obj = parsed;
-        obj['service'] = service;
-        obj['model'] = service;
-        const rewritten = new TextEncoder().encode(JSON.stringify(obj));
-        const updatedHeaders = { ...headers };
-        if ('content-length' in updatedHeaders) {
-            updatedHeaders['content-length'] = String(rewritten.length);
-        }
-        else if ('Content-Length' in updatedHeaders) {
-            updatedHeaders['Content-Length'] = String(rewritten.length);
-        }
-        return { body: rewritten, headers: updatedHeaders };
-    }
-    catch {
-        return { body, headers };
-    }
-}
+const PROTOCOL_TRANSFORMS = {
+    'anthropic-messages→openai-chat-completions': {
+        transformRequest: transformAnthropicMessagesRequestToOpenAIChat,
+        adaptResponse: (res, meta) => transformOpenAIChatResponseToAnthropicMessage(res, meta),
+        createStreamAdapter: createOpenAIChatToAnthropicStreamingAdapter,
+    },
+    'openai-responses→openai-chat-completions': {
+        transformRequest: transformOpenAIResponsesRequestToOpenAIChat,
+        adaptResponse: (res, meta) => transformOpenAIChatResponseToOpenAIResponses(res, meta),
+        createStreamAdapter: createOpenAIChatToResponsesStreamingAdapter,
+    },
+    'openai-chat-completions→openai-responses': {
+        transformRequest: transformOpenAIChatRequestToOpenAIResponses,
+        adaptResponse: (res, meta) => transformOpenAIResponsesResponseToOpenAIChat(res, meta),
+        createStreamAdapter: createOpenAIResponsesToChatStreamingAdapter,
+    },
+};
 /**
  * Local HTTP proxy that forwards requests to P2P sellers.
  *
@@ -625,6 +80,7 @@ export class BuyerProxy {
     _pinnedService;
     _stateFileWatcher = null;
     _stateWatchDebounce = null;
+    _stateWriteChain = Promise.resolve();
     _cachedPeers = [];
     _cacheLastUpdatedAtMs = 0;
     _cacheMutationEpoch = 0;
@@ -659,6 +115,9 @@ export class BuyerProxy {
             });
         });
         this._startBackgroundRefresh();
+        // Trigger initial peer discovery immediately so the desktop can show
+        // services without waiting for the first request or 5-minute interval.
+        void this._refreshPeersNow().catch(() => { });
         await this._writeStateFile('connected');
         this._watchStateFile();
     }
@@ -716,38 +175,44 @@ export class BuyerProxy {
             // state file unreadable; keep current values
         }
     }
-    async _writeStateFile(state) {
-        try {
-            const dir = join(homedir(), '.antseed');
-            await mkdir(dir, { recursive: true });
-            let existing = {};
+    /** Serialised read-modify-write to buyer.state.json. Returns the queued write promise. */
+    _mergeStateFile(patch) {
+        this._stateWriteChain = this._stateWriteChain.then(async () => {
             try {
-                const raw = await readFile(BUYER_STATE_FILE, 'utf-8');
-                existing = JSON.parse(raw);
+                const dir = join(homedir(), '.antseed');
+                await mkdir(dir, { recursive: true });
+                let existing = {};
+                try {
+                    const raw = await readFile(BUYER_STATE_FILE, 'utf-8');
+                    existing = JSON.parse(raw);
+                }
+                catch {
+                    // file doesn't exist yet
+                }
+                const data = { ...existing, ...patch };
+                const tmp = join(homedir(), '.antseed', `.buyer.state.${randomUUID()}.json.tmp`);
+                await writeFile(tmp, JSON.stringify(data, null, 2));
+                await rename(tmp, BUYER_STATE_FILE);
             }
             catch {
-                // file doesn't exist yet
+                // non-fatal
             }
-            // 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'
-                ? { pinnedService: this._pinnedService, pinnedPeerId: this._pinnedPeer }
-                : {};
-            const data = {
-                ...existing,
-                state,
-                pid: process.pid,
-                port: this._port,
-                ...sessionOverrides,
-            };
-            const tmp = join(homedir(), '.antseed', `.buyer.state.${randomUUID()}.json.tmp`);
-            await writeFile(tmp, JSON.stringify(data, null, 2));
-            await rename(tmp, BUYER_STATE_FILE);
-        }
-        catch {
-            // non-fatal
-        }
+        }).catch(() => { });
+        return this._stateWriteChain;
+    }
+    async _writeStateFile(state) {
+        // 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'
+            ? { pinnedService: this._pinnedService, pinnedPeerId: this._pinnedPeer }
+            : {};
+        await this._mergeStateFile({
+            state,
+            pid: process.pid,
+            port: this._port,
+            ...sessionOverrides,
+        });
     }
     _startBackgroundRefresh() {
         this._bgRefreshHandle = setInterval(() => {
@@ -760,6 +225,34 @@ export class BuyerProxy {
         this._cachedPeers = incoming;
         this._cacheLastUpdatedAtMs = Date.now();
         this._cacheMutationEpoch += 1;
+        this._persistPeersToState();
+    }
+    _persistPeersToState() {
+        // Write discovered peers to buyer.state.json so the dashboard can read them
+        // without running its own DHT node.
+        const peers = this._cachedPeers.map((p) => {
+            // Extract service names from providerPricing entries.
+            const services = [];
+            if (p.providerPricing) {
+                for (const entry of Object.values(p.providerPricing)) {
+                    if (entry.services) {
+                        services.push(...Object.keys(entry.services));
+                    }
+                }
+            }
+            return {
+                peerId: p.peerId,
+                displayName: p.displayName ?? null,
+                publicAddress: p.publicAddress ?? null,
+                providers: p.providers,
+                services,
+                defaultInputUsdPerMillion: p.defaultInputUsdPerMillion ?? 0,
+                defaultOutputUsdPerMillion: p.defaultOutputUsdPerMillion ?? 0,
+                maxConcurrency: p.maxConcurrency ?? 0,
+                lastSeen: p.lastSeen,
+            };
+        });
+        this._mergeStateFile({ discoveredPeers: peers, peersUpdatedAt: Date.now() });
     }
     _evictPeer(peerId) {
         const before = this._cachedPeers.length;
@@ -813,55 +306,7 @@ export class BuyerProxy {
             explicitProvider ?? 'auto-provider',
         ].join('|');
     }
-    async _readLocalSeederFallback() {
-        try {
-            const raw = await readFile(DAEMON_STATE_FILE, 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (parsed.state !== 'seeding')
-                return null;
-            if (typeof parsed.peerId !== 'string' || !/^[0-9a-f]{64}$/i.test(parsed.peerId))
-                return null;
-            const signalingPort = Number(parsed.signalingPort);
-            if (!Number.isFinite(signalingPort) || signalingPort <= 0 || signalingPort > 65535)
-                return null;
-            const pid = Number(parsed.pid);
-            if (Number.isFinite(pid) && pid > 0) {
-                try {
-                    process.kill(Math.floor(pid), 0);
-                }
-                catch {
-                    return null;
-                }
-            }
-            const providers = typeof parsed.provider === 'string' && parsed.provider.trim().length > 0
-                ? [parsed.provider.trim()]
-                : [];
-            const defaultInputUsdPerMillion = Number(parsed.defaultInputUsdPerMillion);
-            const defaultOutputUsdPerMillion = Number(parsed.defaultOutputUsdPerMillion);
-            const providerPricing = parsed.providerPricing && typeof parsed.providerPricing === 'object'
-                ? parsed.providerPricing
-                : undefined;
-            const peerId = parsed.peerId.toLowerCase();
-            return {
-                peerId: peerId,
-                lastSeen: Date.now(),
-                publicAddress: `127.0.0.1:${Math.floor(signalingPort)}`,
-                providers,
-                defaultInputUsdPerMillion: Number.isFinite(defaultInputUsdPerMillion) ? defaultInputUsdPerMillion : 0,
-                defaultOutputUsdPerMillion: Number.isFinite(defaultOutputUsdPerMillion) ? defaultOutputUsdPerMillion : 0,
-                ...(providerPricing ? { providerPricing } : {}),
-            };
-        }
-        catch {
-            return null;
-        }
-    }
     async _discoverPeersFromNetwork() {
-        const localSeeder = await this._readLocalSeederFallback();
-        if (localSeeder) {
-            log(`Using local seeder ${localSeeder.peerId.slice(0, 12)}... @ ${localSeeder.publicAddress} (skipping DHT lookup)`);
-            return [localSeeder];
-        }
         log('Discovering peers via DHT...');
         const peers = await this._node.discoverPeers();
         if (peers.length > 0) {
@@ -1108,28 +553,13 @@ export class BuyerProxy {
         }
         if (routingPeers.length === 0) {
             const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
-            res.writeHead(502, { 'content-type': 'text/plain' });
-            if (requestProtocol) {
-                const protocolLabel = requestProtocol;
-                const providerLabel = explicitProvider ? ` for provider "${explicitProvider}"` : '';
-                res.end(`No peers support ${protocolLabel}${providerLabel}. ${diagnostics}`);
-            }
-            else {
-                res.end(`No peers advertise provider "${explicitProvider}". ${diagnostics}`);
-            }
-            return;
-        }
-        if (routingPeers.length === 0) {
-            const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
-            res.writeHead(502, { 'content-type': 'text/plain' });
             const providerLabel = explicitProvider ? ` for provider "${explicitProvider}"` : '';
+            res.writeHead(502, { 'content-type': 'text/plain' });
             res.end(`No peers support ${requestProtocol ?? 'this request'}${providerLabel}. ${diagnostics}`);
             return;
         }
         log(`Routing candidates: ${routingPeers.length} peer(s)`);
-        // Select peer: explicit pin bypasses the router (and retry)
         const router = this._node.router;
-        const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
         if (explicitPeerId) {
             // Pinned peers must use fresh discovery data so IP changes are picked up.
             // Safe with the hasForcedRefresh guard: if an earlier refresh already ran
@@ -1243,7 +673,7 @@ export class BuyerProxy {
             }
             if (!selectedPeer) {
                 selectedPeer = router
-                    ? router.selectPeer(serializedReq, availableCandidates)
+                    ? (router.selectPeer(serializedReq, availableCandidates) ?? availableCandidates[0] ?? null)
                     : availableCandidates[0] ?? null;
             }
             if (!selectedPeer)
@@ -1298,88 +728,35 @@ export class BuyerProxy {
         let adaptResponse = null;
         let streamResponseAdapter = null;
         if (selectedRoutePlan.selection?.requiresTransform) {
-            if (requestProtocol === 'anthropic-messages'
-                && selectedRoutePlan.selection.targetProtocol === 'openai-chat-completions') {
-                log(`Applying protocol adapter anthropic-messages -> openai-chat-completions via provider "${selectedRoutePlan.provider}"`);
-                const transformed = transformAnthropicMessagesRequestToOpenAIChat(requestForPeer);
-                if (!transformed) {
-                    res.writeHead(502, { 'content-type': 'text/plain' });
-                    res.end('Failed to transform Anthropic request for selected provider protocol');
-                    return { done: true };
-                }
-                requestForPeer = {
-                    ...transformed.request,
-                    headers: {
-                        ...transformed.request.headers,
-                        'x-antseed-provider': selectedRoutePlan.provider,
-                    },
-                };
-                adaptResponse = (response) => transformOpenAIChatResponseToAnthropicMessage(response, {
-                    streamRequested: transformed.streamRequested,
-                    fallbackModel: transformed.requestedModel,
-                });
-                if (transformed.streamRequested) {
-                    streamResponseAdapter = createOpenAIChatToAnthropicStreamingAdapter({
-                        fallbackModel: transformed.requestedModel,
-                    });
-                }
+            const transformKey = `${requestProtocol}→${selectedRoutePlan.selection.targetProtocol}`;
+            const strategy = PROTOCOL_TRANSFORMS[transformKey];
+            if (!strategy) {
+                res.writeHead(502, { 'content-type': 'text/plain' });
+                res.end('Unsupported protocol transformation path');
+                return { done: 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,
-                });
-                if (transformed.streamRequested) {
-                    streamResponseAdapter = createOpenAIChatToResponsesStreamingAdapter({
-                        fallbackModel: transformed.requestedModel,
-                    });
-                }
+            log(`Applying protocol adapter ${transformKey} via provider "${selectedRoutePlan.provider}"`);
+            const transformed = strategy.transformRequest(requestForPeer);
+            if (!transformed) {
+                res.writeHead(502, { 'content-type': 'text/plain' });
+                res.end(`Failed to transform request for ${transformKey}`);
+                return { done: true };
             }
-            else if (requestProtocol === 'openai-chat-completions'
-                && selectedRoutePlan.selection.targetProtocol === 'openai-responses') {
-                log(`Applying protocol adapter openai-chat-completions -> openai-responses via provider "${selectedRoutePlan.provider}"`);
-                const transformed = transformOpenAIChatRequestToOpenAIResponses(requestForPeer);
-                if (!transformed) {
-                    res.writeHead(502, { 'content-type': 'text/plain' });
-                    res.end('Failed to transform Chat Completions request for selected provider protocol');
-                    return { done: true };
-                }
-                requestForPeer = {
-                    ...transformed.request,
-                    headers: {
-                        ...transformed.request.headers,
-                        'x-antseed-provider': selectedRoutePlan.provider,
-                    },
-                };
-                adaptResponse = (response) => transformOpenAIResponsesResponseToOpenAIChat(response, {
+            requestForPeer = {
+                ...transformed.request,
+                headers: {
+                    ...transformed.request.headers,
+                    'x-antseed-provider': selectedRoutePlan.provider,
+                },
+            };
+            adaptResponse = (response) => strategy.adaptResponse(response, {
+                streamRequested: transformed.streamRequested,
+                fallbackModel: transformed.requestedModel,
+            });
+            if (transformed.streamRequested) {
+                streamResponseAdapter = strategy.createStreamAdapter({
                     fallbackModel: transformed.requestedModel,
-                    streamRequested: transformed.streamRequested,
                 });
-                if (transformed.streamRequested) {
-                    streamResponseAdapter = createOpenAIResponsesToChatStreamingAdapter({
-                        fallbackModel: transformed.requestedModel,
-                    });
-                }
-            }
-            else {
-                res.writeHead(502, { 'content-type': 'text/plain' });
-                res.end('Unsupported protocol transformation path');
-                return { done: true };
             }
         }
         if (DEBUG()) {
@@ -1429,6 +806,7 @@ export class BuyerProxy {
                 if (!streamed && adaptResponse) {
                     responseForClient = adaptResponse(response);
                 }
+                responseForClient = adaptOpenAICompatibleErrorResponse(responseForClient, requestProtocol);
                 const latencyMs = Date.now() - startTime;
                 log(`Response: ${responseForClient.statusCode} (${latencyMs}ms, ${responseForClient.body.length} bytes)`);
                 if (responseForClient.statusCode >= 400) {
@@ -1480,6 +858,7 @@ export class BuyerProxy {
                 if (adaptResponse) {
                     response = adaptResponse(response);
                 }
+                response = adaptOpenAICompatibleErrorResponse(response, requestProtocol);
                 const latencyMs = Date.now() - startTime;
                 log(`Response: ${response.statusCode} (${latencyMs}ms, ${response.body.length} bytes)`);
                 if (response.statusCode >= 400) {