github-router 0.3.288 → 0.3.289

package/dist/{peer-mcp-personas-B5Wp6wIn.js → peer-mcp-personas-Bd56EmiO.js}

@@ -19497,6 +19497,354 @@ function currentInFlight() {
 	return inFlight$2;
 }
 //#endregion
+//#region src/lib/prompt-cache.ts
+/**
+* Conservative eligibility floor, in UTF-8 BYTES — never `.length`, which
+* counts UTF-16 code units and undercounts anything outside the BMP (an
+* emoji is 2 code units but 4 bytes). This is a proxy for "the prefix is
+* obviously large enough that marking it as a cache breakpoint is worth one
+* of the scarce marker slots," and it deliberately does NOT claim to be a
+* token count: byte-to-token density varies by tokenizer and content — CJK
+* text carries MORE tokens per byte than ASCII prose (undercounting risk is
+* the SAFE direction: we'd skip a marker that might have qualified), while a
+* long run of a repeated character or repeated whitespace carries FEWER
+* tokens per byte than either, since BPE merges long runs into very few
+* tokens (overcounting risk: a byte count clearing the floor doesn't
+* guarantee the real token count clears Anthropic's or Copilot's per-model
+* minimum). No fixed byte threshold can bound that adversarial case; this
+* value is chosen so ordinary Claude Code system prompts and tool schemas
+* (natural-language / JSON, not deliberately repetitive) reliably qualify,
+* while genuinely small prefixes never burn a marker for no benefit.
+*/
+const MIN_CACHEABLE_PREFIX_BYTES = 4096;
+const CACHE_KEY_NAMESPACE = "ghr-cache-v1";
+const CACHE_DIAGNOSTIC_LIMIT = 128;
+const GPT56_EXPLICIT_CACHE_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-5.6-luna"
+]);
+const priorSignatures = /* @__PURE__ */ new Map();
+function nonNegativeInt(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+	return Math.floor(value);
+}
+/**
+* Pick the first genuinely POSITIVE numeric candidate from an ordered,
+* priority-ranked list of usage-shape fields. `??`-chaining these fields is
+* wrong: it stops at the first field that is merely PRESENT, and a provider
+* surface that always populates a nested detail object with `0` as a
+* placeholder (while the real, positive count is reported only in a
+* lower-priority field, e.g. the top-level one) would have its explicit zero
+* silently shadow that populated count. Falling through zeros to find a real
+* positive value fixes that; when every candidate is zero, absent, or
+* non-numeric, this returns `0` — a genuine all-zero reading, never
+* `undefined` — so downstream `nonNegativeInt` always has a countable value.
+*/
+function firstPositive(...candidates) {
+	for (const c of candidates) if (typeof c === "number" && Number.isFinite(c) && c > 0) return c;
+	return 0;
+}
+function usageDetails(usage) {
+	const input = usage.input_tokens_details ?? {};
+	const prompt = usage.prompt_tokens_details ?? {};
+	return {
+		cached_tokens: firstPositive(input.cached_tokens, prompt.cached_tokens, usage.cache_read_input_tokens),
+		cache_write_tokens: firstPositive(input.cache_write_tokens, input.cache_creation_tokens, prompt.cache_write_tokens, prompt.cache_creation_tokens, usage.cache_write_tokens, usage.cache_creation_input_tokens),
+		cache_ttl_seconds: firstPositive(input.cache_ttl_seconds, prompt.cache_ttl_seconds, usage.cache_ttl_seconds)
+	};
+}
+/**
+* OpenAI totals INCLUDE cached and cache-write tokens. Normalize them into
+* mutually exclusive buckets so Anthropic and Pi consumers do not count the
+* same input twice.
+*/
+function normalizeOpenAIUsage(usage) {
+	if (!usage) return {
+		totalInput: 0,
+		uncachedInput: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0
+	};
+	const totalInput = nonNegativeInt(usage.input_tokens ?? usage.prompt_tokens);
+	const output = nonNegativeInt(usage.output_tokens ?? usage.completion_tokens);
+	const details = usageDetails(usage);
+	const cacheRead = Math.min(totalInput, nonNegativeInt(details.cached_tokens));
+	const remaining = Math.max(0, totalInput - cacheRead);
+	const cacheWrite = Math.min(remaining, nonNegativeInt(details.cache_write_tokens ?? details.cache_creation_tokens));
+	const uncachedInput = Math.max(0, totalInput - cacheRead - cacheWrite);
+	const reportedTotal = nonNegativeInt(usage.total_tokens);
+	const cacheTtlSeconds = nonNegativeInt(details.cache_ttl_seconds);
+	return {
+		totalInput,
+		uncachedInput,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(reportedTotal, totalInput + output),
+		...cacheTtlSeconds > 0 ? { cacheTtlSeconds } : {}
+	};
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function signatureFor(value) {
+	return hash(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function serializedBytes(value) {
+	return Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function logCacheSignature(args) {
+	if (parseBoolEnv(process.env.GH_ROUTER_LOG_CACHE) !== true) return;
+	const key = `${args.endpoint}:${args.model}:${args.workload}`;
+	const current = {
+		system: signatureFor(args.system),
+		tools: signatureFor(args.tools),
+		messages: signatureFor(args.messages)
+	};
+	const previous = priorSignatures.get(key);
+	let changed = "cold";
+	if (previous) changed = previous.system !== current.system ? "system" : previous.tools !== current.tools ? "tools" : previous.messages !== current.messages ? "messages" : "none";
+	priorSignatures.set(key, current);
+	if (priorSignatures.size > CACHE_DIAGNOSTIC_LIMIT) {
+		const oldest = priorSignatures.keys().next().value;
+		if (oldest !== void 0) priorSignatures.delete(oldest);
+	}
+	consola.info(`cache-signature endpoint=${args.endpoint} model=${args.model} workload=${args.workload} changed=${changed} system_bytes=${serializedBytes(args.system ?? "")} tools_bytes=${serializedBytes(args.tools ?? [])} messages_bytes=${serializedBytes(args.messages ?? [])}`);
+}
+function hasResponsesBreakpoint(input) {
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return false;
+		if (Array.isArray(value)) return value.some(visit);
+		const record = value;
+		return record.prompt_cache_breakpoint !== void 0 || Object.values(record).some(visit);
+	};
+	return visit(input);
+}
+function gpt56ExplicitCacheEnabled(model) {
+	if (parseBoolEnv(process.env.GH_ROUTER_DISABLE_GPT56_EXPLICIT_CACHE) === true) return false;
+	return GPT56_EXPLICIT_CACHE_MODELS.has(model);
+}
+function responsesCacheKey(payload, opts, stablePrefix) {
+	const digest = hash(JSON.stringify({
+		namespace: CACHE_KEY_NAMESPACE,
+		model: payload.model,
+		workload: opts.workload,
+		scope: opts.scope ?? "",
+		stablePrefix,
+		tools: payload.tools ?? []
+	}));
+	return `${CACHE_KEY_NAMESPACE}-${digest.slice(0, 48)}`;
+}
+/**
+* Add GPT-5.6 explicit caching only to router-owned REUSABLE-PREFIX payloads.
+* Public passthrough routes never call this helper, and existing caller
+* fields always win. Live shape acceptance is pinned by compatibility probe
+* `gpt56_explicit_cache_breakpoint`.
+*
+* **`"conversation"` is deliberately EXCLUDED and left untouched (a no-op),
+* same as `"passthrough"`/`"one-shot"`.** A live-verified regression: on a
+* growing multi-turn conversation (Claude Code's translated main loop and
+* the worker-agent loop, both of which pass `workload: "conversation"`),
+* marking only the stable SYSTEM block with an explicit breakpoint measured
+* substantially worse than leaving caching provider-managed and implicit.
+* Explicit mode is a distinct
+* caching strategy from Copilot's provider-managed automatic caching, not an
+* addition to it — turning it on for a request marks only the bytes an
+* explicit breakpoint names, and the REST of that request's prefix (here,
+* the entire un-marked growing message history) stops receiving automatic
+* prefix-growth caching too. Measured on `gpt-5.6-sol` with explicit mode
+* force-enabled for conversation workloads: turn 1 (cold)
+* `input_tokens=27038, cache_write=2031, cache_read=0`; turn 2
+* `input_tokens=27054, cache_read=2031`; turn 3 `input_tokens=27071,
+* cache_read=2031` — the ~2k-token system block cached once and never grew,
+* while the other ~25k tokens of accumulating history were recomputed from
+* scratch on every single turn. `"reusable-prefix"` calls (peer/advisor/
+* worker-tool/browser-compressor prefixes reused verbatim across many
+* DISCRETE calls, never a single request whose own history keeps growing)
+* do not have this failure mode and keep the explicit treatment below.
+*/
+function applyResponsesCachePolicy(payload, opts) {
+	logCacheSignature({
+		endpoint: "/responses",
+		model: payload.model,
+		workload: opts.workload,
+		system: opts.stablePrefix ?? payload.instructions,
+		tools: payload.tools,
+		messages: payload.input
+	});
+	if (opts.workload !== "reusable-prefix" || !gpt56ExplicitCacheEnabled(payload.model) || payload.prompt_cache_key !== void 0 || payload.prompt_cache_options !== void 0 || hasResponsesBreakpoint(payload.input)) return payload;
+	const stablePrefix = opts.stablePrefix ?? payload.instructions;
+	const stableBytes = serializedBytes(stablePrefix ?? "") + serializedBytes(payload.tools ?? []);
+	if (!stablePrefix || stableBytes < MIN_CACHEABLE_PREFIX_BYTES) return payload;
+	const input = typeof payload.input === "string" ? [{
+		role: "user",
+		content: payload.input
+	}] : [...payload.input];
+	const stableContent = [{
+		type: "input_text",
+		text: stablePrefix,
+		prompt_cache_breakpoint: { mode: "explicit" }
+	}];
+	let nextInput;
+	let removeInstructions = false;
+	if (payload.instructions === stablePrefix) {
+		nextInput = [{
+			role: "system",
+			content: stableContent
+		}, ...input];
+		removeInstructions = true;
+	} else {
+		const stableSystemIndex = input.findIndex((item) => item.role === "system" && item.content === stablePrefix);
+		if (stableSystemIndex < 0) return payload;
+		nextInput = [...input];
+		nextInput[stableSystemIndex] = {
+			...nextInput[stableSystemIndex],
+			content: stableContent
+		};
+	}
+	const next = {
+		...payload,
+		input: nextInput,
+		prompt_cache_key: responsesCacheKey(payload, opts, stablePrefix),
+		prompt_cache_options: {
+			mode: "explicit",
+			ttl: "30m"
+		}
+	};
+	if (removeInstructions) delete next.instructions;
+	return next;
+}
+function itemHasCacheControl(value) {
+	return !!value && typeof value === "object" && value.cache_control !== void 0;
+}
+function hasClaudeCacheControl(body) {
+	if (itemHasCacheControl(body.system)) return true;
+	if (Array.isArray(body.system) && body.system.some(itemHasCacheControl)) return true;
+	if (Array.isArray(body.tools) && body.tools.some(itemHasCacheControl)) return true;
+	if (!Array.isArray(body.messages)) return false;
+	return body.messages.some((message) => {
+		if (!message || typeof message !== "object") return false;
+		const content = message.content;
+		return itemHasCacheControl(content) || Array.isArray(content) && content.some(itemHasCacheControl);
+	});
+}
+/**
+* UTF-8 byte length of the tools array alone — the eligibility floor for the
+* TOOL breakpoint. Marked on the last non-deferred tool, it caches only the
+* tools prefix (Claude's wire order is tools, then system, then messages), so
+* its own size — not the combined system+tools size — is what determines
+* whether that marker is worth spending. See `MIN_CACHEABLE_PREFIX_BYTES`.
+*/
+function claudeToolsPrefixBytes(body) {
+	return serializedBytes(body.tools ?? []);
+}
+/**
+* UTF-8 byte length of tools + system combined — the eligibility floor for
+* the SYSTEM breakpoint. Marked on the last system text block, it caches
+* everything up to and including system (tools THEN system in wire order),
+* so the combined size is the right measure — checked SEPARATELY from the
+* tools-only floor above so a large system prompt behind tiny tools doesn't
+* smuggle a useless tools-only marker in under the combined total, and a
+* large tools array behind an empty system doesn't get double-counted as
+* "small" just because system alone is tiny.
+*/
+function claudeSystemPrefixBytes(body) {
+	return claudeToolsPrefixBytes(body) + serializedBytes(body.system ?? "");
+}
+function markClaudeSystem(body) {
+	if (typeof body.system === "string" && body.system.length > 0) {
+		body.system = [{
+			type: "text",
+			text: body.system,
+			cache_control: { type: "ephemeral" }
+		}];
+		return true;
+	}
+	if (!Array.isArray(body.system)) return false;
+	for (let index = body.system.length - 1; index >= 0; index--) {
+		const block = body.system[index];
+		if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+			body.system[index] = {
+				...block,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+function markClaudeTool(body) {
+	if (!Array.isArray(body.tools)) return false;
+	for (let index = body.tools.length - 1; index >= 0; index--) {
+		const tool = body.tools[index];
+		if (tool && typeof tool === "object" && tool.defer_loading !== true) {
+			body.tools[index] = {
+				...tool,
+				cache_control: { type: "ephemeral" }
+			};
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Apply the bounded Claude anchor policy to router-generated Messages bodies.
+* Caller-owned marker layouts are returned byte-for-byte unchanged.
+*
+* Marks at most TWO breakpoints — the last non-deferred tool and the stable
+* system boundary — each gated on its OWN eligibility check
+* (`claudeToolsPrefixBytes` / `claudeSystemPrefixBytes`) rather than one
+* combined check, so a large system prompt behind tiny tools doesn't also
+* mark a tools breakpoint too small to be worth a marker slot, and vice
+* versa. Anthropic's own hard ceiling is FOUR `cache_control` blocks per
+* request (probe `cache_control_marker_limit_5`); this policy only ever
+* spends up to two of them (`hasClaudeCacheControl` already refuses to run
+* at all once the caller has marked anything itself, so the two never
+* combine with a caller-owned marker to approach that ceiling).
+*
+* There used to be a third, message-level marking path gated on
+* `opts.workload === "conversation"`. It was removed as dead code: every
+* production call site of this function (`src/routes/mcp/handler.ts`,
+* `src/services/advisor/advisor.ts`) passes `workload: "reusable-prefix"`,
+* so the per-message branch never ran outside its own unit test, which gave
+* false confidence that production traffic exercised it. `CacheWorkload`
+* keeps `"conversation"` as a shared enum value — the Responses-side policy,
+* which has no per-message logic of its own, still uses it — so passing it
+* here remains type-valid; it now behaves identically to
+* `"reusable-prefix"`.
+*/
+function applyClaudeCachePolicy(rawBody, opts) {
+	if (opts.workload === "passthrough" || opts.workload === "one-shot" || parseBoolEnv(process.env.GH_ROUTER_DISABLE_CLAUDE_CACHE_POLICY) === true) return rawBody;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return rawBody;
+	const body = parsed;
+	if (typeof body.model !== "string" || !body.model.startsWith("claude-") || hasClaudeCacheControl(body)) return rawBody;
+	const toolsEligible = claudeToolsPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	const systemEligible = claudeSystemPrefixBytes(body) >= MIN_CACHEABLE_PREFIX_BYTES;
+	if (!toolsEligible && !systemEligible) return rawBody;
+	let markers = 0;
+	if (toolsEligible && markClaudeTool(body)) markers++;
+	if (systemEligible && markClaudeSystem(body)) markers++;
+	if (markers === 0) return rawBody;
+	logCacheSignature({
+		endpoint: "/messages",
+		model: body.model,
+		workload: opts.workload,
+		system: body.system,
+		tools: body.tools,
+		messages: body.messages
+	});
+	return JSON.stringify(body);
+}
+//#endregion
 //#region src/lib/vision-preflight.ts
 /**
 * Outbound vision handling.
@@ -20421,7 +20769,7 @@ async function callViaChat(model, systemPrompt, userMessage, tool, signal) {
 *  Image parts use `input_image` (vs chat's `image_url`) — see
 *  `toResponsesContent`. */
 async function callViaResponses(model, systemPrompt, userMessage, tool, signal) {
-	const payload = {
+	const payload = applyResponsesCachePolicy({
 		model,
 		stream: false,
 		input: [{
@@ -20441,7 +20789,10 @@ async function callViaResponses(model, systemPrompt, userMessage, tool, signal)
 			type: "function",
 			name: tool.name
 		}
-	};
+	}, {
+		workload: "reusable-prefix",
+		stablePrefix: systemPrompt
+	});
 	const resp = await createResponses(payload, void 0, signal, true);
 	const output = Array.isArray(resp.output) ? resp.output : [];
 	for (const item of output) {
@@ -24491,6 +24842,10 @@ function neutralToolsToResponses(tools) {
 /** Assemble the full Responses payload from the neutral request shape. */
 function assembleResponsesPayload(opts) {
 	const input = [];
+	if (opts.dynamicInstructions) input.push({
+		role: "system",
+		content: opts.dynamicInstructions
+	});
 	for (const m of opts.messages) for (const item of neutralMessageToResponsesInput(m)) input.push(item);
 	const payload = {
 		model: opts.model,
@@ -24507,7 +24862,10 @@ function assembleResponsesPayload(opts) {
 	if (typeof opts.maxOutputTokens === "number" && opts.maxOutputTokens > 0) payload.max_output_tokens = Math.max(opts.maxOutputTokens, RESPONSES_MIN_MAX_OUTPUT_TOKENS);
 	if (opts.stopSequences && opts.stopSequences.length > 0) payload.stop = [...opts.stopSequences];
 	if (opts.parallelToolCalls === false) payload.parallel_tool_calls = false;
-	return payload;
+	return opts.cachePolicy ? applyResponsesCachePolicy(payload, {
+		...opts.cachePolicy,
+		stablePrefix: opts.cachePolicy.stablePrefix ?? opts.instructions
+	}) : payload;
 }
 //#endregion
 //#region src/lib/worker-agent/context-budget.ts
@@ -25042,7 +25400,10 @@ function mapResponsesUsage(u) {
 		prompt_tokens: u.input_tokens ?? 0,
 		completion_tokens: u.output_tokens ?? 0,
 		total_tokens: u.total_tokens ?? 0,
-		prompt_tokens_details: u.input_tokens_details?.cached_tokens != null ? { cached_tokens: u.input_tokens_details.cached_tokens } : void 0
+		prompt_tokens_details: u.input_tokens_details != null ? {
+			cached_tokens: u.input_tokens_details.cached_tokens ?? 0,
+			cache_write_tokens: u.input_tokens_details.cache_write_tokens ?? u.input_tokens_details.cache_creation_tokens ?? 0
+		} : void 0
 	};
 }
 /**
@@ -25291,6 +25652,7 @@ function buildResponsesPayload(context, resolved) {
 		messages,
 		tools: piToolsToNeutral(context.tools),
 		reasoningEffort: resolved.thinking,
+		cachePolicy: { workload: "conversation" },
 		stream: true
 	});
 }
@@ -25513,12 +25875,13 @@ function emptyUsage() {
 }
 function deriveUsage(u) {
 	if (!u) return emptyUsage();
+	const normalized = normalizeOpenAIUsage(u);
 	return {
-		input: u.prompt_tokens ?? 0,
-		output: u.completion_tokens ?? 0,
-		cacheRead: u.prompt_tokens_details?.cached_tokens ?? 0,
-		cacheWrite: 0,
-		totalTokens: u.total_tokens ?? 0,
+		input: normalized.uncachedInput,
+		output: normalized.output,
+		cacheRead: normalized.cacheRead,
+		cacheWrite: normalized.cacheWrite,
+		totalTokens: normalized.totalTokens,
 		cost: {
 			input: 0,
 			output: 0,
@@ -27839,7 +28202,7 @@ function jsonPathPreflightCap(body, scope) {
 async function dispatchModelCall(args) {
 	const resolvedModel = resolveModel(args.model);
 	if (args.endpoint === "/v1/responses") {
-		const payload = {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedModel,
 			instructions: args.instructions,
 			input: [{
@@ -27854,7 +28217,7 @@ async function dispatchModelCall(args) {
 			}],
 			stream: false,
 			reasoning: { effort: args.effort }
-		};
+		}, { workload: "reusable-prefix" });
 		return extractResponsesText(await withTransientRetry(() => createResponses(payload, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -27862,7 +28225,7 @@ async function dispatchModelCall(args) {
 	}
 	if (args.endpoint === "/v1/messages") {
 		const maxTokens = args.effort === "low" ? 4096 : args.effort === "medium" ? 8192 : args.effort === "high" ? 16384 : 32768;
-		const body = JSON.stringify({
+		const body = applyClaudeCachePolicy(JSON.stringify({
 			model: resolvedModel,
 			max_tokens: maxTokens,
 			system: args.instructions,
@@ -27885,7 +28248,7 @@ async function dispatchModelCall(args) {
 				role: "user",
 				content: args.userText
 			}]
-		});
+		}), { workload: "reusable-prefix" });
 		return extractMessagesText(await (await withTransientRetry(() => createMessages(body, void 0, args.signal), {
 			signal: args.signal,
 			label: resolvedModel
@@ -29387,7 +29750,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 	}
 	const conversationText = renderConversationAsText(conversation, maxUnits, measure);
 	if (advisorUsesResponses(resolvedAdvisorModel)) {
-		const payload = {
+		const payload = applyResponsesCachePolicy({
 			model: resolvedAdvisorModel,
 			instructions: advisorSystem,
 			input: [{
@@ -29399,7 +29762,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			}],
 			stream: false,
 			reasoning: { effort: advisorEffort }
-		};
+		}, { workload: "reusable-prefix" });
 		const response = await withTransientRetry(() => createResponses(payload, void 0, signal), {
 			signal,
 			label: resolvedAdvisorModel
@@ -29424,7 +29787,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 	const advisorEntry = state.models?.data?.find((m) => m.id === resolvedAdvisorModel);
 	const limits = advisorEntry?.capabilities?.limits;
 	const maxTokens = limits?.max_non_streaming_output_tokens ?? limits?.max_output_tokens ?? ADVISOR_FALLBACK_MAX_OUTPUT_TOKENS;
-	const advisorBody = JSON.stringify({
+	const advisorBody = applyClaudeCachePolicy(JSON.stringify({
 		model: resolvedAdvisorModel,
 		max_tokens: maxTokens,
 		system: advisorSystem,
@@ -29437,7 +29800,7 @@ async function runAdvisor(conversation, advisorModel, advisorEffort, signal, adv
 			thinking: { type: "adaptive" },
 			...advertisedEffortLadder(resolvedAdvisorModel) ? { output_config: { effort: advisorEffort } } : {}
 		} : {}
-	});
+	}), { workload: "reusable-prefix" });
 	const json = await (await withTransientRetry(() => createMessages(advisorBody, {}, signal), {
 		signal,
 		label: resolvedAdvisorModel
@@ -31715,7 +32078,7 @@ function advisorTool(getMessages) {
 			const release = acquireInFlightSlot();
 			if (!release) throw new Error(`advisor: MCP in-flight cap (${MAX_INFLIGHT_TOOLS_CALL}) saturated; retry shortly`);
 			try {
-				const text = extractResponsesText(await createResponses({
+				const payload = applyResponsesCachePolicy({
 					model: resolvedModel,
 					instructions: advisorSystem,
 					input: [{
@@ -31727,7 +32090,8 @@ function advisorTool(getMessages) {
 					}],
 					stream: false,
 					reasoning: { effort: ADVISOR_DEFAULT_EFFORT }
-				}, void 0, signal, true));
+				}, { workload: "reusable-prefix" });
+				const text = extractResponsesText(await createResponses(payload, void 0, signal, true));
 				if (!text) throw new Error("advisor returned empty output");
 				return textResult(text);
 			} finally {
@@ -36111,6 +36475,6 @@ function enumerateInjectedMcpToolNames(groupKeys, opts = {}) {
 	return [...new Set(names)];
 }
 //#endregion
-export { handleMcpDelete as $, generateRandomPort as $t, satisfiesMinVersion as A, readResponseBodyCapped as At, rememberThinkingHistoryRepair as B, CONDENSED_OPERATING_SEQUENCE as Bt, availableToolCommands as C, getTokenCount as Ct, vscodeRipgrepPath as D, createResponses as Dt, toolbeltSkipSet as E, resolveMcpToolTimeoutMs as Et, injectAdvisorTool as F, provisionAndIndexColbert as Ft, isControllerClosedError as G, BUDGET_SMALL_FAST_CATALOG_ID as Gt, repairRejectedThinkingHistory as H, shouldUseInsecureTls as Ht, isAdvisorRequested as I, extractTarGzMember as It, relayAnthropicStream as J, DEFAULT_CODEX_MODEL as Jt, logStreamError as K, BUDGET_SMALL_FAST_SLUG as Kt, resolveAdvisorEffort as L, extractZipMember as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, provisionBrowserAssets as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, hasSupportedBrowserInstalled as Nt, TOOLBELT_TOOLS$1 as O, createChatCompletions as Ot, buildAdvisorStream as P, colbertDegradedWarning as Pt, clampEffort as Q, UPSTREAM_INACTIVITY_TIMEOUT_MS as Qt, resolveAdvisorModel as R, warmTreeSitterPool as Rt, buildEnv as S, createMessages as St, toolbeltEnabled as T, warnOnTokenPriceDrift as Tt, buildAnthropicErrorEvent as U, collapsePathKeys as Ut, repairKnownThinkingHistory as V, DEFINITION_OF_GREATNESS as Vt, buildOpenAIErrorEvent as W, toolbeltPathOverride as Wt, UNKNOWN_EFFORT_ANCHOR as X, DEFAULT_PORT as Xt, EFFORT_ORDER as Y, DEFAULT_CODEX_MODEL_FALLBACKS as Yt, bucketEffort as Z, UPSTREAM_FETCH_TIMEOUT_MS as Zt, appendPlanReminder as _, scribeModel as _t, buildPeerAwarenessSnippet as a, classifyMessagesRoute as an, browseAgentEnabled as at, resolveWorkerRunOpts as b, shimDefaultsToXhigh as bt, personasFor as c, withInstallLock as cn, fleetToolsEnabled as ct, EXPLORE_DEFAULT_MODEL as d, implementerFastModel as dt, isBudgetClaudeLead as en, handleMcpPost as et, EXPLORE_DEFAULT_THINKING as f, nativeSubagentModel as ft, TEST_DEFAULT_MODEL as g, scoutModel as gt, REVIEW_DEFAULT_MODEL as h, reviewerModel as ht, buildAgentPrompt as i, upstreamMaxConnections as in, brainstormModel as it, searchWeb as j, parseJsonOrDiagnose as jt, assetFor as k, MAX_RESPONSE_BODY_BYTES as kt, BROWSE_DEFAULT_MODEL as l, geminiAvailable as lt, PLAN_DEFAULT_MODEL as m, reviewerFastModel as mt, MCP_GROUPS as n, resolveLeadSlugArg as nn, agentToolsEnabled as nt, buildPeerAwarenessSummary as o, withOneMSuffix as on, browserCompoundToolsEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveGeminiReviewModel as pt, readIteratorWithTimeout as q, DEFAULT_CLAUDE_MODEL_FALLBACKS as qt, assertMcpToolSurfaceConsistent as r, upstreamAllowH2 as rn, artifactToolsEnabled as rt, enumerateInjectedMcpToolNames as s, withOneMSuffixForLead as sn, browserToolsEnabled as st, GROUP_META as t, pickClaudeDefault as tn, REVIEW_FAST_DEFAULT_MODEL as tt, DEFAULT_MODEL_CHAIN as u, generalPurposeFastModel as ut, resolveDefaultModel as v, standInToolEnabled as vt, buildToolbeltAwareness as w, assembleResponsesPayload as wt, runWorkerAgent as x, countTokens as xt, resolveModeDefaults as y, workerToolsEnabled as yt, formatThinkingRepairDecline as z, provisionTreeSitterAssets as zt };
+export { handleMcpDelete as $, UPSTREAM_INACTIVITY_TIMEOUT_MS as $t, satisfiesMinVersion as A, readResponseBodyCapped as At, rememberThinkingHistoryRepair as B, provisionTreeSitterAssets as Bt, availableToolCommands as C, getTokenCount as Ct, vscodeRipgrepPath as D, createResponses as Dt, toolbeltSkipSet as E, resolveMcpToolTimeoutMs as Et, injectAdvisorTool as F, colbertDegradedWarning as Ft, isControllerClosedError as G, toolbeltPathOverride as Gt, repairRejectedThinkingHistory as H, DEFINITION_OF_GREATNESS as Ht, isAdvisorRequested as I, provisionAndIndexColbert as It, relayAnthropicStream as J, DEFAULT_CLAUDE_MODEL_FALLBACKS as Jt, logStreamError as K, BUDGET_SMALL_FAST_CATALOG_ID as Kt, resolveAdvisorEffort as L, extractTarGzMember as Lt, ADVISOR_INTERNAL_TOOL_NAME as M, normalizeOpenAIUsage as Mt, ADVISOR_TOOL_INSTRUCTIONS as N, provisionBrowserAssets as Nt, TOOLBELT_TOOLS$1 as O, createChatCompletions as Ot, buildAdvisorStream as P, hasSupportedBrowserInstalled as Pt, clampEffort as Q, UPSTREAM_FETCH_TIMEOUT_MS as Qt, resolveAdvisorModel as R, extractZipMember as Rt, buildEnv as S, createMessages as St, toolbeltEnabled as T, warnOnTokenPriceDrift as Tt, buildAnthropicErrorEvent as U, shouldUseInsecureTls as Ut, repairKnownThinkingHistory as V, CONDENSED_OPERATING_SEQUENCE as Vt, buildOpenAIErrorEvent as W, collapsePathKeys as Wt, UNKNOWN_EFFORT_ANCHOR as X, DEFAULT_CODEX_MODEL_FALLBACKS as Xt, EFFORT_ORDER as Y, DEFAULT_CODEX_MODEL as Yt, bucketEffort as Z, DEFAULT_PORT as Zt, appendPlanReminder as _, scribeModel as _t, buildPeerAwarenessSnippet as a, upstreamMaxConnections as an, browseAgentEnabled as at, resolveWorkerRunOpts as b, shimDefaultsToXhigh as bt, personasFor as c, withOneMSuffixForLead as cn, fleetToolsEnabled as ct, EXPLORE_DEFAULT_MODEL as d, implementerFastModel as dt, generateRandomPort as en, handleMcpPost as et, EXPLORE_DEFAULT_THINKING as f, nativeSubagentModel as ft, TEST_DEFAULT_MODEL as g, scoutModel as gt, REVIEW_DEFAULT_MODEL as h, reviewerModel as ht, buildAgentPrompt as i, upstreamAllowH2 as in, brainstormModel as it, searchWeb as j, parseJsonOrDiagnose as jt, assetFor as k, MAX_RESPONSE_BODY_BYTES as kt, BROWSE_DEFAULT_MODEL as l, withInstallLock as ln, geminiAvailable as lt, PLAN_DEFAULT_MODEL as m, reviewerFastModel as mt, MCP_GROUPS as n, pickClaudeDefault as nn, agentToolsEnabled as nt, buildPeerAwarenessSummary as o, classifyMessagesRoute as on, browserCompoundToolsEnabled as ot, IMPLEMENT_DEFAULT_MODEL as p, resolveGeminiReviewModel as pt, readIteratorWithTimeout as q, BUDGET_SMALL_FAST_SLUG as qt, assertMcpToolSurfaceConsistent as r, resolveLeadSlugArg as rn, artifactToolsEnabled as rt, enumerateInjectedMcpToolNames as s, withOneMSuffix as sn, browserToolsEnabled as st, GROUP_META as t, isBudgetClaudeLead as tn, REVIEW_FAST_DEFAULT_MODEL as tt, DEFAULT_MODEL_CHAIN as u, generalPurposeFastModel as ut, resolveDefaultModel as v, standInToolEnabled as vt, buildToolbeltAwareness as w, assembleResponsesPayload as wt, runWorkerAgent as x, countTokens as xt, resolveModeDefaults as y, workerToolsEnabled as yt, formatThinkingRepairDecline as z, warmTreeSitterPool as zt };
 
-//# sourceMappingURL=peer-mcp-personas-B5Wp6wIn.js.map
+//# sourceMappingURL=peer-mcp-personas-Bd56EmiO.js.map