github-router 0.3.269 → 0.3.270

package/dist/{server-setup-Dd293T1O.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-DSbBlgFt.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-Bg1_DWhi.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-C_q95GF7.js";
-import { t as getCopilotUsage } from "./get-copilot-usage-CFEpeA7E.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();
@@ -1277,7 +1357,7 @@ function collectToolFieldKeys(body) {
 //#endregion
 //#region package.json
 var name = "github-router";
-var version = "0.3.269";
+var version = "0.3.270";
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -1625,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
@@ -1645,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) {
@@ -1752,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;
@@ -1772,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) {
@@ -3501,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
@@ -3698,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,
@@ -3715,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");
@@ -3751,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,
@@ -3821,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,
@@ -3903,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.
 *
@@ -3914,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;
@@ -4120,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;
@@ -4134,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;
@@ -5263,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-Dd293T1O.js.map
+//# sourceMappingURL=server-setup-BmyWS4WU.js.map