@antseed/cli 0.1.23 → 0.1.24

package/dist/proxy/buyer-proxy.js

@@ -1,10 +1,12 @@
 import { createServer } from 'node:http';
 import { randomUUID } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
+import { watch } from 'node:fs';
+import { readFile, writeFile, rename, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { detectRequestModelApiProtocol, inferProviderDefaultModelApiProtocols, selectTargetProtocolForRequest, transformAnthropicMessagesRequestToOpenAIChat, transformOpenAIChatResponseToAnthropicMessage, } from './model-api-adapter.js';
 const DAEMON_STATE_FILE = join(homedir(), '.antseed', 'daemon.state.json');
+const BUYER_STATE_FILE = join(homedir(), '.antseed', 'buyer.state.json');
 const DEBUG = () => ['1', 'true', 'yes', 'on'].includes((process.env['ANTSEED_DEBUG'] ?? '').trim().toLowerCase());
 function log(...args) {
     if (DEBUG())
@@ -54,11 +56,21 @@ function getPreferredPeerIdHint(request) {
     return header;
 }
 function getPeerProviderProtocols(peer, provider, requestedModel) {
+    const normalizedRequestedModel = requestedModel?.trim();
     const fromMetadata = peer.providerModelApiProtocols?.[provider]?.models;
     if (fromMetadata) {
-        if (requestedModel && fromMetadata[requestedModel]?.length) {
-            log(`Model match: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${requestedModel}" → [${fromMetadata[requestedModel].join(',')}]`);
-            return Array.from(new Set(fromMetadata[requestedModel]));
+        if (normalizedRequestedModel) {
+            const directMatchKey = Object.keys(fromMetadata).find((model) => model.toLowerCase() === normalizedRequestedModel.toLowerCase());
+            if (directMatchKey && fromMetadata[directMatchKey]?.length) {
+                log(`Model match: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${normalizedRequestedModel}" `
+                    + `→ [${fromMetadata[directMatchKey].join(',')}]`);
+                return Array.from(new Set(fromMetadata[directMatchKey]));
+            }
+            if (Object.keys(fromMetadata).length > 0) {
+                log(`Model strict-miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} model="${normalizedRequestedModel}" `
+                    + 'not in metadata; excluding from route candidates.');
+                return [];
+            }
         }
         const merged = Object.values(fromMetadata).flat();
         if (merged.length > 0) {
@@ -72,24 +84,6 @@ function getPeerProviderProtocols(peer, provider, requestedModel) {
     log(`No metadata: peer ${peer.peerId.slice(0, 8)} provider=${provider} → inferred [${inferred.join(',')}]`);
     return inferred;
 }
-function isProviderModelExplicitlyUnsupported(peer, provider, requestedModel) {
-    if (!requestedModel) {
-        return false;
-    }
-    const modelMatrix = peer.providerModelApiProtocols?.[provider]?.models;
-    if (!modelMatrix) {
-        return false;
-    }
-    const advertisedModels = Object.keys(modelMatrix);
-    if (advertisedModels.length === 0) {
-        return false;
-    }
-    if (Object.prototype.hasOwnProperty.call(modelMatrix, requestedModel)) {
-        return false;
-    }
-    log(`Model strict-miss: peer ${peer.peerId.slice(0, 8)} provider=${provider} does not advertise model="${requestedModel}"`);
-    return true;
-}
 function resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitProvider) {
     const providers = peer.providers
         .map((provider) => provider.trim().toLowerCase())
@@ -107,9 +101,6 @@ function resolvePeerRoutePlan(peer, requestProtocol, requestedModel, explicitPro
     }
     let transformedFallback = null;
     for (const provider of candidates) {
-        if (!explicitProvider && isProviderModelExplicitlyUnsupported(peer, provider, requestedModel)) {
-            continue;
-        }
         const supportedProtocols = getPeerProviderProtocols(peer, provider, requestedModel);
         const selection = selectTargetProtocolForRequest(requestProtocol, supportedProtocols);
         if (!selection) {
@@ -575,6 +566,16 @@ function requestWantsStreaming(headers, body) {
         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)
@@ -599,6 +600,38 @@ function isLoopbackPeer(peer) {
     const host = extractHostFromAddress(peer.publicAddress);
     return isLoopbackHost(host);
 }
+/**
+ * Rewrite the `model` field 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 rewriteModelInBody(body, headers, model) {
+    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['model'] = model;
+        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 };
+    }
+}
 /**
  * Local HTTP proxy that forwards requests to P2P sellers.
  *
@@ -612,9 +645,13 @@ export class BuyerProxy {
     _port;
     _bgRefreshIntervalMs;
     _peerCacheTtlMs;
-    _pinnedPeerId;
+    _pinnedPeer;
+    _pinnedModel;
+    _stateFileWatcher = null;
+    _stateWatchDebounce = null;
     _cachedPeers = [];
     _cacheLastUpdatedAtMs = 0;
+    _cacheMutationEpoch = 0;
     _peerRefreshPromise = null;
     _lastStaleCacheLogAtMs = 0;
     _bgRefreshHandle = null;
@@ -625,7 +662,8 @@ export class BuyerProxy {
         this._port = config.port;
         this._bgRefreshIntervalMs = config.backgroundRefreshIntervalMs ?? 5 * 60_000;
         this._peerCacheTtlMs = Math.max(0, config.peerCacheTtlMs ?? 30_000);
-        this._pinnedPeerId = config.pinnedPeerId?.toLowerCase();
+        this._pinnedPeer = config.pinnedPeerId?.toLowerCase() ?? null;
+        this._pinnedModel = config.pinnedModel?.trim() ?? null;
         this._server = createServer((req, res) => {
             this._handleRequest(req, res).catch((err) => {
                 log('Unhandled error:', err);
@@ -645,16 +683,96 @@ export class BuyerProxy {
             });
         });
         this._startBackgroundRefresh();
+        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 pinnedModel = typeof parsed.pinnedModel === 'string' && parsed.pinnedModel.trim().length > 0
+                ? parsed.pinnedModel.trim()
+                : null;
+            const pinnedPeer = typeof parsed.pinnedPeerId === 'string' && parsed.pinnedPeerId.trim().length > 0
+                ? parsed.pinnedPeerId.trim().toLowerCase()
+                : null;
+            this._pinnedModel = pinnedModel;
+            this._pinnedPeer = pinnedPeer;
+            log(`Session overrides reloaded: model=${pinnedModel ?? 'none'} peer=${pinnedPeer ?? 'none'}`);
+        }
+        catch {
+            // state file unreadable; keep current values
+        }
+    }
+    async _writeStateFile(state) {
+        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
+            }
+            // When stopping, preserve whatever pinnedModel/pinnedPeerId is already
+            // in the file — the debounce may have been cancelled before
+            // _reloadSessionOverrides could commit the latest CLI-written values.
+            const sessionOverrides = state === 'connected'
+                ? { pinnedModel: this._pinnedModel, pinnedPeerId: this._pinnedPeer }
+                : {};
+            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
+        }
+    }
     _startBackgroundRefresh() {
         this._bgRefreshHandle = setInterval(() => {
             void this._refreshPeersNow().catch(() => {
@@ -665,12 +783,14 @@ export class BuyerProxy {
     _replacePeers(incoming) {
         this._cachedPeers = incoming;
         this._cacheLastUpdatedAtMs = Date.now();
+        this._cacheMutationEpoch += 1;
     }
     _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;
             log(`Evicted failing peer ${peerId.slice(0, 12)}... from cache (${this._cachedPeers.length} remaining)`);
         }
     }
@@ -692,7 +812,11 @@ export class BuyerProxy {
             this._lastSuccessfulPeerByRouteKey.delete(routeKey);
         }
         if (this._lastSuccessfulPeerId === peerId) {
-            this._lastSuccessfulPeerId = null;
+            const stillUsedByOtherRoute = Array.from(this._lastSuccessfulPeerByRouteKey.values())
+                .some((rememberedPeerId) => rememberedPeerId === peerId);
+            if (!stillUsedByOtherRoute) {
+                this._lastSuccessfulPeerId = null;
+            }
         }
     }
     _buildRouteKey(path, requestProtocol, requestedModel, explicitProvider) {
@@ -754,16 +878,14 @@ export class BuyerProxy {
             return null;
         }
     }
-    async _discoverAndCachePeers() {
+    async _discoverPeersFromNetwork() {
         const localSeeder = await this._readLocalSeederFallback();
         if (localSeeder) {
-            this._replacePeers([localSeeder]);
             log(`Using local seeder ${localSeeder.peerId.slice(0, 12)}... @ ${localSeeder.publicAddress} (skipping DHT lookup)`);
-            return this._cachedPeers;
+            return [localSeeder];
         }
         log('Discovering peers via DHT...');
         const peers = await this._node.discoverPeers();
-        this._replacePeers(peers);
         if (peers.length > 0) {
             log(`Found ${peers.length} peer(s)`);
         }
@@ -773,14 +895,22 @@ export class BuyerProxy {
         if (this._peerRefreshPromise) {
             return this._peerRefreshPromise;
         }
-        const previousCachedPeers = this._cachedPeers;
+        const previousCachedPeers = [...this._cachedPeers];
+        const mutationEpochAtStart = this._cacheMutationEpoch;
         this._peerRefreshPromise = (async () => {
-            const peers = await this._discoverAndCachePeers();
-            if (peers.length === 0 && previousCachedPeers.length > 0) {
+            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; keeping previous cached peers as fallback.');
-                this._replacePeers(previousCachedPeers);
-                return previousCachedPeers;
+                log('Discovery returned 0 peers; preserving most-recent cached peers as fallback.');
+                this._replacePeers(fallbackPeers);
+                return fallbackPeers;
             }
             return peers;
         })().finally(() => {
@@ -851,13 +981,24 @@ export class BuyerProxy {
         }
         // Remove host header (points to localhost, not the seller)
         delete headers['host'];
-        const serializedReq = {
+        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 model/peer mismatch mid-request.
+        const effectivePinnedModel = this._pinnedModel;
+        const effectivePinnedPeer = this._pinnedPeer;
+        if (effectivePinnedModel) {
+            const { body: rewrittenBody, headers: rewrittenHeaders } = rewriteModelInBody(serializedReq.body, serializedReq.headers, effectivePinnedModel);
+            if (rewrittenBody !== serializedReq.body) {
+                serializedReq = { ...serializedReq, body: rewrittenBody, headers: rewrittenHeaders };
+                log(`Model override applied: ${effectivePinnedModel}`);
+            }
+        }
         const clientAbortController = new AbortController();
         const onClientAbort = () => {
             if (clientAbortController.signal.aborted) {
@@ -866,7 +1007,11 @@ export class BuyerProxy {
             clientAbortController.abort();
             log(`Client disconnected; aborting upstream request reqId=${serializedReq.requestId.slice(0, 8)}`);
         };
-        req.once('aborted', onClientAbort);
+        req.once('close', () => {
+            if (!req.complete && !res.writableEnded) {
+                onClientAbort();
+            }
+        });
         res.once('close', () => {
             if (!res.writableEnded) {
                 onClientAbort();
@@ -884,20 +1029,30 @@ export class BuyerProxy {
         const requestedModel = extractRequestedModel(serializedReq);
         log(`Routing: protocol=${requestProtocol ?? 'null'} model=${requestedModel ?? 'null'}`);
         const explicitProvider = getExplicitProviderOverride(serializedReq);
-        const explicitPeerId = getExplicitPeerIdOverride(serializedReq, this._pinnedPeerId);
+        const explicitPeerId = getExplicitPeerIdOverride(serializedReq, effectivePinnedPeer ?? undefined);
         const preferredPeerId = getPreferredPeerIdHint(serializedReq);
         log(`Routing hints: provider=${explicitProvider ?? 'auto'} pin-peer=${explicitPeerId ?? 'none'} prefer-peer=${preferredPeerId ?? 'none'}`);
         const routeKey = this._buildRouteKey(serializedReq.path, requestProtocol, requestedModel, explicitProvider);
-        const { candidatePeers, routePlanByPeerId, } = selectCandidatePeersForRouting(peers, requestProtocol, requestedModel, explicitProvider);
+        const selectPeers = (candidateSources) => selectCandidatePeersForRouting(candidateSources, requestProtocol, requestedModel, 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) {
-            // One forced refresh handles stale-cache routing mismatches (e.g. missing provider/model updates).
-            discoveredPeers = await this._getPeers({ forceRefresh: true });
-            const refreshedSelection = selectCandidatePeersForRouting(discoveredPeers, requestProtocol, requestedModel, explicitProvider);
-            routingPeers = refreshedSelection.candidatePeers;
-            routingPlans = refreshedSelection.routePlanByPeerId;
+            await refreshPeerSelection('empty initial routing candidate set');
         }
         if (routingPeers.length === 0) {
             const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
@@ -912,6 +1067,28 @@ export class BuyerProxy {
             }
             return;
         }
+        const preferredProviders = explicitProvider
+            ? []
+            : inferPreferredProvidersForRequest(requestProtocol, requestedModel);
+        let hasPreferredProviderCandidate = preferredProviders.length > 0
+            && routingPeers.some((peer) => {
+                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
+                return Boolean(provider && preferredProviders.includes(provider));
+            });
+        if (preferredProviders.length > 0 && !hasPreferredProviderCandidate) {
+            await refreshPeerSelection(`missing preferred providers [${preferredProviders.join(',')}]`);
+            hasPreferredProviderCandidate = routingPeers.some((peer) => {
+                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
+                return Boolean(provider && preferredProviders.includes(provider));
+            });
+        }
+        if (routingPeers.length === 0) {
+            const diagnostics = this._formatPeerSelectionDiagnostics(discoveredPeers);
+            res.writeHead(502, { 'content-type': 'text/plain' });
+            const providerLabel = explicitProvider ? ` for provider "${explicitProvider}"` : '';
+            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;
@@ -921,11 +1098,9 @@ export class BuyerProxy {
             let pinnedRoutePlans = routingPlans;
             let selectedPeer = pinnedRoutingPeers.find((p) => p.peerId.toLowerCase() === explicitPeerId) ?? null;
             if (!selectedPeer) {
-                log(`Pinned peer ${explicitPeerId.slice(0, 12)}... not in current candidate set; forcing refresh.`);
-                discoveredPeers = await this._getPeers({ forceRefresh: true });
-                const refreshedSelection = selectCandidatePeersForRouting(discoveredPeers, requestProtocol, requestedModel, explicitProvider);
-                pinnedRoutingPeers = refreshedSelection.candidatePeers;
-                pinnedRoutePlans = refreshedSelection.routePlanByPeerId;
+                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) {
@@ -955,27 +1130,23 @@ export class BuyerProxy {
         // Non-pinned: retry with failover on provider errors
         const MAX_ATTEMPTS = 3;
         const triedPeerIds = new Set();
-        const preferredProviders = explicitProvider
-            ? []
-            : inferPreferredProvidersForRequest(requestProtocol, requestedModel);
-        const hasPreferredProviderCandidate = preferredProviders.length > 0
-            && routingPeers.some((peer) => {
-                const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
-                return Boolean(provider && preferredProviders.includes(provider));
-            });
         const restrictFailoverToPreferredProviders = preferredProviders.length > 0 && hasPreferredProviderCandidate;
         if (restrictFailoverToPreferredProviders) {
-            log(`Provider-family failover lock active: [${preferredProviders.join(',')}]`);
+            log(`Provider-family preference active (attempt 1): [${preferredProviders.join(',')}]`);
         }
         let lastStatusCode = 502;
         let lastResponseBody = null;
         let lastResponseHeaders = { 'content-type': 'text/plain' };
         for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            const limitToPreferredProviders = restrictFailoverToPreferredProviders && attempt === 0;
+            if (restrictFailoverToPreferredProviders && attempt === 1) {
+                log('Preferred provider attempt failed; expanding failover to all compatible providers.');
+            }
             const availableCandidates = routingPeers.filter((peer) => {
                 if (triedPeerIds.has(peer.peerId)) {
                     return false;
                 }
-                if (!restrictFailoverToPreferredProviders) {
+                if (!limitToPreferredProviders) {
                     return true;
                 }
                 const provider = routingPlans.get(peer.peerId)?.provider?.trim().toLowerCase();
@@ -1144,7 +1315,9 @@ export class BuyerProxy {
                 return { done: true };
             }
         }
-        log(`Outbound request shape: ${summarizeRequestShape(requestForPeer)}`);
+        if (DEBUG()) {
+            log(`Outbound request shape: ${summarizeRequestShape(requestForPeer)}`);
+        }
         log(`Routing to peer ${selectedPeer.peerId.slice(0, 12)}...`);
         // Forward through P2P
         const wantsStreaming = !forceDisableUpstreamStreaming
@@ -1159,12 +1332,7 @@ export class BuyerProxy {
                             return;
                         streamed = true;
                         const streamingHeaders = attachStreamingAntseedHeaders(startResponse.headers, selectedPeer, requestForPeer.requestId);
-                        // Ensure SSE-friendly headers so intermediaries don't buffer
-                        /* streamingHeaders['cache-control'] = 'no-cache, no-transform'
-                        streamingHeaders['x-accel-buffering'] = 'no' */
                         res.writeHead(startResponse.statusCode, streamingHeaders);
-                        // Disable Nagle's algorithm on the underlying socket for low-latency streaming
-                        // res.socket?.setNoDelay(true)
                         if (startResponse.body.length > 0) {
                             res.write(Buffer.from(startResponse.body));
                         }
@@ -1214,7 +1382,7 @@ export class BuyerProxy {
             }
             else {
                 const upstreamResponse = await this._node.sendRequest(selectedPeer, requestForPeer, { signal: requestSignal });
-                if (upstreamResponse.statusCode >= 400) {
+                if (upstreamResponse.statusCode >= 400 && !adaptResponse) {
                     log(`Upstream raw error detail: ${summarizeErrorResponse(upstreamResponse)}`);
                 }
                 let response = upstreamResponse;
@@ -1224,7 +1392,8 @@ export class BuyerProxy {
                 const latencyMs = Date.now() - startTime;
                 log(`Response: ${response.statusCode} (${latencyMs}ms, ${response.body.length} bytes)`);
                 if (response.statusCode >= 400) {
-                    log(`Upstream error detail: ${summarizeErrorResponse(response)}`);
+                    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);
@@ -1252,15 +1421,39 @@ export class BuyerProxy {
         catch (err) {
             const latencyMs = Date.now() - startTime;
             const message = err instanceof Error ? err.message : String(err);
-            const abortedLocally = requestSignal.aborted || /\baborted\b/i.test(message);
+            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.headersSent) {
-                    if (!res.writableEnded) {
-                        res.end();
+                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 };
                 }
                 return { done: true };
             }
@@ -1278,6 +1471,16 @@ export class BuyerProxy {
             if (isControlPlaneModelsRequest) {
                 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);