@antseed/cli 0.1.61 → 0.1.62

package/dist/proxy/buyer-proxy.js

@@ -0,0 +1,1056 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+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, 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 RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
+/** Max age for carrying forward peers not seen in the latest DHT scan. */
+const CARRY_FORWARD_TTL_MS = 30 * 60_000;
+function adaptOpenAICompatibleErrorResponse(response, requestProtocol) {
+    if (response.statusCode !== 402) {
+        return response;
+    }
+    if (requestProtocol !== 'openai-responses' && requestProtocol !== 'openai-chat-completions') {
+        return response;
+    }
+    let parsed = null;
+    try {
+        parsed = JSON.parse(Buffer.from(response.body).toString('utf-8'));
+    }
+    catch {
+        return response;
+    }
+    if (!parsed || parsed.error !== 'payment_required') {
+        return response;
+    }
+    const wrappedError = {
+        error: {
+            ...parsed,
+            type: 'payment_required',
+            message: JSON.stringify(parsed),
+        },
+    };
+    return {
+        ...response,
+        headers: {
+            ...response.headers,
+            'content-type': 'application/json',
+        },
+        body: Buffer.from(JSON.stringify(wrappedError)),
+    };
+}
+/**
+ * Inject the buyer-known peerId into a 402 payment_required JSON body.
+ * The seller doesn't include its own peerId (and shouldn't — self-reported
+ * identity is untrusted). The buyer proxy knows which peer it connected to,
+ * so it stamps the peerId into the body before forwarding to the client.
+ */
+function inject402PeerId(response, peerId) {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(Buffer.from(response.body).toString('utf-8'));
+    }
+    catch {
+        return response;
+    }
+    if (!parsed)
+        return response;
+    // Handle both flat { error: 'payment_required', ... } and
+    // wrapped { error: { type: 'payment_required', ... } } formats.
+    if (parsed.error === 'payment_required') {
+        parsed.peerId = peerId;
+    }
+    else if (typeof parsed.error === 'object' &&
+        parsed.error !== null &&
+        parsed.error.type === 'payment_required') {
+        parsed.error.peerId = peerId;
+    }
+    else {
+        return response;
+    }
+    return {
+        ...response,
+        body: Buffer.from(JSON.stringify(parsed)),
+    };
+}
+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.
+ *
+ * Tools like Claude CLI set ANTHROPIC_BASE_URL=http://localhost:8377
+ * and the proxy transparently routes their API calls through the
+ * Antseed P2P network.
+ */
+export class BuyerProxy {
+    _server;
+    _node;
+    _port;
+    _bgRefreshIntervalMs;
+    _peerCacheTtlMs;
+    _pinnedPeer;
+    _pinnedService;
+    _stateFileWatcher = null;
+    _stateWatchDebounce = null;
+    _stateWriteChain = Promise.resolve();
+    _cachedPeers = [];
+    _cacheLastUpdatedAtMs = 0;
+    _cacheMutationEpoch = 0;
+    _peerRefreshPromise = null;
+    _lastStaleCacheLogAtMs = 0;
+    _bgRefreshHandle = null;
+    _lastSuccessfulPeerId = null;
+    _lastSuccessfulPeerByRouteKey = new Map();
+    constructor(config) {
+        this._node = config.node;
+        this._port = config.port;
+        this._bgRefreshIntervalMs = config.backgroundRefreshIntervalMs ?? 5 * 60_000;
+        this._peerCacheTtlMs = Math.max(0, config.peerCacheTtlMs ?? 30_000);
+        this._pinnedPeer = config.pinnedPeerId?.toLowerCase() ?? null;
+        this._pinnedService = config.pinnedService?.trim() ?? null;
+        this._server = createServer((req, res) => {
+            this._handleRequest(req, res).catch((err) => {
+                log('Unhandled error:', err);
+                if (!res.headersSent) {
+                    res.writeHead(502, { 'content-type': 'text/plain' });
+                }
+                res.end(`Proxy error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        });
+    }
+    async start() {
+        await new Promise((resolve, reject) => {
+            this._server.once('error', reject);
+            this._server.listen(this._port, '127.0.0.1', () => {
+                this._server.removeListener('error', reject);
+                resolve();
+            });
+        });
+        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();
+    }
+    async stop() {
+        if (this._stateWatchDebounce) {
+            clearTimeout(this._stateWatchDebounce);
+            this._stateWatchDebounce = null;
+        }
+        if (this._stateFileWatcher) {
+            this._stateFileWatcher.close();
+            this._stateFileWatcher = null;
+        }
+        if (this._bgRefreshHandle) {
+            clearInterval(this._bgRefreshHandle);
+            this._bgRefreshHandle = null;
+        }
+        await this._writeStateFile('stopped');
+        return new Promise((resolve) => {
+            this._server.close(() => resolve());
+        });
+    }
+    _watchStateFile() {
+        try {
+            this._stateFileWatcher = watch(BUYER_STATE_FILE, { persistent: false }, () => {
+                if (this._stateWatchDebounce)
+                    clearTimeout(this._stateWatchDebounce);
+                this._stateWatchDebounce = setTimeout(() => {
+                    this._stateWatchDebounce = null;
+                    void this._reloadSessionOverrides().catch(() => { });
+                }, 50);
+            });
+            this._stateFileWatcher.on('error', () => {
+                // watcher error is non-fatal
+            });
+        }
+        catch {
+            // watcher setup failed; non-fatal
+        }
+    }
+    async _reloadSessionOverrides() {
+        try {
+            const raw = await readFile(BUYER_STATE_FILE, 'utf-8');
+            const parsed = JSON.parse(raw);
+            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._pinnedService = pinnedService;
+            this._pinnedPeer = pinnedPeer;
+            log(`Session overrides reloaded: service=${pinnedService ?? 'none'} peer=${pinnedPeer ?? 'none'}`);
+        }
+        catch {
+            // state file unreadable; keep current values
+        }
+    }
+    /** Serialised read-modify-write to buyer.state.json. Returns the queued write promise. */
+    _mergeStateFile(patch) {
+        this._stateWriteChain = this._stateWriteChain.then(async () => {
+            try {
+                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 {
+                // 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(() => {
+            void this._refreshPeersNow().catch(() => {
+                // background refresh failure is non-fatal
+            });
+        }, this._bgRefreshIntervalMs);
+    }
+    _replacePeers(incoming) {
+        const incomingById = new Map(incoming.map((p) => [p.peerId, p]));
+        const now = Date.now();
+        // Carry forward previously known peers that are missing from this scan,
+        // preserving their lastSeen timestamp. A missed DHT scan doesn't mean
+        // the peer is unavailable — it just wasn't discovered this time.
+        const merged = [...incoming];
+        for (const prev of this._cachedPeers) {
+            if (!incomingById.has(prev.peerId) && now - prev.lastSeen < CARRY_FORWARD_TTL_MS) {
+                merged.push({ ...prev });
+            }
+        }
+        this._cachedPeers = merged;
+        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,
+                providerPricing: p.providerPricing ?? null,
+                providerServiceApiProtocols: p.providerServiceApiProtocols ?? null,
+                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;
+        this._cachedPeers = this._cachedPeers.filter((p) => p.peerId !== peerId);
+        if (this._cachedPeers.length < before) {
+            this._cacheLastUpdatedAtMs = Date.now();
+            this._cacheMutationEpoch += 1;
+            this._persistPeersToState();
+            log(`Evicted failing peer ${peerId.slice(0, 12)}... from cache (${this._cachedPeers.length} remaining)`);
+        }
+    }
+    _rememberSuccessfulPeer(routeKey, peerId) {
+        this._lastSuccessfulPeerId = peerId;
+        this._lastSuccessfulPeerByRouteKey.set(routeKey, peerId);
+        // Keep map bounded to prevent unbounded growth from long-running channels.
+        const MAX_ROUTE_HISTORY = 200;
+        if (this._lastSuccessfulPeerByRouteKey.size > MAX_ROUTE_HISTORY) {
+            const oldestKey = this._lastSuccessfulPeerByRouteKey.keys().next().value;
+            if (typeof oldestKey === 'string') {
+                this._lastSuccessfulPeerByRouteKey.delete(oldestKey);
+            }
+        }
+    }
+    _forgetSuccessfulPeer(routeKey, peerId) {
+        const rememberedForRoute = this._lastSuccessfulPeerByRouteKey.get(routeKey);
+        if (rememberedForRoute === peerId) {
+            this._lastSuccessfulPeerByRouteKey.delete(routeKey);
+        }
+        if (this._lastSuccessfulPeerId === peerId) {
+            const stillUsedByOtherRoute = Array.from(this._lastSuccessfulPeerByRouteKey.values())
+                .some((rememberedPeerId) => rememberedPeerId === peerId);
+            if (!stillUsedByOtherRoute) {
+                this._lastSuccessfulPeerId = null;
+            }
+        }
+    }
+    _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/responses')
+                    ? '/v1/responses'
+                    : normalizedPath.startsWith('/v1/models')
+                        ? '/v1/models'
+                        : normalizedPath);
+        return [
+            pathGroup,
+            requestProtocol ?? 'unknown-protocol',
+            requestedService ?? 'unknown-service',
+            explicitProvider ?? 'auto-provider',
+        ].join('|');
+    }
+    async _discoverPeersFromNetwork() {
+        log('Discovering peers via DHT...');
+        const peers = await this._node.discoverPeers();
+        if (peers.length > 0) {
+            log(`Found ${peers.length} peer(s)`);
+        }
+        return peers;
+    }
+    async _refreshPeersNow() {
+        if (this._peerRefreshPromise) {
+            return this._peerRefreshPromise;
+        }
+        const previousCachedPeers = [...this._cachedPeers];
+        const mutationEpochAtStart = this._cacheMutationEpoch;
+        this._peerRefreshPromise = (async () => {
+            const peers = await this._discoverPeersFromNetwork();
+            if (peers.length > 0) {
+                this._replacePeers(peers);
+                return peers;
+            }
+            const fallbackPeers = previousCachedPeers.length > 0 && this._cacheMutationEpoch === mutationEpochAtStart
+                ? [...previousCachedPeers]
+                : [];
+            if (fallbackPeers.length > 0) {
+                // Preserve stale cache as fallback when discovery transiently fails.
+                log('Discovery returned 0 peers; preserving most-recent cached peers as fallback.');
+                this._replacePeers(fallbackPeers);
+                return fallbackPeers;
+            }
+            return peers;
+        })().finally(() => {
+            this._peerRefreshPromise = null;
+        });
+        return this._peerRefreshPromise;
+    }
+    async _getPeers(options) {
+        const forceRefresh = options?.forceRefresh === true;
+        const cacheAgeMs = Date.now() - this._cacheLastUpdatedAtMs;
+        const cacheFresh = this._cacheLastUpdatedAtMs > 0 && cacheAgeMs <= this._peerCacheTtlMs;
+        if (forceRefresh) {
+            log('Forcing peer refresh before routing.');
+            return this._refreshPeersNow();
+        }
+        if (this._cachedPeers.length > 0) {
+            if (cacheFresh) {
+                return this._cachedPeers;
+            }
+            const now = Date.now();
+            if (now - this._lastStaleCacheLogAtMs >= 10_000) {
+                this._lastStaleCacheLogAtMs = now;
+                log(`Peer cache stale (${cacheAgeMs}ms old); routing from cached peers.`);
+            }
+            return this._cachedPeers;
+        }
+        // No cached peers yet — block on initial discovery.
+        return this._refreshPeersNow();
+    }
+    _formatPeerSelectionDiagnostics(peers) {
+        if (peers.length === 0) {
+            return 'No peers discovered.';
+        }
+        const summarize = (peer) => {
+            const providers = peer.providers
+                .map((provider) => provider.trim())
+                .filter((provider) => provider.length > 0);
+            const trust = Number.isFinite(peer.trustScore) ? String(peer.trustScore) : 'n/a';
+            const rep = Number.isFinite(peer.reputationScore) ? String(peer.reputationScore) : 'n/a';
+            const onChain = Number.isFinite(peer.onChainChannelCount) ? String(peer.onChainChannelCount) : 'n/a';
+            const input = Number.isFinite(peer.defaultInputUsdPerMillion) ? String(peer.defaultInputUsdPerMillion) : 'n/a';
+            const output = Number.isFinite(peer.defaultOutputUsdPerMillion) ? String(peer.defaultOutputUsdPerMillion) : 'n/a';
+            return `${peer.peerId.slice(0, 8)} providers=[${providers.join(',') || 'none'}] trust=${trust} rep=${rep} onchain=${onChain} in=${input} out=${output}`;
+        };
+        const samples = peers.slice(0, 5).map((peer) => summarize(peer)).join(' | ');
+        const suffix = peers.length > 5 ? ` (+${peers.length - 5} more)` : '';
+        return `Discovered ${peers.length} peer(s): ${samples}${suffix}`;
+    }
+    async _handleControlPlane(req, res, method, path) {
+        const origin = req.headers.origin ?? '';
+        const isLocal = origin.startsWith('http://127.0.0.1') || origin.startsWith('http://localhost') || origin === 'file://';
+        if (isLocal)
+            res.setHeader('Access-Control-Allow-Origin', origin);
+        if (method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (path === '/_antseed/peers' && method === 'GET') {
+            const peers = await this._getPeers();
+            const payload = peers.map((p) => ({
+                peerId: p.peerId,
+                displayName: p.displayName,
+                publicAddress: p.publicAddress,
+                providers: p.providers,
+                providerPricing: p.providerPricing,
+                providerServiceCategories: p.providerServiceCategories,
+                providerServiceApiProtocols: p.providerServiceApiProtocols,
+                reputationScore: p.reputationScore,
+                trustScore: p.trustScore,
+                lastSeen: p.lastSeen,
+            }));
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, peers: payload }));
+            return;
+        }
+        if (path === '/_antseed/connect' && method === 'POST') {
+            const chunks = [];
+            let totalSize = 0;
+            for await (const chunk of req) {
+                totalSize += chunk.length;
+                if (totalSize > 8192) {
+                    res.writeHead(413, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Request body too large' }));
+                    return;
+                }
+                chunks.push(chunk);
+            }
+            let peerId;
+            try {
+                const body = JSON.parse(Buffer.concat(chunks).toString());
+                peerId = String(body.peerId ?? '');
+            }
+            catch {
+                res.writeHead(400, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Invalid JSON body' }));
+                return;
+            }
+            if (!peerId) {
+                res.writeHead(400, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Missing peerId' }));
+                return;
+            }
+            const peers = await this._getPeers();
+            const peer = peers.find((p) => p.peerId === peerId);
+            if (!peer) {
+                res.writeHead(404, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Peer not found in cache' }));
+                return;
+            }
+            try {
+                await this._node.connectToPeer(peer);
+                log(`Eager connection established to ${peerId.slice(0, 12)}...`);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                log(`Eager connection failed for ${peerId.slice(0, 12)}...: ${message}`);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: message }));
+            }
+            return;
+        }
+        const meteringMatch = path.match(/^\/_antseed\/metering\/(.+)$/);
+        if (meteringMatch && method === 'GET') {
+            const sellerPeerId = decodeURIComponent(meteringMatch[1]);
+            const stats = this._node.getMeteringStatsByPeer(sellerPeerId);
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(stats));
+            return;
+        }
+        res.writeHead(404, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Unknown control-plane endpoint' }));
+    }
+    async _handleRequest(req, res) {
+        const method = req.method ?? 'GET';
+        const path = req.url ?? '/';
+        log(`${method} ${path}`);
+        // Control-plane endpoints — handle before collecting proxy body
+        if (path.startsWith('/_antseed/')) {
+            return this._handleControlPlane(req, res, method, path);
+        }
+        // Only proxy known API paths — reject everything else with 404
+        const normalizedPath = path.split('?')[0]?.trim().toLowerCase() ?? '/';
+        const isKnownApiPath = normalizedPath.startsWith('/v1/messages') ||
+            normalizedPath.startsWith('/v1/chat/completions') ||
+            normalizedPath.startsWith('/v1/responses') ||
+            normalizedPath.startsWith('/v1/models');
+        if (!isKnownApiPath) {
+            res.writeHead(404, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Not found', type: 'invalid_request_error' } }));
+            return;
+        }
+        // Collect request body
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(chunk);
+        }
+        const body = Buffer.concat(chunks);
+        // Build serialized request
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string') {
+                headers[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                headers[key] = value.join(', ');
+            }
+        }
+        // Remove host header (points to localhost, not the seller)
+        delete headers['host'];
+        let serializedReq = {
+            requestId: randomUUID(),
+            method,
+            path,
+            headers,
+            body: new Uint8Array(body),
+        };
+        // Snapshot both session overrides together before any await so a concurrent
+        // _reloadSessionOverrides() cannot produce a service/peer mismatch mid-request.
+        const effectivePinnedService = this._pinnedService;
+        const effectivePinnedPeer = this._pinnedPeer;
+        if (effectivePinnedService) {
+            const { body: rewrittenBody, headers: rewrittenHeaders } = rewriteServiceInBody(serializedReq.body, serializedReq.headers, effectivePinnedService);
+            if (rewrittenBody !== serializedReq.body) {
+                serializedReq = { ...serializedReq, body: rewrittenBody, headers: rewrittenHeaders };
+                log(`Service override applied: ${effectivePinnedService}`);
+            }
+        }
+        const clientAbortController = new AbortController();
+        const onClientAbort = () => {
+            if (clientAbortController.signal.aborted) {
+                return;
+            }
+            clientAbortController.abort();
+            log(`Client disconnected; aborting upstream request reqId=${serializedReq.requestId.slice(0, 8)}`);
+        };
+        req.once('close', () => {
+            if (!req.complete && !res.writableEnded) {
+                onClientAbort();
+            }
+        });
+        res.once('close', () => {
+            if (!res.writableEnded) {
+                onClientAbort();
+            }
+        });
+        // Discover peers
+        const peers = await this._getPeers();
+        if (peers.length === 0) {
+            log('No sellers available');
+            res.writeHead(502, { 'content-type': 'text/plain' });
+            res.end('No sellers available on the network. Is a seeder running?');
+            return;
+        }
+        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, requestedService, explicitProvider);
+        const selectPeers = (candidateSources) => selectCandidatePeersForRouting(candidateSources, requestProtocol, requestedService, explicitProvider);
+        let hasForcedRefresh = false;
+        const refreshPeerSelection = async (reason) => {
+            if (hasForcedRefresh) {
+                return;
+            }
+            hasForcedRefresh = true;
+            log(`Forcing peer refresh before routing after ${reason}.`);
+            discoveredPeers = await this._getPeers({ forceRefresh: true });
+            ({
+                candidatePeers: routingPeers,
+                routePlanByPeerId: routingPlans,
+            } = selectPeers(discoveredPeers));
+        };
+        let { candidatePeers, routePlanByPeerId, } = selectPeers(peers);
+        let routingPeers = candidatePeers;
+        let routingPlans = routePlanByPeerId;
+        let discoveredPeers = peers;
+        if (routingPeers.length === 0) {
+            await refreshPeerSelection('empty initial routing candidate set');
+        }
+        if (routingPeers.length === 0) {
+            const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
+            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)`);
+        const router = this._node.router;
+        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
+            // this request, the cache is already fresh and cacheAgeMs will be < TTL.
+            const cacheAgeMs = Date.now() - this._cacheLastUpdatedAtMs;
+            if (cacheAgeMs > this._peerCacheTtlMs) {
+                await refreshPeerSelection(`pinned peer with stale cache (${cacheAgeMs}ms old)`);
+            }
+            let pinnedRoutingPeers = routingPeers;
+            let pinnedRoutePlans = routingPlans;
+            let selectedPeer = pinnedRoutingPeers.find((p) => p.peerId.toLowerCase() === explicitPeerId) ?? null;
+            if (!selectedPeer) {
+                await refreshPeerSelection(`pinned peer ${explicitPeerId.slice(0, 12)}... not in candidate set`);
+                pinnedRoutingPeers = routingPeers;
+                pinnedRoutePlans = routingPlans;
+                selectedPeer = pinnedRoutingPeers.find((p) => p.peerId.toLowerCase() === explicitPeerId) ?? null;
+            }
+            if (!selectedPeer) {
+                const source = serializedReq.headers['x-antseed-pin-peer'] ? 'x-antseed-pin-peer header' : '--peer flag';
+                const peerDiscovered = discoveredPeers.some((peer) => peer.peerId.toLowerCase() === explicitPeerId);
+                const protocolLabel = requestProtocol ? `protocol=${requestProtocol}` : 'protocol=unknown';
+                const providerLabel = explicitProvider ? `provider=${explicitProvider}` : 'provider=auto';
+                const serviceLabel = requestedService ? `service=${requestedService}` : 'service=none';
+                const mismatchHint = peerDiscovered
+                    ? `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' });
+                res.end(`Pinned peer ${explicitPeerId.slice(0, 12)}... is not available or does not support this request. ${mismatchHint}`);
+                return;
+            }
+            log(`Using pinned peer ${selectedPeer.peerId.slice(0, 12)}...`);
+            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
+                res.writeHead(result.statusCode, result.responseHeaders);
+                res.end(result.responseBody);
+            }
+            return;
+        }
+        // Non-pinned: retry with failover on provider errors
+        const MAX_ATTEMPTS = 3;
+        const triedPeerIds = new Set();
+        let lastStatusCode = 502;
+        let lastResponseBody = null;
+        let lastResponseHeaders = { 'content-type': 'text/plain' };
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            const availableCandidates = routingPeers.filter((peer) => !triedPeerIds.has(peer.peerId));
+            if (availableCandidates.length === 0)
+                break;
+            let selectedPeer = null;
+            // Prefer a recently successful peer for the same request route.
+            if (attempt === 0) {
+                const routePreferredPeerId = this._lastSuccessfulPeerByRouteKey.get(routeKey);
+                if (routePreferredPeerId) {
+                    const remembered = availableCandidates.find((peer) => peer.peerId === routePreferredPeerId) ?? null;
+                    if (remembered) {
+                        selectedPeer = remembered;
+                        log(`Reusing last successful route peer ${selectedPeer.peerId.slice(0, 12)}...`);
+                    }
+                }
+            }
+            // Fallback to the latest globally successful peer.
+            if (!selectedPeer && attempt === 0 && this._lastSuccessfulPeerId && !requestedService) {
+                const remembered = availableCandidates.find((peer) => peer.peerId === this._lastSuccessfulPeerId) ?? null;
+                if (remembered) {
+                    selectedPeer = remembered;
+                    log(`Reusing last successful peer ${selectedPeer.peerId.slice(0, 12)}...`);
+                }
+            }
+            // Soft peer affinity: try caller-preferred peer first, but allow normal fallback.
+            if (!selectedPeer && attempt === 0 && preferredPeerId) {
+                const preferred = availableCandidates.find((peer) => peer.peerId.toLowerCase() === preferredPeerId) ?? null;
+                if (preferred) {
+                    selectedPeer = preferred;
+                    log(`Preferring requested peer ${selectedPeer.peerId.slice(0, 12)}...`);
+                }
+            }
+            // Prefer local peers on first attempt
+            if (!selectedPeer && attempt === 0) {
+                const localPeers = availableCandidates.filter((peer) => isLoopbackPeer(peer));
+                if (localPeers.length > 0) {
+                    selectedPeer = router
+                        ? router.selectPeer(serializedReq, localPeers)
+                        : localPeers[0] ?? null;
+                    if (selectedPeer) {
+                        log(`Preferring local peer ${selectedPeer.peerId.slice(0, 12)}... @ ${selectedPeer.publicAddress ?? 'unknown'}`);
+                    }
+                }
+            }
+            // Prefer peers that can serve the request protocol directly without adapter transform.
+            if (!selectedPeer && requestProtocol === 'anthropic-messages') {
+                const shouldPreferDirect = !requestedService || /claude|anthropic/i.test(requestedService);
+                if (shouldPreferDirect) {
+                    const directPeers = availableCandidates.filter((peer) => {
+                        const plan = routingPlans.get(peer.peerId);
+                        if (!plan)
+                            return false;
+                        return !plan.selection || !plan.selection.requiresTransform;
+                    });
+                    if (directPeers.length > 0) {
+                        selectedPeer = router
+                            ? router.selectPeer(serializedReq, directPeers)
+                            : directPeers[0] ?? null;
+                        if (selectedPeer) {
+                            log(`Preferring direct protocol peer ${selectedPeer.peerId.slice(0, 12)}...`);
+                        }
+                    }
+                }
+            }
+            if (!selectedPeer) {
+                selectedPeer = router
+                    ? (router.selectPeer(serializedReq, availableCandidates) ?? availableCandidates[0] ?? null)
+                    : availableCandidates[0] ?? null;
+            }
+            if (!selectedPeer)
+                break;
+            triedPeerIds.add(selectedPeer.peerId);
+            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);
+            // Request failed with a retryable error — try another peer
+            lastStatusCode = result.statusCode;
+            lastResponseBody = result.responseBody;
+            lastResponseHeaders = result.responseHeaders;
+            if (attempt < MAX_ATTEMPTS - 1) {
+                log(`Peer ${selectedPeer.peerId.slice(0, 12)}... returned ${result.statusCode}, retrying with another peer (attempt ${attempt + 2}/${MAX_ATTEMPTS})`);
+            }
+        }
+        // All retries exhausted or no peers available
+        if (!res.headersSent) {
+            if (lastResponseBody) {
+                log(`All ${triedPeerIds.size} peer(s) failed, returning last error (${lastStatusCode})`);
+                res.writeHead(lastStatusCode, lastResponseHeaders);
+                res.end(lastResponseBody);
+            }
+            else {
+                const diagnostics = this._formatPeerSelectionDiagnostics(routingPeers);
+                log('No peers available for request');
+                res.writeHead(502, { 'content-type': 'text/plain' });
+                res.end(`Router could not select a suitable peer. ${diagnostics}`);
+            }
+        }
+    }
+    /**
+     * Dispatch a request to a specific peer. Returns `{ done: true }` if the response
+     * 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, requestedService, explicitProvider, router, retryableStatusCodes, requestSignal) {
+        const selectedRoutePlan = routePlanByPeerId.get(selectedPeer.peerId)
+            ?? 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 };
+        }
+        const { 'x-antseed-pin-peer': _pinPeer, 'x-antseed-prefer-peer': _preferPeer, ...headersForPeer } = serializedReq.headers;
+        let requestForPeer = {
+            ...serializedReq,
+            headers: {
+                ...headersForPeer,
+                'x-antseed-provider': selectedRoutePlan.provider,
+            },
+        };
+        let adaptResponse = null;
+        let streamResponseAdapter = null;
+        if (selectedRoutePlan.selection?.requiresTransform) {
+            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 };
+            }
+            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 };
+            }
+            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,
+                });
+            }
+        }
+        if (DEBUG()) {
+            log(`Outbound request shape: ${summarizeRequestShape(requestForPeer)}`);
+        }
+        log(`Routing to peer ${selectedPeer.peerId.slice(0, 12)}...`);
+        // Forward through P2P
+        const wantsStreaming = requestWantsStreaming(requestForPeer.headers, requestForPeer.body);
+        const startTime = Date.now();
+        try {
+            if (wantsStreaming) {
+                let streamed = false;
+                const response = await this._node.sendRequestStream(selectedPeer, requestForPeer, {
+                    onResponseStart: (startResponse, metadata) => {
+                        if (!metadata.streaming)
+                            return;
+                        streamed = true;
+                        const adaptedStartResponse = streamResponseAdapter
+                            ? streamResponseAdapter.adaptStart(startResponse)
+                            : startResponse;
+                        const streamingHeaders = attachStreamingAntseedHeaders(adaptedStartResponse.headers, selectedPeer, requestForPeer.requestId);
+                        // Ensure content-type is set for SSE — some upstream APIs (e.g. Codex)
+                        // omit it, which can cause the client's fetch body reader to not
+                        // detect end-of-stream properly.
+                        if (!streamingHeaders['content-type']) {
+                            streamingHeaders['content-type'] = 'text/event-stream';
+                        }
+                        res.writeHead(adaptedStartResponse.statusCode, streamingHeaders);
+                        if (adaptedStartResponse.body.length > 0) {
+                            res.write(Buffer.from(adaptedStartResponse.body));
+                        }
+                    },
+                    onResponseChunk: (chunk) => {
+                        if (!streamed)
+                            return;
+                        const adaptedChunks = streamResponseAdapter
+                            ? streamResponseAdapter.adaptChunk(chunk)
+                            : [chunk];
+                        for (const adaptedChunk of adaptedChunks) {
+                            if (adaptedChunk.data.length > 0) {
+                                res.write(Buffer.from(adaptedChunk.data));
+                            }
+                        }
+                    },
+                }, { signal: requestSignal });
+                let responseForClient = response;
+                if (!streamed && adaptResponse) {
+                    responseForClient = adaptResponse(response);
+                }
+                responseForClient = adaptOpenAICompatibleErrorResponse(responseForClient, requestProtocol);
+                if (responseForClient.statusCode === 402) {
+                    responseForClient = inject402PeerId(responseForClient, selectedPeer.peerId);
+                }
+                const latencyMs = Date.now() - startTime;
+                log(`Response: ${responseForClient.statusCode} (${latencyMs}ms, ${responseForClient.body.length} bytes)`);
+                if (responseForClient.statusCode >= 400) {
+                    const prefix = adaptResponse && !streamed ? 'Upstream adapted error detail' : 'Upstream error detail';
+                    log(`${prefix}: ${summarizeErrorResponse(responseForClient)}`);
+                }
+                const telemetry = computeResponseTelemetry(requestForPeer, responseForClient.headers, responseForClient.body, selectedPeer);
+                if (router) {
+                    router.onResult(selectedPeer, {
+                        success: !retryableStatusCodes.has(responseForClient.statusCode),
+                        latencyMs,
+                        tokens: telemetry.usage.totalTokens,
+                    });
+                }
+                if (streamed) {
+                    // Headers already sent to client, can't retry
+                    if (responseForClient.statusCode >= 200 && responseForClient.statusCode < 400) {
+                        this._rememberSuccessfulPeer(routeKey, selectedPeer.peerId);
+                    }
+                    if (!res.writableEnded) {
+                        res.end();
+                    }
+                    return { done: true };
+                }
+                // Non-streamed response — check if retryable
+                const responseHeaders = attachAntseedTelemetryHeaders(responseForClient.headers, selectedPeer, telemetry, requestForPeer.requestId, latencyMs);
+                if (retryableStatusCodes.has(responseForClient.statusCode)) {
+                    return {
+                        done: false,
+                        statusCode: responseForClient.statusCode,
+                        responseBody: Buffer.from(responseForClient.body),
+                        responseHeaders,
+                        errorMessage: null,
+                    };
+                }
+                if (responseForClient.statusCode >= 200 && responseForClient.statusCode < 400) {
+                    this._rememberSuccessfulPeer(routeKey, selectedPeer.peerId);
+                }
+                res.writeHead(responseForClient.statusCode, responseHeaders);
+                res.end(Buffer.from(responseForClient.body));
+                return { done: true };
+            }
+            else {
+                const upstreamResponse = await this._node.sendRequest(selectedPeer, requestForPeer, { signal: requestSignal });
+                if (upstreamResponse.statusCode >= 400 && !adaptResponse) {
+                    log(`Upstream raw error detail: ${summarizeErrorResponse(upstreamResponse)}`);
+                }
+                let response = upstreamResponse;
+                if (adaptResponse) {
+                    response = adaptResponse(response);
+                }
+                response = adaptOpenAICompatibleErrorResponse(response, requestProtocol);
+                if (response.statusCode === 402) {
+                    response = inject402PeerId(response, selectedPeer.peerId);
+                }
+                const latencyMs = Date.now() - startTime;
+                log(`Response: ${response.statusCode} (${latencyMs}ms, ${response.body.length} bytes)`);
+                if (response.statusCode >= 400) {
+                    const prefix = adaptResponse ? 'Upstream adapted error detail' : 'Upstream error detail';
+                    log(`${prefix}: ${summarizeErrorResponse(response)}`);
+                }
+                const telemetry = computeResponseTelemetry(requestForPeer, response.headers, response.body, selectedPeer);
+                const responseHeaders = attachAntseedTelemetryHeaders(response.headers, selectedPeer, telemetry, requestForPeer.requestId, latencyMs);
+                // Report result to router for learning
+                if (router) {
+                    router.onResult(selectedPeer, {
+                        success: !retryableStatusCodes.has(response.statusCode),
+                        latencyMs,
+                        tokens: telemetry.usage.totalTokens,
+                    });
+                }
+                // Check if retryable
+                if (retryableStatusCodes.has(response.statusCode)) {
+                    return { done: false, statusCode: response.statusCode, responseBody: Buffer.from(response.body), responseHeaders, errorMessage: null };
+                }
+                if (response.statusCode >= 200 && response.statusCode < 400) {
+                    this._rememberSuccessfulPeer(routeKey, selectedPeer.peerId);
+                }
+                // Forward response headers and body to the HTTP client
+                res.writeHead(response.statusCode, responseHeaders);
+                res.end(Buffer.from(response.body));
+                return { done: true };
+            }
+        }
+        catch (err) {
+            const latencyMs = Date.now() - startTime;
+            const message = err instanceof Error ? err.message : String(err);
+            const abortedLocally = requestSignal.aborted;
+            const connectionChurnError = isConnectionChurnError(message);
+            log(`Request failed after ${latencyMs}ms: ${message}`);
+            if (abortedLocally) {
+                log(`Request ${requestForPeer.requestId.slice(0, 8)} aborted locally; skipping retry, router penalty, and peer eviction.`);
+                if (!res.writableEnded) {
+                    let responded = false;
+                    if (!res.headersSent) {
+                        try {
+                            res.writeHead(499, { 'content-type': 'text/plain' });
+                            responded = true;
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    try {
+                        if (res.writableEnded) {
+                            // no-op
+                        }
+                        else {
+                            if (responded) {
+                                res.end('Request cancelled');
+                            }
+                            else {
+                                res.end();
+                            }
+                            responded = true;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                return { done: true };
+            }
+            if (router) {
+                router.onResult(selectedPeer, {
+                    success: false,
+                    latencyMs,
+                    tokens: 0,
+                });
+            }
+            // 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 isControlPlaneServicesRequest = normalizedPath.startsWith('/v1/models');
+            if (isControlPlaneServicesRequest) {
+                log(`Skipping peer eviction for control-plane failure on ${requestForPeer.path}`);
+            }
+            else if (connectionChurnError) {
+                const currentState = this._node.getPeerConnectionState(selectedPeer.peerId);
+                if (isConnectionHealthy(currentState)) {
+                    log(`Skipping peer eviction after connection churn: peer ${selectedPeer.peerId.slice(0, 12)}... `
+                        + `has replacement connection state=${currentState}`);
+                }
+                else {
+                    this._evictPeer(selectedPeer.peerId);
+                }
+            }
+            else {
+                // Evict only the failing peer — others remain usable.
+                this._evictPeer(selectedPeer.peerId);
+            }
+            this._forgetSuccessfulPeer(routeKey, selectedPeer.peerId);
+            if (res.headersSent) {
+                // Headers already sent (streaming), can't retry
+                if (!res.writableEnded) {
+                    res.end();
+                }
+                return { done: true };
+            }
+            return { done: false, statusCode: 502, responseBody: Buffer.from(`P2P request failed: ${message}`), responseHeaders: { 'content-type': 'text/plain' }, errorMessage: message };
+        }
+    }
+}
+//# sourceMappingURL=buyer-proxy.js.map