github-router 0.3.263 → 0.3.270

package/dist/{server-setup-BM9Smfek.js → server-setup-BmyWS4WU.js}

@@ -1,15 +1,15 @@
-import { A as searchWeb, B as readIteratorWithTimeout, Dt as toolbeltPathOverride, F as isAdvisorRequested, H as handleMcpDelete, I as buildAnthropicErrorEvent, It as withOneMSuffix, L as buildOpenAIErrorEvent, Lt as withInstallLock, M as ADVISOR_TOOL_INSTRUCTIONS, Mt as UPSTREAM_FETCH_TIMEOUT_MS, N as buildAdvisorStream, Nt as UPSTREAM_INACTIVITY_TIMEOUT_MS, P as injectAdvisorTool, Pt as generateRandomPort, R as isControllerClosedError, U as handleMcpPost, V as relayAnthropicStream, W as agentToolsEnabled, at as countTokens, ct as assembleResponsesPayload, dt as createResponses, ft as createChatCompletions, ht as parseJsonOrDiagnose, it as shimDefaultsToXhigh, j as ADVISOR_INTERNAL_TOOL_NAME, lt as resolveMcpToolTimeoutMs, mt as readResponseBodyCapped, ot as createMessages, pt as MAX_RESPONSE_BODY_BYTES, r as assertMcpToolSurfaceConsistent, st as getTokenCount, ut as pickEndpoint, w as toolbeltEnabled, z as logStreamError } from "./peer-mcp-personas-B22ncnbQ.js";
+import { A as searchWeb, B as readIteratorWithTimeout, Dt as toolbeltPathOverride, F as isAdvisorRequested, H as handleMcpDelete, I as buildAnthropicErrorEvent, It as withOneMSuffix, L as buildOpenAIErrorEvent, Lt as withInstallLock, M as ADVISOR_TOOL_INSTRUCTIONS, Mt as UPSTREAM_FETCH_TIMEOUT_MS, N as buildAdvisorStream, Nt as UPSTREAM_INACTIVITY_TIMEOUT_MS, P as injectAdvisorTool, Pt as generateRandomPort, R as isControllerClosedError, U as handleMcpPost, V as relayAnthropicStream, W as agentToolsEnabled, at as countTokens, ct as assembleResponsesPayload, dt as createResponses, ft as createChatCompletions, ht as parseJsonOrDiagnose, it as shimDefaultsToXhigh, j as ADVISOR_INTERNAL_TOOL_NAME, lt as resolveMcpToolTimeoutMs, mt as readResponseBodyCapped, ot as createMessages, pt as MAX_RESPONSE_BODY_BYTES, r as assertMcpToolSurfaceConsistent, st as getTokenCount, ut as pickEndpoint, w as toolbeltEnabled, z as logStreamError } from "./peer-mcp-personas-pWP3Eyt7.js";
 import { t as getPackageVersion } from "./version-_Q1WpsQp.js";
-import { i as ensurePaths, t as PATHS } from "./paths-BXrbboAS.js";
-import { C as copilotHeaders, O as state, S as copilotBaseUrl, a as cacheCopilotVersion, c as filterBetaHeader, d as resolveModel, f as sleep, g as fetchWithTransientRetry, i as tryRefreshAndRetry, l as isNullish, n as setupGitHubAgentToken, o as cacheModels, r as setupGitHubToken, s as cacheVSCodeVersion, t as setupCopilotToken, v as HTTPError, y as forwardError } from "./token-C8Uh7aUe.js";
-import { t as getCopilotUsage } from "./get-copilot-usage-DOFJWJaQ.js";
-import { a as resolveExecutable, n as killManagedTree, o as runCommandCapture, r as parseBoolEnv, s as runCommandVoid } from "./exec-DTO2oin0.js";
+import { i as ensurePaths, t as PATHS } from "./paths-Bg1_DWhi.js";
+import { A as state, T as copilotHeaders, _ as forwardError, a as cacheCopilotVersion, c as filterBetaHeader, d as resolveModel, f as sleep, g as HTTPError, i as tryRefreshAndRetry, l as isNullish, n as setupGitHubAgentToken, o as cacheModels, r as setupGitHubToken, s as cacheVSCodeVersion, t as setupCopilotToken, w as copilotBaseUrl, y as fetchWithTransientRetry } from "./token-iaSGp76k.js";
+import { t as getCopilotUsage } from "./get-copilot-usage-Ds09xSmH.js";
+import { a as resolveExecutable, n as killManagedTree, o as runCommandCapture, r as parseBoolEnv, s as runCommandVoid } from "./exec-y8C_MU8A.js";
 import consola from "consola";
 import * as fs$2 from "node:fs";
 import fs, { existsSync } from "node:fs";
 import * as nodePath from "node:path";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
 import process$1 from "node:process";
@@ -357,9 +357,12 @@ async function runSelfUpdate(opts) {
 //#region src/lib/file-log-reporter.ts
 const MAX_LOG_BYTES = 1048576;
 const DEDUP_MAX = 1e3;
+const DEDUP_WINDOW_MS = 3e5;
 const ARG_MAX_LEN = 2048;
-const DEDUP_KEY_MAX_LEN = 200;
+const ERROR_CAUSE_MAX_DEPTH = 4;
+const ERROR_FIELD_MAX_LEN = 512;
 const CREDENTIAL_RE = /\b(eyJ[A-Za-z0-9_-]{20,}(?:\.[A-Za-z0-9_-]+){0,2}|gh[opsu]_[A-Za-z0-9_]{20,}|Bearer\s+\S{20,})\b/g;
+const ERROR_BODY_RE = /\b(request\s+body|body)\s*[:=]\s*.*$/i;
 const ALLOWED_TYPES = /* @__PURE__ */ new Set([
 	"fatal",
 	"error",
@@ -368,25 +371,87 @@ const ALLOWED_TYPES = /* @__PURE__ */ new Set([
 function sanitize(line) {
 	return line.replace(CREDENTIAL_RE, "[REDACTED]");
 }
+function errorProperty(error, key) {
+	if (typeof error !== "object" && typeof error !== "function" || error === null) return;
+	try {
+		const value = error[key];
+		return typeof value === "string" ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function errorCause(error) {
+	if (typeof error !== "object" && typeof error !== "function" || error === null) return;
+	try {
+		return error.cause;
+	} catch {
+		return;
+	}
+}
+function safeString(value) {
+	try {
+		return String(value);
+	} catch {
+		return "[unserializable]";
+	}
+}
+function boundErrorField(value) {
+	return value.length > ERROR_FIELD_MAX_LEN ? `${value.slice(0, ERROR_FIELD_MAX_LEN)}…` : value;
+}
+function sanitizeErrorMessage(value) {
+	return sanitize(value).replace(ERROR_BODY_RE, "$1=[REDACTED]");
+}
+function serializeError(error) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	for (let depth = 0; current !== void 0 && depth <= ERROR_CAUSE_MAX_DEPTH; depth++) {
+		if ((typeof current === "object" || typeof current === "function") && current !== null) {
+			if (seen.has(current)) {
+				chain.push("[circular cause]");
+				break;
+			}
+			seen.add(current);
+		}
+		const name = boundErrorField(errorProperty(current, "name") ?? "Error");
+		const message = boundErrorField(sanitizeErrorMessage(errorProperty(current, "message") ?? (typeof current === "string" ? current : safeString(current))));
+		const rawCode = errorProperty(current, "code");
+		const code = rawCode ? boundErrorField(rawCode) : void 0;
+		chain.push(`${name}: ${message}${code ? ` code=${code}` : ""}`);
+		const cause = errorCause(current);
+		if (cause === void 0) break;
+		if (depth === ERROR_CAUSE_MAX_DEPTH) {
+			chain.push("[cause chain truncated]");
+			break;
+		}
+		current = cause;
+	}
+	return chain.join(" <- cause: ");
+}
 function serializeArg(arg) {
 	if (typeof arg === "string") return arg;
-	if (arg instanceof Error) {
-		const parts = [arg.message];
-		if (arg.stack) parts.push(arg.stack);
-		return parts.join("\n");
-	}
-	return String(arg);
+	if (arg instanceof Error) return serializeError(arg);
+	return safeString(arg);
+}
+function serializeArgs(logObj) {
+	return logObj.args.map((arg) => {
+		const serialized = sanitize(serializeArg(arg));
+		return serialized.length > ARG_MAX_LEN ? `${serialized.slice(0, ARG_MAX_LEN)}…` : serialized;
+	});
 }
-function formatLogLine(logObj) {
-	return sanitize(`${logObj.date.toISOString()} [${(logObj.type ?? "error").toUpperCase()}] ${logObj.args.map((a) => {
-		const s = serializeArg(a);
-		return s.length > ARG_MAX_LEN ? s.slice(0, ARG_MAX_LEN) + "…" : s;
-	}).join(" ").replace(/\r\n|\r|\n/g, "\\n")}\n`);
+function formatLogLine(logObj, suppressed = 0) {
+	return `${logObj.date.toISOString()} [${(logObj.type ?? "error").toUpperCase()}] ${serializeArgs(logObj).join(" ").replace(/\r\n|\r|\n/g, "\\n")}${suppressed > 0 ? ` [${suppressed} identical occurrences suppressed]` : ""}\n`;
 }
 function makeDedupeKey(logObj) {
-	const firstArg = logObj.args.length > 0 ? serializeArg(logObj.args[0]) : "";
-	const key = `${logObj.type}:${firstArg}`;
-	return key.length > DEDUP_KEY_MAX_LEN ? key.slice(0, DEDUP_KEY_MAX_LEN) : key;
+	const hash = createHash("sha256");
+	hash.update(logObj.type);
+	for (const arg of serializeArgs(logObj)) {
+		hash.update("\0");
+		hash.update(String(arg.length));
+		hash.update(":");
+		hash.update(arg);
+	}
+	return hash.digest("base64url");
 }
 /**
 * Construction-time rotation: rename the log aside if it's already over the
@@ -408,7 +473,7 @@ function rotateAtStartup(filePath) {
 }
 var FileLogReporter = class FileLogReporter {
 	filePath;
-	seen = /* @__PURE__ */ new Set();
+	seen = /* @__PURE__ */ new Map();
 	bytesSinceCheck = 0;
 	static ROTATE_CHECK_BYTES = MAX_LOG_BYTES / 2;
 	fd;
@@ -466,10 +531,25 @@ var FileLogReporter = class FileLogReporter {
 	log(logObj, _ctx) {
 		if (!ALLOWED_TYPES.has(logObj.type)) return;
 		const key = makeDedupeKey(logObj);
-		if (this.seen.has(key)) return;
-		if (this.seen.size >= DEDUP_MAX) this.seen.clear();
-		this.seen.add(key);
-		const line = formatLogLine(logObj);
+		const timestamp = logObj.date.getTime();
+		const previous = this.seen.get(key);
+		let suppressed = 0;
+		if (previous) {
+			if (timestamp - previous.lastWrittenAt < DEDUP_WINDOW_MS) {
+				previous.suppressed++;
+				return;
+			}
+			suppressed = previous.suppressed;
+			previous.lastWrittenAt = timestamp;
+			previous.suppressed = 0;
+		} else {
+			if (this.seen.size >= DEDUP_MAX) this.seen.clear();
+			this.seen.set(key, {
+				lastWrittenAt: timestamp,
+				suppressed: 0
+			});
+		}
+		const line = formatLogLine(logObj, suppressed);
 		this.bytesSinceCheck += line.length;
 		if (this.bytesSinceCheck >= FileLogReporter.ROTATE_CHECK_BYTES) {
 			this.rotateIfNeeded();
@@ -1045,60 +1125,6 @@ function initProxyFromEnv() {
 	}
 }
 //#endregion
-//#region package.json
-var name = "github-router";
-var version = "0.3.263";
-//#endregion
-//#region src/lib/approval.ts
-const awaitApproval = async () => {
-	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected by user", Response.json({ message: "Request rejected by user" }, { status: 403 }));
-};
-//#endregion
-//#region src/lib/rate-limit.ts
-const RATE_LIMIT_QUEUE_TIMEOUT_MS = 5e3;
-let rateLimitChain = Promise.resolve();
-async function checkRateLimit(state) {
-	if (state.rateLimitSeconds === void 0) return;
-	const ticket = { aborted: false };
-	const myTurn = rateLimitChain.then(() => doCheck(state, ticket));
-	rateLimitChain = myTurn.catch(() => {});
-	return Promise.race([myTurn, sleep(RATE_LIMIT_QUEUE_TIMEOUT_MS).then(() => {
-		ticket.aborted = true;
-		throw new HTTPError("Rate limit queue wait exceeded", Response.json({
-			type: "error",
-			error: {
-				type: "rate_limit_error",
-				message: `Rate limit queue exceeded ${RATE_LIMIT_QUEUE_TIMEOUT_MS}ms; try again`
-			}
-		}, { status: 429 }));
-	})]);
-}
-async function doCheck(state, ticket) {
-	if (state.rateLimitSeconds === void 0) return;
-	if (ticket.aborted) return;
-	const now = Date.now();
-	if (!state.lastRequestTimestamp) {
-		state.lastRequestTimestamp = now;
-		return;
-	}
-	const elapsedSeconds = (now - state.lastRequestTimestamp) / 1e3;
-	if (elapsedSeconds > state.rateLimitSeconds) {
-		state.lastRequestTimestamp = now;
-		return;
-	}
-	const waitTimeSeconds = Math.ceil(state.rateLimitSeconds - elapsedSeconds);
-	if (!state.rateLimitWait) {
-		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
-		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
-	}
-	const waitTimeMs = waitTimeSeconds * 1e3;
-	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
-	await sleep(waitTimeMs);
-	if (ticket.aborted) return;
-	state.lastRequestTimestamp = Date.now();
-	consola.info("Rate limit wait completed, proceeding with request");
-}
-//#endregion
 //#region src/lib/request-log.ts
 /**
 * Rolling request-body size distribution.
@@ -1122,6 +1148,79 @@ function recordBodySize(bytes) {
 	bodySizeIdx = (bodySizeIdx + 1) % BODY_SIZE_RING;
 	if (bodySizeCount < BODY_SIZE_RING) bodySizeCount++;
 }
+/** Percentile snapshot of observed body sizes, or undefined if none seen. */
+function bodySizeStats() {
+	if (bodySizeCount === 0) return void 0;
+	const s = Array.from(bodySizes.slice(0, bodySizeCount)).sort((a, b) => a - b);
+	const at = (q) => s[Math.min(s.length - 1, Math.floor(s.length * q))];
+	return {
+		count: bodySizeCount,
+		p50: at(.5),
+		p95: at(.95),
+		p99: at(.99),
+		max: s[s.length - 1]
+	};
+}
+/**
+* Print the observed body-size distribution, if any requests were seen.
+*
+* Without this the ring was WRITE-ONLY: `bodySizeStats()` had no caller
+* anywhere in `src/`, so the one number its own doc comment says the decision
+* needs ("benchmarks at 4.5 MiB mean nothing if the real p50 is 40 KiB") was
+* collected every request and readable by nobody.
+*
+* At `consola.info` because it is a once-per-session line answering a question
+* an operator or contributor actually asks; anything noisier would be a reason
+* to switch it off.
+*/
+function logBodySizeStats() {
+	const stats = bodySizeStats();
+	if (!stats) return void 0;
+	const line = `request body sizes (n=${stats.count}): p50 ${formatBytes(stats.p50)}, p95 ${formatBytes(stats.p95)}, p99 ${formatBytes(stats.p99)}, max ${formatBytes(stats.max)}`;
+	consola.info(line);
+	return line;
+}
+/**
+* Report the distribution once, on the way out.
+*
+* Self-registered rather than wired into each subcommand's shutdown chain
+* because `start` has NO `launchChild`/`onShutdown` to hang it on (see the
+* comment at its `startKeepAwake()` call), and a stat that only appeared under
+* `claude` would answer the question for one of three entry points. Same
+* pattern, and same reasoning, as `~/lib/keep-awake`'s own reaper.
+*
+* **Windows caveat, measured rather than assumed.** This reports on a clean
+* exit and on a signal the runtime actually delivers to JS (Ctrl-C in an
+* interactive console). It does NOT report when the process is killed by
+* another process on Windows: `child.kill(...)` and `taskkill` terminate
+* abruptly via `TerminateProcess`, dispatching no JS signal event, so NO
+* handler runs — not this one, and not `process.on("exit")` either. Verified
+* on a real win32 host: a child registering both handlers and killed by its
+* parent produced no output and exited with a null code.
+*
+* That is acceptable for a diagnostic — it is a measurement aid, not a
+* durability guarantee, and the interactive case it exists to serve (run a
+* session, Ctrl-C, read the distribution) does work. It is NOT acceptable for
+* anything durable: do not move credential, ledger, or cleanup work onto this
+* hook. The existing teardown paths that must survive a hard kill are built
+* differently on purpose (see `~/lib/keep-awake`, which relies on the OS
+* releasing a thread-scoped assertion rather than on a handler running, and
+* `~/lib/process-guard`, which uses a separate reaper process).
+*
+* Idempotent: `exit` can follow a signal handler, and both call this.
+*/
+let statsReported = false;
+function reportOnce() {
+	if (statsReported) return;
+	statsReported = true;
+	logBodySizeStats();
+}
+let exitHooksInstalled = false;
+function installBodySizeStatsExitHook() {
+	if (exitHooksInstalled) return;
+	exitHooksInstalled = true;
+	process.once("exit", reportOnce);
+}
 /** Format a byte count compactly (1.2M / 15.3K / 900B). */
 function formatBytes(n) {
 	if (n >= 1048576) return `${(n / 1048576).toFixed(1)}M`;
@@ -1256,6 +1355,60 @@ function collectToolFieldKeys(body) {
 	return [...seen].sort();
 }
 //#endregion
+//#region package.json
+var name = "github-router";
+var version = "0.3.270";
+//#endregion
+//#region src/lib/approval.ts
+const awaitApproval = async () => {
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected by user", Response.json({ message: "Request rejected by user" }, { status: 403 }));
+};
+//#endregion
+//#region src/lib/rate-limit.ts
+const RATE_LIMIT_QUEUE_TIMEOUT_MS = 5e3;
+let rateLimitChain = Promise.resolve();
+async function checkRateLimit(state) {
+	if (state.rateLimitSeconds === void 0) return;
+	const ticket = { aborted: false };
+	const myTurn = rateLimitChain.then(() => doCheck(state, ticket));
+	rateLimitChain = myTurn.catch(() => {});
+	return Promise.race([myTurn, sleep(RATE_LIMIT_QUEUE_TIMEOUT_MS).then(() => {
+		ticket.aborted = true;
+		throw new HTTPError("Rate limit queue wait exceeded", Response.json({
+			type: "error",
+			error: {
+				type: "rate_limit_error",
+				message: `Rate limit queue exceeded ${RATE_LIMIT_QUEUE_TIMEOUT_MS}ms; try again`
+			}
+		}, { status: 429 }));
+	})]);
+}
+async function doCheck(state, ticket) {
+	if (state.rateLimitSeconds === void 0) return;
+	if (ticket.aborted) return;
+	const now = Date.now();
+	if (!state.lastRequestTimestamp) {
+		state.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsedSeconds = (now - state.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state.rateLimitSeconds) {
+		state.lastRequestTimestamp = now;
+		return;
+	}
+	const waitTimeSeconds = Math.ceil(state.rateLimitSeconds - elapsedSeconds);
+	if (!state.rateLimitWait) {
+		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
+		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
+	}
+	const waitTimeMs = waitTimeSeconds * 1e3;
+	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
+	await sleep(waitTimeMs);
+	if (ticket.aborted) return;
+	state.lastRequestTimestamp = Date.now();
+	consola.info("Rate limit wait completed, proceeding with request");
+}
+//#endregion
 //#region src/routes/chat-completions/handler.ts
 const ENCODER$1 = new TextEncoder();
 function formatSSE$1(chunk) {
@@ -1552,12 +1705,21 @@ mcpRoutes.delete("/:group", (c) => {
 * any other input shape, fall back to a synthesized `toolu_advisor_N`
 * id.
 */
-function toCopilotToolUseId(srvId, fallbackIndex) {
+function toCopilotToolUseId(srvId) {
 	if (srvId.startsWith("srvtoolu_")) {
 		const suffix = srvId.slice(9);
 		if (/^[a-zA-Z0-9_]+$/.test(suffix)) return `toolu_${suffix}`;
 	}
-	return `toolu_advisor_${fallbackIndex}`;
+	if (/^toolu_[a-zA-Z0-9_]+$/.test(srvId)) return srvId;
+}
+function invalidAdvisorHistory(message) {
+	throw new HTTPError("Invalid advisor history", Response.json({
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			message: `Invalid advisor history: ${message}`
+		}
+	}, { status: 400 }));
 }
 /**
 * Fast-path detector: returns true if the raw body has any chance of
@@ -1572,85 +1734,148 @@ function bodyMightNeedSanitize(rawBody) {
 	return rawBody.includes("\"server_tool_use\"") || rawBody.includes("\"advisor_tool_result\"") || /"type":"advisor_\d+"/.test(rawBody);
 }
 /**
-* Translate one assistant turn's content array, splitting at advisor
-* pairs into the multi-message structure Copilot accepts.
-*
-* Input shape (Claude Code stores everything in one assistant turn):
-*   [text*, server_tool_use{advisor}, advisor_tool_result, text*, ...]
-*
-* Output: array of {role, content[]} message objects, alternating
-* assistant→user→assistant for each advisor pair encountered.
+* Translate one client-visible assistant turn into the internal messages
+* Copilot originally saw. Parallel advisor calls are replayed as one assistant
+* turn followed by one user turn containing every matching result. Sequential
+* advisor groups remain separate assistant/user pairs. When a client tool and
+* advisor coexist, the advisor results and the client's following tool results
+* are merged into the one immediate user message required by Anthropic.
 */
-function splitAssistantTurnAtAdvisorPairs(originalContent, syntheticIndexRef) {
+function splitAssistantTurnAtAdvisorPairs(originalMessage, originalContent, followingMessage) {
 	const messages = [];
 	let currentAssistantContent = [];
 	let translated = false;
+	let emittedFirstAssistant = false;
+	const pushAssistant = () => {
+		if (currentAssistantContent.length === 0) invalidAdvisorHistory("advisor pair has no assistant content");
+		messages.push(emittedFirstAssistant ? {
+			role: "assistant",
+			content: currentAssistantContent
+		} : {
+			...originalMessage,
+			content: currentAssistantContent
+		});
+		emittedFirstAssistant = true;
+	};
 	let i = 0;
 	while (i < originalContent.length) {
 		const block = originalContent[i];
 		const b = typeof block === "object" && block !== null ? block : null;
-		if (b && b.type === "server_tool_use" && b.name === "__anthropic_advisor".replace(/^__anthropic_/, "")) {
-			const stuId = typeof b.id === "string" ? b.id : "";
-			const nextBlock = originalContent[i + 1];
-			const next = typeof nextBlock === "object" && nextBlock !== null ? nextBlock : null;
-			const copilotId = stuId.startsWith("srvtoolu_") ? toCopilotToolUseId(stuId, syntheticIndexRef.value++) : stuId.startsWith("toolu_") && /^toolu_[a-zA-Z0-9_]+$/.test(stuId) ? stuId : `toolu_advisor_${syntheticIndexRef.value++}`;
-			currentAssistantContent.push({
-				type: "tool_use",
-				id: copilotId,
-				name: ADVISOR_INTERNAL_TOOL_NAME,
-				input: {}
-			});
-			messages.push({
-				role: "assistant",
-				content: currentAssistantContent
-			});
+		if (b?.type === "server_tool_use" && b.name === "__anthropic_advisor".replace(/^__anthropic_/, "")) {
+			const uses = [];
+			const results = /* @__PURE__ */ new Map();
+			let readingResults = false;
+			while (i < originalContent.length) {
+				const candidate = originalContent[i];
+				const record = typeof candidate === "object" && candidate !== null ? candidate : null;
+				if (record?.type === "server_tool_use" && record.name === "__anthropic_advisor".replace(/^__anthropic_/, "")) {
+					if (readingResults) {
+						if (results.size === uses.length) break;
+						invalidAdvisorHistory("advisor blocks overlap or are ambiguously nested");
+					}
+					const serverId = typeof record.id === "string" ? record.id : "";
+					const copilotId = toCopilotToolUseId(serverId);
+					if (!copilotId) invalidAdvisorHistory("advisor server_tool_use id is not round-trippable");
+					if (uses.some((use) => use.serverId === serverId)) invalidAdvisorHistory("duplicate advisor server_tool_use id");
+					uses.push({
+						serverId,
+						copilotId
+					});
+					currentAssistantContent.push({
+						type: "tool_use",
+						id: copilotId,
+						name: ADVISOR_INTERNAL_TOOL_NAME,
+						input: {}
+					});
+					i++;
+					continue;
+				}
+				if (record?.type === "advisor_tool_result") {
+					readingResults = true;
+					const serverId = typeof record.tool_use_id === "string" ? record.tool_use_id : "";
+					if (!uses.some((use) => use.serverId === serverId)) invalidAdvisorHistory("advisor_tool_result has no matching advisor server_tool_use");
+					if (results.has(serverId)) invalidAdvisorHistory("duplicate advisor_tool_result");
+					const resultContent = record.content;
+					let resultText;
+					if (typeof resultContent === "string") resultText = resultContent;
+					else if (typeof resultContent === "object" && resultContent !== null) {
+						const text = resultContent.text;
+						if (typeof text === "string") resultText = text;
+					}
+					if (resultText === void 0) invalidAdvisorHistory("advisor_tool_result has no replayable text");
+					results.set(serverId, resultText);
+					i++;
+					continue;
+				}
+				if (readingResults) {
+					if (results.size !== uses.length) invalidAdvisorHistory("advisor server_tool_use has no matching advisor_tool_result in the same assistant turn");
+					break;
+				}
+				currentAssistantContent.push(candidate);
+				i++;
+			}
+			if (results.size !== uses.length) invalidAdvisorHistory("advisor server_tool_use has no matching advisor_tool_result in the same assistant turn");
+			const ordinaryToolIds = currentAssistantContent.filter((entry) => typeof entry === "object" && entry !== null && entry.type === "tool_use" && entry.name !== "__anthropic_advisor").map((entry) => entry.id);
+			if (ordinaryToolIds.some((id) => typeof id !== "string" || id.length === 0)) invalidAdvisorHistory("client tool_use has no matchable id");
+			pushAssistant();
 			translated = true;
-			let resultText = "";
-			if (next && next.type === "advisor_tool_result") {
-				const c = next.content;
-				if (typeof c === "string") resultText = c;
-				else if (typeof c === "object" && c !== null) {
-					const txt = c.text;
-					if (typeof txt === "string") resultText = txt;
+			const advisorResults = uses.map((use) => ({
+				type: "tool_result",
+				tool_use_id: use.copilotId,
+				content: results.get(use.serverId)
+			}));
+			if (ordinaryToolIds.length > 0) {
+				if (i < originalContent.length) invalidAdvisorHistory("assistant continuation followed an unresolved client tool in an advisor turn");
+				if (typeof followingMessage !== "object" || followingMessage === null || followingMessage.role !== "user" || !Array.isArray(followingMessage.content)) invalidAdvisorHistory("mixed advisor/client-tool turn has no immediate user tool results");
+				const following = followingMessage;
+				const followingContent = following.content;
+				let sawNonResult = false;
+				const resultIds = [];
+				for (const entry of followingContent) {
+					const record = typeof entry === "object" && entry !== null ? entry : null;
+					if (record?.type === "tool_result") {
+						if (sawNonResult) invalidAdvisorHistory("tool_result appears after user text/content");
+						if (typeof record.tool_use_id !== "string") invalidAdvisorHistory("tool_result has no matchable tool_use_id");
+						resultIds.push(record.tool_use_id);
+					} else sawNonResult = true;
 				}
-				i += 2;
-			} else {
-				resultText = "[Advisor result missing in conversation history.]";
-				i += 1;
+				const expected = [...ordinaryToolIds].sort();
+				const actual = [...resultIds].sort();
+				if (expected.length !== actual.length || expected.some((id, index) => id !== actual[index])) invalidAdvisorHistory("mixed advisor/client-tool turn does not have exactly one result for every client tool");
+				messages.push({
+					...following,
+					content: [...advisorResults, ...followingContent]
+				});
+				return {
+					messages,
+					translated: true,
+					consumedFollowingMessage: true
+				};
 			}
 			messages.push({
 				role: "user",
-				content: [{
-					type: "tool_result",
-					tool_use_id: copilotId,
-					content: resultText
-				}]
+				content: advisorResults
 			});
 			currentAssistantContent = [];
 			continue;
 		}
-		if (b && b.type === "advisor_tool_result") {
-			translated = true;
-			i += 1;
-			continue;
-		}
+		if (b?.type === "advisor_tool_result") invalidAdvisorHistory("advisor_tool_result has no immediately preceding advisor server_tool_use");
 		currentAssistantContent.push(block);
-		i += 1;
+		i++;
 	}
 	if (currentAssistantContent.length > 0) messages.push({
 		role: "assistant",
 		content: currentAssistantContent
 	});
 	if (!translated) return {
-		messages: [{
-			role: "assistant",
-			content: originalContent
-		}],
-		translated: false
+		messages: [originalMessage],
+		translated: false,
+		consumedFollowingMessage: false
 	};
 	return {
 		messages,
-		translated: true
+		translated: true,
+		consumedFollowingMessage: false
 	};
 }
 function sanitizeAnthropicBody(rawBody) {
@@ -1679,8 +1904,8 @@ function sanitizeAnthropicBody(rawBody) {
 		const original = parsed.messages;
 		const rebuilt = [];
 		let anyTranslated = false;
-		const syntheticIndexRef = { value: 0 };
-		for (const msg of original) {
+		for (let messageIndex = 0; messageIndex < original.length; messageIndex++) {
+			const msg = original[messageIndex];
 			if (typeof msg !== "object" || msg === null || msg.role !== "assistant") {
 				rebuilt.push(msg);
 				continue;
@@ -1699,10 +1924,11 @@ function sanitizeAnthropicBody(rawBody) {
 				rebuilt.push(msg);
 				continue;
 			}
-			const { messages: split, translated } = splitAssistantTurnAtAdvisorPairs(content, syntheticIndexRef);
+			const { messages: split, translated, consumedFollowingMessage } = splitAssistantTurnAtAdvisorPairs(msg, content, original[messageIndex + 1]);
 			if (translated) {
 				anyTranslated = true;
 				for (const m of split) rebuilt.push(m);
+				if (consumedFollowingMessage) messageIndex++;
 			} else rebuilt.push(msg);
 		}
 		if (anyTranslated) {
@@ -1900,6 +2126,40 @@ function anthropicSseStreamFromEvents(events, opts) {
 			controller.close();
 		} catch {}
 	};
+	/**
+	* Tear down the upstream, exactly once, on a PREMATURE end of stream.
+	*
+	* Called from the three places a stream can end early — the stall branch,
+	* the error branch, and consumer `cancel()` — because all three leave the
+	* upstream fetch running and the generator suspended. Both halves matter:
+	* `onCancel` aborts the fetch, and `return()` drives the generator's
+	* `finally`; `return()` alone cannot release a generator parked on a
+	* never-settling await, since it queues behind that await.
+	*
+	* Two things this is deliberately NOT:
+	*
+	*   - **Not a `finally` around `pull`.** `pull` re-enters per chunk, so a
+	*     `finally` there would fire on every successful chunk.
+	*   - **Not called on normal completion** (`res.done`). Aborting an
+	*     AbortController whose fetch has already completed DESTROYS the socket
+	*     instead of returning it to the keep-alive pool, so every successful
+	*     turn would pay a fresh TLS handshake. Premature-only is the whole
+	*     correctness condition, and `tornDown` only makes it idempotent — it
+	*     does not make an unconditional call safe.
+	*/
+	let tornDown = false;
+	const teardownUpstream = () => {
+		if (tornDown) return;
+		tornDown = true;
+		try {
+			opts.onCancel?.();
+		} catch (err) {
+			consola.warn(`Anthropic-translate onCancel threw during teardown at ${opts.routePath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		try {
+			events.return?.(void 0)?.catch?.(() => void 0);
+		} catch {}
+	};
 	return new ReadableStream({
 		async pull(controller) {
 			if (consumerCancelled || finished) {
@@ -1918,8 +2178,7 @@ function anthropicSseStreamFromEvents(events, opts) {
 					}
 					const message = `Upstream stalled: no stream activity for ${timeoutMs}ms`;
 					consola.error(`Anthropic-translate stream inactivity timeout at ${opts.routePath}: ${message}`);
-					opts.onCancel?.();
-					events.return?.(void 0)?.catch?.(() => void 0);
+					teardownUpstream();
 					try {
 						controller.enqueue(enc.encode(buildAnthropicErrorEvent("timeout_error", message)));
 					} catch (enqueueError) {
@@ -1938,6 +2197,7 @@ function anthropicSseStreamFromEvents(events, opts) {
 				const name = err instanceof Error ? err.name : "Error";
 				const message = err instanceof Error ? err.message : String(err);
 				consola.error(`Anthropic-translate stream interrupted at ${opts.routePath}: ${name}: ${JSON.stringify(message)}`);
+				teardownUpstream();
 				try {
 					controller.enqueue(enc.encode(buildAnthropicErrorEvent(name, message)));
 				} catch (enqueueError) {
@@ -1968,8 +2228,7 @@ function anthropicSseStreamFromEvents(events, opts) {
 		cancel() {
 			consumerCancelled = true;
 			finished = true;
-			opts.onCancel?.();
-			events.return?.(void 0)?.catch?.(() => void 0);
+			teardownUpstream();
 		}
 	});
 }
@@ -3395,7 +3654,119 @@ async function handleNonClaudeChat(c, opts) {
 	return c.json(anthropic, 200);
 }
 //#endregion
+//#region src/lib/thinking-history-repair.ts
+const THINKING_INTEGRITY_ERROR_RES = [/messages\.(\d+)\.content\.\d+:\s*`thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified/, /messages\.(\d+)\.content\.\d+:\s*Invalid `signature` in `thinking` block/];
+const MAX_REMEMBERED_REPAIRS = 1e3;
+const OMITTED_THINKING_PLACEHOLDER = "[prior reasoning omitted]";
+const repairSalt = randomBytes(32);
+const rememberedRepairs = /* @__PURE__ */ new Set();
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function signedBlockFingerprint(_messageIndex, content) {
+	const hash = createHash("sha256");
+	hash.update(repairSalt);
+	let signedBlocks = 0;
+	for (let index = 0; index < content.length; index++) {
+		const block = content[index];
+		if (!isRecord(block)) continue;
+		if (block.type !== "thinking" && block.type !== "redacted_thinking") continue;
+		signedBlocks++;
+		hash.update(String(index));
+		hash.update(String(block.type));
+		if (typeof block.signature === "string") hash.update(block.signature);
+		if (typeof block.data === "string") hash.update(block.data);
+	}
+	return signedBlocks > 0 ? hash.digest("hex") : void 0;
+}
+function repairMessageAt(parsed, messageIndex) {
+	if (!Array.isArray(parsed.messages)) return void 0;
+	const messages = [...parsed.messages];
+	const message = messages[messageIndex];
+	if (!isRecord(message) || message.role !== "assistant") return void 0;
+	if (!Array.isArray(message.content)) return void 0;
+	const fingerprint = signedBlockFingerprint(messageIndex, message.content);
+	if (!fingerprint) return void 0;
+	const repairedContent = message.content.filter((block) => !isRecord(block) || block.type !== "thinking" && block.type !== "redacted_thinking");
+	const removedBlocks = message.content.length - repairedContent.length;
+	if (removedBlocks === 0) return void 0;
+	if (repairedContent.length === 0) repairedContent.push({
+		type: "text",
+		text: OMITTED_THINKING_PLACEHOLDER
+	});
+	messages[messageIndex] = {
+		...message,
+		content: repairedContent
+	};
+	parsed.messages = messages;
+	return {
+		body: JSON.stringify(parsed),
+		fingerprint,
+		messageIndex,
+		removedBlocks
+	};
+}
+/**
+* Build a one-shot repair only for Copilot's known signed-thinking integrity
+* rejections. The upstream error is the oracle: valid omitted-display thinking
+* also has an empty `thinking` string, so request shape alone cannot identify a
+* corrupt signature safely.
+*/
+function repairRejectedThinkingHistory(rawBody, upstreamErrorText) {
+	const match = THINKING_INTEGRITY_ERROR_RES.map((pattern) => pattern.exec(upstreamErrorText)).find((candidate) => candidate !== null);
+	if (!match) return void 0;
+	const messageIndex = Number(match[1]);
+	if (!Number.isSafeInteger(messageIndex) || messageIndex < 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return;
+	}
+	return repairMessageAt(parsed, messageIndex);
+}
+/**
+* Reapply a repair already proven successful in this process. Only salted
+* digests are retained; no message, thinking, signature, or tool content is
+* stored.
+*/
+function repairKnownThinkingHistory(rawBody) {
+	if (rememberedRepairs.size === 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return;
+	}
+	if (!Array.isArray(parsed.messages)) return void 0;
+	let repaired;
+	let totalRemovedBlocks = 0;
+	for (let index = parsed.messages.length - 1; index >= 0; index--) {
+		const message = parsed.messages[index];
+		if (!isRecord(message) || !Array.isArray(message.content)) continue;
+		const fingerprint = signedBlockFingerprint(index, message.content);
+		if (!fingerprint || !rememberedRepairs.has(fingerprint)) continue;
+		const attempt = repairMessageAt(parsed, index);
+		if (!attempt) continue;
+		totalRemovedBlocks += attempt.removedBlocks;
+		repaired = {
+			...attempt,
+			removedBlocks: totalRemovedBlocks
+		};
+	}
+	return repaired;
+}
+function rememberThinkingHistoryRepair(fingerprint) {
+	if (rememberedRepairs.has(fingerprint)) return;
+	if (rememberedRepairs.size >= MAX_REMEMBERED_REPAIRS) {
+		const oldest = rememberedRepairs.values().next().value;
+		if (typeof oldest === "string") rememberedRepairs.delete(oldest);
+	}
+	rememberedRepairs.add(fingerprint);
+}
+//#endregion
 //#region src/routes/messages/handler.ts
+const MAX_THINKING_REPAIR_ATTEMPTS = 5;
 const isWebSearchTool$1 = (tool) => !!tool && typeof tool === "object" && (typeof tool.type === "string" && tool.type.startsWith("web_search") || tool.name === "web_search");
 /**
 * Extract whitelisted beta headers from the incoming request to forward
@@ -3592,15 +3963,30 @@ async function handleCompletion(c) {
 	if (modelId) logEndpointMismatch(modelId, "/v1/messages");
 	const effectiveBetas = applyDefaultBetas(betaHeaders, resolvedModel ?? originalModel);
 	const advisorAborter = advisorEnabled ? new AbortController() : void 0;
+	const requestHeaders = {
+		...selectedModel?.requestHeaders,
+		...effectiveBetas
+	};
+	let nativeBody = resolvedBody;
+	const knownThinkingRepair = repairKnownThinkingHistory(nativeBody);
+	if (knownThinkingRepair) {
+		nativeBody = knownThinkingRepair.body;
+		consola.warn(`Reapplying proven thinking-history repair: message=${knownThinkingRepair.messageIndex} removed_blocks=${knownThinkingRepair.removedBlocks}`);
+	}
 	let response;
-	try {
-		response = await createMessages(resolvedBody, {
-			...selectedModel?.requestHeaders,
-			...effectiveBetas
-		}, advisorAborter?.signal, true);
+	let acceptedRepair;
+	const repairedMessageIndices = /* @__PURE__ */ new Set();
+	for (let attempt = 0; response === void 0; attempt++) try {
+		response = await createMessages(nativeBody, requestHeaders, advisorAborter?.signal, true);
+		if (acceptedRepair) {
+			rememberThinkingHistoryRepair(acceptedRepair.fingerprint);
+			consola.warn(`Thinking-history repair succeeded: message=${acceptedRepair.messageIndex} removed_blocks=${acceptedRepair.removedBlocks} attempts=${attempt}`);
+		}
 	} catch (error) {
-		if (error instanceof HTTPError) {
-			const errorBody = await error.response.clone().text().catch(() => "");
+		if (!(error instanceof HTTPError)) throw error;
+		const errorBody = await error.response.clone().text().catch(() => "");
+		const thinkingRepair = attempt < MAX_THINKING_REPAIR_ATTEMPTS ? repairRejectedThinkingHistory(nativeBody, errorBody) : void 0;
+		if (!thinkingRepair || repairedMessageIndices.has(thinkingRepair.messageIndex)) {
 			logRequest({
 				method: "POST",
 				path: c.req.path,
@@ -3609,8 +3995,13 @@ async function handleCompletion(c) {
 				status: error.response.status,
 				errorBody
 			}, selectedModel, startTime);
+			throw error;
 		}
-		throw error;
+		if (acceptedRepair) rememberThinkingHistoryRepair(acceptedRepair.fingerprint);
+		consola.warn(`Copilot rejected signed thinking history; retrying without rejected historical blocks: message=${thinkingRepair.messageIndex} removed_blocks=${thinkingRepair.removedBlocks} attempt=${attempt + 1}`);
+		nativeBody = thinkingRepair.body;
+		acceptedRepair = thinkingRepair;
+		repairedMessageIndices.add(thinkingRepair.messageIndex);
 	}
 	const contentType = response.headers.get("content-type") ?? "";
 	const clientAcceptsSSE = (c.req.header("accept") ?? "").includes("text/event-stream");
@@ -3645,17 +4036,14 @@ async function handleCompletion(c) {
 		if (advisorEnabled && response.body) {
 			let parsedBase = {};
 			try {
-				parsedBase = JSON.parse(resolvedBody);
+				parsedBase = JSON.parse(nativeBody);
 			} catch {}
 			const initialConversation = Array.isArray(parsedBase.messages) ? parsedBase.messages : [];
 			return new Response(buildAdvisorStream({
 				firstResponse: response,
 				initialConversation,
 				baseBody: parsedBase,
-				requestHeaders: {
-					...selectedModel?.requestHeaders,
-					...effectiveBetas
-				},
+				requestHeaders,
 				externalAborter: advisorAborter
 			}), {
 				status: response.status,
@@ -3715,7 +4103,7 @@ function resolveModelInBody$1(rawBody) {
 	const selectedModel = resolvedModel ? state.models?.data.find((m) => m.id === resolvedModel) : void 0;
 	if (translateThinking(parsed, selectedModel)) modified = true;
 	if (clampOutputConfigEffortInPlace(parsed, selectedModel)) modified = true;
-	if (rawBody.includes("\"scope\"") && sanitizeCacheControl$1(parsed)) modified = true;
+	if ((rawBody.includes("\"scope\"") || rawBody.includes("\"cache_control\"") && (rawBody.includes("\"thinking\"") || rawBody.includes("\"redacted_thinking\""))) && sanitizeCacheControl$1(parsed)) modified = true;
 	if ((rawBody.includes("\"budget\"") || rawBody.includes("\"output_config\"") || rawBody.includes("\"betas\"") || rawBody.includes("\"eager_input_streaming\"")) && stripAnthropicOnlyFields$1(parsed)) modified = true;
 	return {
 		body: modified ? JSON.stringify(parsed) : rawBody,
@@ -3797,7 +4185,9 @@ function translateThinking(body, model) {
 	return true;
 }
 /**
-* Strip the `scope` field from all `cache_control` objects in the body.
+* Strip the `scope` field from ordinary `cache_control` objects. Copilot
+* rejects the entire cache_control object on signed thinking blocks, so remove
+* that unsigned transport metadata without touching thinking/signature/data.
 * Claude CLI 2.1.88+ sends {"type":"ephemeral","scope":"global"} which
 * Copilot rejects. Mutates the parsed object in place.
 *
@@ -3808,6 +4198,11 @@ function sanitizeCacheControl$1(body) {
 	let stripped = false;
 	function stripScope(block) {
 		const cc = block.cache_control;
+		if (cc && (block.type === "thinking" || block.type === "redacted_thinking")) {
+			delete block.cache_control;
+			stripped = true;
+			return;
+		}
 		if (cc?.scope !== void 0) {
 			delete cc.scope;
 			if (Object.keys(cc).length === 0) delete block.cache_control;
@@ -4014,7 +4409,7 @@ function resolveModelInBody(rawBody) {
 			modified = true;
 		}
 	}
-	if (rawBody.includes("\"scope\"") && sanitizeCacheControl(parsed)) modified = true;
+	if ((rawBody.includes("\"scope\"") || rawBody.includes("\"cache_control\"") && (rawBody.includes("\"thinking\"") || rawBody.includes("\"redacted_thinking\""))) && sanitizeCacheControl(parsed)) modified = true;
 	if ((rawBody.includes("\"budget\"") || rawBody.includes("\"output_config\"") || rawBody.includes("\"betas\"") || rawBody.includes("\"eager_input_streaming\"")) && stripAnthropicOnlyFields(parsed)) modified = true;
 	const resolvedModel = typeof parsed.model === "string" ? parsed.model : originalModel;
 	const selectedModel = resolvedModel ? state.models?.data.find((m) => m.id === resolvedModel) : void 0;
@@ -4028,6 +4423,11 @@ function resolveModelInBody(rawBody) {
 function sanitizeCacheControl(body) {
 	let stripped = false;
 	function stripScope(block) {
+		if (block.cache_control && (block.type === "thinking" || block.type === "redacted_thinking")) {
+			delete block.cache_control;
+			stripped = true;
+			return;
+		}
 		if (block.cache_control?.scope !== void 0) {
 			delete block.cache_control.scope;
 			if (Object.keys(block.cache_control).length === 0) delete block.cache_control;
@@ -4751,6 +5151,7 @@ async function setupAndServe(options) {
 	await cacheModels();
 	consola.debug(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serveOptions = buildServeOptions(server.fetch, options.silent);
+	installBodySizeStatsExitHook();
 	let srvxServer;
 	if (options.port !== void 0) srvxServer = serve({
 		...serveOptions,
@@ -5156,4 +5557,4 @@ function getCodexEnvVars(serverUrl) {
 //#endregion
 export { sharedServerArgs as a, listModelsForEndpoint as c, checkClaudeVersion as d, updateClaude as f, setupAndServe as i, enableFileLogging as l, getCodexEnvVars as n, startKeepAwake as o, parseSharedArgs as r, stopKeepAwake as s, getClaudeCodeEnvVars as t, runSelfUpdate as u };
 
-//# sourceMappingURL=server-setup-BM9Smfek.js.map
+//# sourceMappingURL=server-setup-BmyWS4WU.js.map