zidane 7.0.31 → 7.1.1

package/dist/{agent-9gf8ZlBR.js → agent-_xxElOgH.js}

@@ -3,22 +3,22 @@ import { a as documentBlockMarker, c as toolOutputBudgetByteLength, l as toolOut
 import { a as stripLineNumberPrefixes, i as resolveOldString, n as buildContextBreakdown, o as styleReplacementForVia, r as describeVia, t as buildContextSegments } from "./context-segments-BrEsRhA0.js";
 import { n as estimateTokens, r as utf8ByteLength } from "./utils-ngQzYzZD.js";
 import { a as formatDuration, c as previewLine, o as formatTaskStatus, s as formatTaskSummary } from "./format-BF745pLL.js";
+import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-CRE9pw07.js";
 import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./glob-DluQFSw1.js";
 import { i as isOutputExceededMessage } from "./output-cap-C9zukcCj.js";
-import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-BSFQVclW.js";
 import { n as shellQuote, t as alwaysQuote } from "./shell-quote-BmnhZmdM.js";
 import { a as AgentProviderError, d as isAbortLikeError, g as toTypedError, i as AgentLengthResumeExhaustedError, n as AgentBudgetExceededError, p as isTransientTransportError, s as AgentToolPairingError, t as AgentAbortedError, u as errorMessage } from "./errors-DKiMrOKq.js";
 import { i as ARTIFACT_KIND_PATTERN, l as normalizeArtifactInput, o as ARTIFACT_URI_MAX_CHARS, r as ARTIFACT_KINDS, t as ARTIFACTS_METADATA_KEY } from "./artifacts-CV2hUKnL.js";
-import { E as buildCatalog, L as projectUserPaths, O as installAllowedToolsGate, P as validateResourcePathReal, R as findGitRoot, _ as lastLine, a as interpolateShellCommands, b as resolveSubdirRoot, g as fetchInstallSource, h as defaultWhich, k as createSkillActivationState, m as defaultExec, n as resolveSkills, o as stripShellInterpolations, p as InstallSourceError, v as parseInstallSource, y as resolveNpmVersion } from "./skills-PJyiSRCp.js";
+import { E as buildCatalog, L as projectUserPaths, O as installAllowedToolsGate, P as validateResourcePathReal, R as findGitRoot, _ as lastLine, a as interpolateShellCommands, b as resolveSubdirRoot, g as fetchInstallSource, h as defaultWhich, k as createSkillActivationState, m as defaultExec, n as resolveSkills, o as stripShellInterpolations, p as InstallSourceError, v as parseInstallSource, y as resolveNpmVersion } from "./skills-BC3dodWp.js";
 import { n as writeFileAtomicAsync, t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
-import { p as resolveStorageDirs, r as loadAgentPlugin } from "./plugins-B531Tz5b.js";
+import { p as resolveStorageDirs, r as loadAgentPlugin } from "./plugins-gbI7SBA6.js";
 import { r as createLogger, t as consoleSink } from "./logger--C1VQjwJ.js";
 import { t as escapeXml } from "./xml-D5HBhJle.js";
 import { n as reconcileImageMediaType } from "./media-sniff-UKijEaiQ.js";
 import { f as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, n as connectMcpServers, s as nonOwningMcpView } from "./mcp-CgNd-f3F.js";
 import { appendStaticSection, renderSystemForWire } from "./prompt.js";
 import { a as detectTurnInterruption, c as ensureToolResultPairing, l as filterUnresolvedToolUses, m as resolveContentRefsInMessages, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, p as remintDuplicateToolCallIds, s as ensureEndsWithUserMessage } from "./messages-2jcOA_5R.js";
-import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-CVy-2mAy.js";
+import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-BqRP1hS7.js";
 import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { a as settleWithinTimeout, i as resolveTimeoutMs, n as abortableSleep, o as withInactivityTimeout, r as linkAbortSignal, s as withTimeout$1, t as OperationTimeoutError } from "./timeout-CjOG2mea.js";
 import { createRequire } from "node:module";
@@ -26,9 +26,9 @@ import { basename, delimiter, dirname, isAbsolute, join, posix, resolve, sep } f
 import { createHooks } from "hookable";
 import { Buffer } from "node:buffer";
 import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { copyFile, mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
-import { homedir, tmpdir } from "node:os";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/tools/read-state.ts
@@ -3022,7 +3022,14 @@ const KEYBINDING_DEFS = [
 		action: "cancelToolCall",
 		default: "ctrl+k",
 		label: "cancel tool",
-		description: "open the in-flight tool picker to cancel a single tool call without aborting the run (esc still aborts the whole run)",
+		description: "open the in-flight tool picker to cancel a single tool call without aborting the run (abortRun stops the whole run)",
+		group: "Global"
+	},
+	{
+		action: "abortRun",
+		default: "ctrl+escape",
+		label: "abort",
+		description: "abort the run and deny pending approvals (plain esc leaves for the sessions list; rebind if your terminal cannot report ctrl+esc)",
 		group: "Global"
 	},
 	{
@@ -3423,7 +3430,9 @@ function resolveExtensionKeybindings(bindings, raw) {
 }
 /**
 * `true` when `spec` is one of the chords the framework reserves for
-* itself — `escape` (abort / back / exit) and `ctrl+c` (quit). Extensions
+* itself — `escape` (back / exit), `ctrl+escape` (the `abortRun`
+* default — the one built-in that must never be shadowed) and `ctrl+c`
+* (quit). Extensions
 * can never claim these, neither via their declared `default` nor via a
 * user override in `keybindings.json`. Single source of truth shared by
 * `resolveExtensionKeybindings` above and the registration-time refusal
@@ -3433,7 +3442,7 @@ function isReservedExtensionBinding(spec) {
 	const parsed = parseBindingSpec(spec);
 	if (!parsed) return false;
 	const noExtraModifiers = !parsed.shift && !parsed.alt && !parsed.meta;
-	if (parsed.name === "escape" && !parsed.ctrl && noExtraModifiers) return true;
+	if (parsed.name === "escape" && noExtraModifiers) return true;
 	return parsed.name === "c" && parsed.ctrl && noExtraModifiers;
 }
 /**
@@ -7140,11 +7149,19 @@ function applyToolSearchToUnlocked(catalog, input, unlocked, defaultLimit, addUn
 */
 function createToolSearchTool(options) {
 	const defaultLimit = options.defaultLimit ?? DEFAULT_LIMIT;
+	const dispatcher = options.dispatcherName;
 	return {
 		isConcurrencySafe: true,
 		spec: {
 			name: "tool_search",
-			description: "Discover and load schemas for additional tools listed in <searchable_tools>. Tools listed there are advertised by name + description only; their input schemas are not loaded into context until you surface them through this tool. Pass `query` for a substring search, `names` to load specific tools, or `server` to load every tool from one MCP server. Returned tools become callable for the rest of this run.",
+			description: [
+				"Discover and load schemas for additional tools listed in <searchable_tools>.",
+				"Tools listed there are advertised by name + description only; their input",
+				"schemas are not loaded into context until you surface them through this tool.",
+				"Pass `query` for a substring search, `names` to load specific tools, or `server`",
+				"to load every tool from one MCP server.",
+				dispatcher ? `Returned tools become callable through \`${dispatcher}\` (name + arguments) for the rest of this run.` : "Returned tools become callable for the rest of this run."
+			].join(" "),
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -7186,7 +7203,7 @@ function createToolSearchTool(options) {
 			else {
 				for (const entry of shown) parts.push(formatMatch(entry));
 				parts.push("");
-				parts.push("  These tools are now callable. Invoke them by name in subsequent turns.");
+				parts.push(dispatcher ? `  These tools are now callable through \`${dispatcher}\`: pass the tool name as \`name\` and an object matching its schema as \`arguments\`.` : "  These tools are now callable. Invoke them by name in subsequent turns.");
 				if (truncated) parts.push(`  ${total - shown.length} additional matches were truncated; refine the query or raise \`limit\`.`);
 			}
 			if (misses.length > 0) parts.push(`  <misses>${misses.map(escapeXml).join(", ")}</misses>`);
@@ -11698,6 +11715,72 @@ function textForPersistence(output) {
 	return parts.join("\n");
 }
 //#endregion
+//#region src/tools/call-tool.ts
+const CALL_TOOL_NAME = "call_tool";
+/**
+* Unwrap a `call_tool` envelope. `null` when `name` is not the dispatcher or
+* the envelope is malformed (missing / non-string `name`, non-object
+* `arguments`) — callers then treat the call as a plain `call_tool` call and
+* let the dispatcher's own schema validation produce the error the model
+* needs to fix its input.
+*
+* `arguments` may be omitted for zero-argument tools: it defaults to `{}`.
+*/
+function unwrapCallTool(name, input) {
+	if (name !== "call_tool") return null;
+	if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+	const { name: inner, arguments: args } = input;
+	if (typeof inner !== "string" || inner.length === 0) return null;
+	if (args === void 0) return {
+		name: inner,
+		input: {}
+	};
+	if (!args || typeof args !== "object" || Array.isArray(args)) return null;
+	return {
+		name: inner,
+		input: args
+	};
+}
+/**
+* Build the dispatcher ToolDef. The loop rewrites every envelope around a
+* lazy catalog tool into the inner call before dispatch, so `execute` only
+* runs for envelopes it refused: an inner tool that is not a catalog entry
+* (eager tools are called directly, so their history stays scannable by
+* name) or a malformed shape that slipped past schema validation.
+*/
+function createCallToolTool(options = {}) {
+	const discovery = options.discoveryToolName ?? "tool_search";
+	const isDispatchable = options.isDispatchable ?? (() => true);
+	return {
+		isConcurrencySafe: false,
+		spec: {
+			name: CALL_TOOL_NAME,
+			description: `Invoke a tool listed in <searchable_tools>. Load its schema with \`${discovery}\` first (the result shows the exact \`name\` and input schema), then call it here with \`name\` set to that tool name and \`arguments\` set to an object matching its schema. Arguments are validated against the tool's own schema; a validation error names the offending field.`,
+			inputSchema: {
+				type: "object",
+				properties: {
+					name: {
+						type: "string",
+						description: "Tool name exactly as shown in <searchable_tools> / the tool_search result."
+					},
+					arguments: {
+						type: "object",
+						description: "Input for the tool, matching its schema. Omit for zero-argument tools.",
+						additionalProperties: true
+					}
+				},
+				required: ["name"],
+				additionalProperties: false
+			}
+		},
+		async execute(input) {
+			const target = input.name;
+			if (typeof target === "string" && target.length > 0 && !isDispatchable(target)) throw new Error(`call_tool: "${target}" is not listed in <searchable_tools>. Call it directly by name if it is one of your tools; call_tool is only for surfaced catalog tools.`);
+			throw new Error(`call_tool: malformed envelope for ${typeof target === "string" ? `"${target}"` : "unknown tool"}: expected \`name\` (string) and optional \`arguments\` (object).`);
+		}
+	};
+}
+//#endregion
 //#region src/loop.ts
 const DEFAULT_PROVIDER_STREAM_START_TIMEOUT_MS = 300 * 1e3;
 const DEFAULT_PROVIDER_STREAM_TIMEOUT_MS = 1800 * 1e3;
@@ -11899,8 +11982,12 @@ function executionBlobWriter(ctx) {
 * the per-turn `turnId` tags that the TUI's select-turn mode relies on.
 *
 * Pure: a fresh array is returned only when a marker is found. Input
-* turns are never mutated; the synthetic markers are the only new
-* `SessionTurn`s allocated.
+* turns are never mutated. New `SessionTurn`s allocated: the synthetic
+* markers, plus a copy of every preserved assistant turn older than the
+* newest marker whose replayable thinking was stripped (see
+* {@link withoutReplayedThinking}). The output is WIRE-shaped, not
+* display-shaped: hosts rendering a transcript should read the session
+* turns, not this view.
 */
 /**
 * Recover the auto-compaction hysteresis baseline from a resumed session.
@@ -11962,17 +12049,68 @@ function applyCompactSummaryCutoff(turns) {
 			...m.turn.runId ? { runId: m.turn.runId } : {}
 		});
 	}
+	const newestMarkerIdx = markers[markers.length - 1].idx;
+	const stripBound = preservedChainStart(turns, newestMarkerIdx);
 	const out = [];
 	for (let i = 0; i < turns.length; i++) {
 		const synthetic = syntheticAt.get(i);
 		if (synthetic) out.push(synthetic);
 		if (markerIdxSet.has(i)) continue;
 		if (replacedAll.has(turns[i].id)) continue;
-		out.push(turns[i]);
+		out.push(i < stripBound ? withoutReplayedThinking(turns[i]) : turns[i]);
 	}
 	return out;
 }
 /**
+* Strip bound for the preserved tail behind the marker at `markerIdx`: the
+* index below which pre-marker assistant turns lose their replayed thinking.
+*
+* Reads the turn immediately before the marker to tell whether a tool loop
+* was in flight when compaction fired. A `tool_result`-only user turn (or an
+* assistant turn still holding a `tool_call`) means the marker landed mid
+* loop: the bound retreats to that chain's start — the last user turn before
+* the marker carrying real, non-`tool_result` content (`compact-summary`
+* turns render as user text but are not prompts) — so the assistant turn
+* whose `tool_use` the loop is still answering keeps its thinking. Any other
+* neighbour (a text-only assistant answer, a bare prompt) means the run had
+* settled and everything before the marker is strippable. Depends only on
+* turns before the marker, so it is stable across later requests.
+*/
+function preservedChainStart(turns, markerIdx) {
+	const before = turns[markerIdx - 1];
+	if (!(before !== void 0 && (before.role === "user" && before.content.length > 0 && before.content.every((block) => block.type === "tool_result") || before.role === "assistant" && before.content.some((block) => block.type === "tool_call")))) return markerIdx;
+	for (let i = markerIdx - 1; i >= 0; i--) {
+		const turn = turns[i];
+		if (turn.role !== "user") continue;
+		if (turn.content.some((block) => block.type === "compact-summary")) continue;
+		if (turn.content.some((block) => block.type !== "tool_result")) return i;
+	}
+	return markerIdx;
+}
+/**
+* Copy of `turn` with prefix-bound reasoning removed: `redacted_thinking`,
+* and SIGNED `thinking` blocks not produced by an OpenAI-family provider
+* (whose encrypted reasoning is bound per item, not per prefix). Unsigned
+* thinking is left alone — it is what `reasoning_content`-style OpenAI-compat
+* providers (vLLM, DeepSeek, Arcee) echo back, and `toAnthropic` already
+* drops it on the Anthropic wire. Same predicate as the provider's
+* signature scrub. Returns the input object when nothing is removed so
+* identity-based callers see no churn. A reasoning-only turn keeps a
+* placeholder so the assistant message stays non-empty on the wire.
+*/
+function withoutReplayedThinking(turn) {
+	if (turn.role !== "assistant") return turn;
+	const kept = turn.content.filter((block) => block.type !== "redacted_thinking" && !(block.type === "thinking" && !!block.signature && block.signatureProducer !== "openai"));
+	if (kept.length === turn.content.length) return turn;
+	return {
+		...turn,
+		content: kept.length > 0 ? kept : [{
+			type: "text",
+			text: "[historical reasoning omitted]"
+		}]
+	};
+}
+/**
 * Flatten image blocks inside previously-stored `tool_result` outputs to text
 * markers when the provider reports no vision capability. This handles the
 * session-resume / mid-session-provider-switch case:
@@ -11990,6 +12128,56 @@ function applyCompactSummaryCutoff(turns) {
 */
 const COMPACTION_STUB = "[…elided: older tool output trimmed to fit the context budget.]";
 const COMPACTION_STUB_BYTES = toolOutputByteLength(COMPACTION_STUB);
+/** Byte threshold tail compaction falls back to when `compactThreshold` is unset. */
+const DEFAULT_COMPACT_THRESHOLD_BYTES = 131072;
+/**
+* Effective byte threshold for client-side compaction (`'tail'` and the
+* `CompactFunction` path): the host's `compactThreshold` (default 128 KiB),
+* raised to `compactThresholdWindowFraction × contextWindow × BYTES_PER_TOKEN`
+* when both are known. Every frontier step re-bills the whole suffix at the
+* cache-write rate, so on large-context models the byte threshold alone
+* trips far too early; see `AgentBehavior.compactThresholdWindowFraction`.
+* Pure — exported for host-behavior tests.
+*/
+function resolveTailCompactionThreshold(behavior, contextWindow) {
+	const base = typeof behavior.compactThreshold === "number" && behavior.compactThreshold > 0 ? behavior.compactThreshold : DEFAULT_COMPACT_THRESHOLD_BYTES;
+	const fraction = behavior.compactThresholdWindowFraction;
+	if (typeof fraction !== "number" || !(fraction > 0) || typeof contextWindow !== "number" || !(contextWindow > 0)) return base;
+	return Math.max(base, Math.floor(fraction * contextWindow * 4));
+}
+/**
+* Context window (tokens) of the model currently serving the run, for
+* window-relative wire budgets.
+*
+* On the primary target the host's explicit `behavior.contextWindow` (chat
+* hosts inject the picked model's window every run) wins, then the resolved
+* autocompact window, the primary {@link ModelTarget}'s window, and the
+* provider's advertised `meta.contextWindow`. Once the run has advanced down
+* the fallback chain, `behavior.contextWindow` describes the model that just
+* FAILED (1M Fable → 200k Sonnet is the realistic shape), so the active
+* target's own window and the re-based autocompact window take precedence
+* and the stale behavior value is only a last resort before provider meta.
+* `null` when nothing knows.
+*/
+function activeContextWindow(ctx) {
+	const positive = (n) => typeof n === "number" && n > 0 ? n : null;
+	const advanced = (ctx.activeTargetIndex ?? 0) > 0;
+	const target = ctx.targets?.[ctx.activeTargetIndex ?? 0];
+	const ordered = advanced ? [
+		target?.contextWindow,
+		ctx.autoCompact?.contextWindow,
+		ctx.behavior.contextWindow
+	] : [
+		ctx.behavior.contextWindow,
+		ctx.autoCompact?.contextWindow,
+		target?.contextWindow
+	];
+	for (const candidate of ordered) {
+		const n = positive(candidate);
+		if (n !== null) return n;
+	}
+	return positive(ctx.provider.meta.contextWindow);
+}
 /**
 * Cross-turn memo for `toolOutputBudgetByteLength`, keyed on the tool_result
 * block object. The wire pipeline preserves block references for unchanged
@@ -12873,7 +13061,7 @@ async function enforceSchemaOutput(ctx, turnId) {
 		description: "Return the final structured output matching the required schema.",
 		inputSchema: ctx.behavior.schema
 	};
-	const schemaMessages = ensureEndsWithUserMessage(applyPairingRepair(ctx, rewriteMessagesToWire(await resolveContentRefsForWire(ctx, turnsToMessages(applyCompactSummaryCutoff(ctx.turns))), ctx.aliasMaps), turnId), ctx.provider);
+	const schemaMessages = ensureEndsWithUserMessage(applyPairingRepair(ctx, rewriteMessagesToWire(await resolveContentRefsForWire(ctx, turnsToMessages(applyCompactSummaryCutoff(ctx.turns)).map(withoutReplayedThinking)), ctx.aliasMaps), turnId), ctx.provider);
 	let schemaResult;
 	try {
 		schemaResult = await streamWithWatchdogs(ctx, {
@@ -13097,6 +13285,7 @@ async function streamWithWatchdogs(ctx, options, callbacks, turnId, opts) {
 	if (opts?.startTimeoutCapMs !== void 0 && startTimeoutMs > 0) startTimeoutMs = Math.min(startTimeoutMs, opts.startTimeoutCapMs);
 	const callerHistoryRepair = callbacks.onHistoryRepair;
 	let pendingRepair;
+	const callerInputTransformations = callbacks.onInputTransformations;
 	callbacks = {
 		...callbacks,
 		onDiagnostic(event) {
@@ -13106,6 +13295,20 @@ async function streamWithWatchdogs(ctx, options, callbacks, turnId, opts) {
 				turnId
 			})).catch(() => {});
 		},
+		onInputTransformations(transformations) {
+			try {
+				callerInputTransformations?.(transformations);
+			} catch {}
+			const info = {
+				runId: ctx.runId,
+				turnId,
+				...ctx.session?.id ? { sessionId: ctx.session.id } : {},
+				transformations,
+				prefixMismatches: transformations.filter((t) => t.reason === "prefix_binding_mismatch").length,
+				modelMismatches: transformations.filter((t) => t.reason === "model_binding_mismatch").length
+			};
+			Promise.resolve(ctx.hooks.callHook("provider:input-transformations", info)).catch(() => {});
+		},
 		async onHistoryRepair(repair) {
 			if (repair.type === "invalid-anthropic-thinking-signature") {
 				const result = repairInvalidAnthropicThinkingHistory(ctx, options, repair);
@@ -13601,7 +13804,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 	let callMapsMemo;
 	const callMaps = () => callMapsMemo ??= collectCallMaps(canonicalMessages);
 	if (ctx.behavior.compactStrategy === "tail") {
-		const threshold = typeof ctx.behavior.compactThreshold === "number" && ctx.behavior.compactThreshold > 0 ? ctx.behavior.compactThreshold : 131072;
+		const threshold = resolveTailCompactionThreshold(ctx.behavior, activeContextWindow(ctx));
 		const keep = typeof ctx.behavior.compactKeepTurns === "number" && ctx.behavior.compactKeepTurns >= 0 ? ctx.behavior.compactKeepTurns : 4;
 		const { readPathByCallId, toolNameByCallId } = callMaps();
 		const compacted = applyTailCompaction(sanitizedMessages, threshold, keep, {
@@ -13618,7 +13821,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			writeBlob: executionBlobWriter(ctx)
 		});
 	} else if (typeof ctx.behavior.compactStrategy === "function") {
-		const threshold = typeof ctx.behavior.compactThreshold === "number" && ctx.behavior.compactThreshold > 0 ? ctx.behavior.compactThreshold : 131072;
+		const threshold = resolveTailCompactionThreshold(ctx.behavior, activeContextWindow(ctx));
 		const keep = typeof ctx.behavior.compactKeepTurns === "number" && ctx.behavior.compactKeepTurns >= 0 ? ctx.behavior.compactKeepTurns : 4;
 		let totalBytes = 0;
 		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += memoizedToolResultBudgetBytes(block);
@@ -13989,6 +14192,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			})).catch(() => {});
 		}
 	}
+	canonicalToolCalls = unwrapDispatchCalls(ctx, canonicalToolCalls);
 	if (turnTtftMs !== void 0 && result.usage.timeToFirstTokenMs === void 0) result.usage.timeToFirstTokenMs = turnTtftMs;
 	if (result.usage.streamDurationMs === void 0) result.usage.streamDurationMs = Date.now() - streamStartedAt;
 	const assistantTurn = {
@@ -14290,6 +14494,31 @@ async function commitToolState(ctx, callId, toolName) {
 		if (!hookCtx.handled) console.error(`[zidane] tool state commit for ${toolName} (${callId}) failed; the write did NOT land, continuing:`, error);
 	}
 }
+/**
+* Rewrite every well-formed `call_tool` envelope around a lazy catalog tool
+* into the inner call it carries (same `id`, inner wire name → canonical,
+* `arguments` → `input`). No-op unless the run is in dispatch mode
+* ({@link LoopContext.dispatcher}). Left as a `call_tool` call, so the
+* dispatcher itself answers: a malformed envelope (its schema validation
+* reports the shape error) and an inner name outside the catalog (its
+* `execute` says to call the tool directly, or that it does not exist).
+*/
+function unwrapDispatchCalls(ctx, calls) {
+	const dispatcher = ctx.dispatcher;
+	if (!dispatcher) return calls.slice();
+	return calls.map((call) => {
+		if (call.name !== dispatcher.name) return call;
+		const inner = unwrapCallTool(call.name, call.input);
+		if (!inner) return call;
+		const canonical = toCanonicalName(inner.name, ctx.aliasMaps);
+		if (!dispatcher.targets.has(canonical)) return call;
+		return {
+			...call,
+			name: canonical,
+			input: inner.input
+		};
+	});
+}
 async function executeSingleTool(ctx, call, turnId) {
 	const toolDef = ctx.tools[call.name];
 	const callId = call.id;
@@ -15908,6 +16137,7 @@ const HOOK_EVENT_SET = /* @__PURE__ */ new Set([
 	"compact:progress",
 	"compact:end",
 	"history:repair",
+	"provider:input-transformations",
 	"oauth:refresh",
 	"provider:diagnostic",
 	"content-ref:resolve",
@@ -16090,6 +16320,8 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		readFileDefaults: runBehavior?.readFileDefaults ?? agentBehavior?.readFileDefaults,
 		compactStrategy: runBehavior?.compactStrategy ?? agentBehavior?.compactStrategy ?? "off",
 		compactThreshold: runBehavior?.compactThreshold ?? agentBehavior?.compactThreshold,
+		compactThresholdWindowFraction: runBehavior?.compactThresholdWindowFraction ?? agentBehavior?.compactThresholdWindowFraction,
+		contextWindow: runBehavior?.contextWindow ?? agentBehavior?.contextWindow,
 		compactKeepTurns: runBehavior?.compactKeepTurns ?? agentBehavior?.compactKeepTurns,
 		thinkingDecay: runBehavior?.thinkingDecay ?? agentBehavior?.thinkingDecay,
 		writeFileExistingPolicy: runBehavior?.writeFileExistingPolicy ?? agentBehavior?.writeFileExistingPolicy,
@@ -16318,6 +16550,16 @@ function buildMcpToolNameSeparatorAliases(mcpToolNames, servers, separator) {
 	return Object.keys(aliases).length > 0 ? aliases : void 0;
 }
 /**
+* Resolve the effective `toolSearch.mode`. An explicit host value always
+* wins. When unset, Anthropic-family providers default to `'dispatch'`
+* (see {@link DisclosureStateInput.providerName}); everyone else keeps
+* `'unlock'`, whose only cost there is a prompt-cache rewrite per wave.
+*/
+function resolveToolSearchMode(toolSearch, providerName) {
+	if (toolSearch?.mode !== void 0) return toolSearch.mode;
+	return providerName === "anthropic" ? "dispatch" : "unlock";
+}
+/**
 * Partition the registry into eager vs lazy buckets and build the per-run
 * unlock bookkeeping the loop reads when rebuilding the wire-level tool list.
 *
@@ -16332,7 +16574,8 @@ function buildMcpToolNameSeparatorAliases(mcpToolNames, servers, separator) {
 * dispatch-map lookup.
 */
 function buildRunDisclosureState(input) {
-	const { tools: baseTools, mcpToolNames, mcpServers, toolDisclosure, toolSearch, toolAliases, hasRunToolOverride } = input;
+	const { tools: baseTools, mcpToolNames, mcpServers, toolDisclosure, toolSearch, toolAliases, hasRunToolOverride, providerName } = input;
+	const toolSearchMode = resolveToolSearchMode(toolSearch, providerName);
 	const disclosure = partitionToolDisclosure(baseTools, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
 	const unlocked = new Set(disclosure.eagerCanonicalNames);
 	const initialUnlocked = new Set(disclosure.eagerCanonicalNames);
@@ -16347,13 +16590,15 @@ function buildRunDisclosureState(input) {
 	};
 	const hostDefinedToolSearch = !!baseTools.tool_search;
 	const injectedToolSearch = !hasRunToolOverride && (toolDisclosure === "lazy" || disclosure.lazyEntries.length > 0) && toolSearch?.tool !== false && !hostDefinedToolSearch;
+	const dispatchMode = injectedToolSearch && toolSearchMode === "dispatch" && disclosure.lazyEntries.length > 0 && !baseTools["call_tool"];
 	let tools = baseTools;
 	if (injectedToolSearch) {
 		const toolSearchTool = createToolSearchTool({
 			catalog: disclosure.lazyEntries,
 			unlocked,
 			addUnlock: recordUnlock,
-			...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
+			...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {},
+			...dispatchMode ? { dispatcherName: CALL_TOOL_NAME } : {}
 		});
 		tools = {
 			...baseTools,
@@ -16361,6 +16606,19 @@ function buildRunDisclosureState(input) {
 		};
 		unlocked.add(toolSearchTool.spec.name);
 		initialUnlocked.add(toolSearchTool.spec.name);
+		if (dispatchMode) {
+			const lazyWireNames = new Set(disclosure.lazyEntries.map((entry) => entry.name));
+			const callTool = createCallToolTool({
+				discoveryToolName: toolSearchTool.spec.name,
+				isDispatchable: (name) => lazyWireNames.has(name)
+			});
+			tools = {
+				...tools,
+				[CALL_TOOL_NAME]: callTool
+			};
+			unlocked.add(CALL_TOOL_NAME);
+			initialUnlocked.add(CALL_TOOL_NAME);
+		}
 	}
 	return {
 		disclosure,
@@ -16370,7 +16628,8 @@ function buildRunDisclosureState(input) {
 		recordUnlock,
 		tools,
 		injectedToolSearch,
-		hostDefinedToolSearch
+		hostDefinedToolSearch,
+		dispatchMode
 	};
 }
 /**
@@ -16631,7 +16890,11 @@ function buildSearchableCatalog(entries, options) {
 	}
 	const serverNames = [...byServer.keys()].sort();
 	const parts = [];
-	if (options.discoveryToolName) parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas for any tool below that you have not already surfaced. Surfaced tools persist for the rest of the run.`, "");
+	if (options.discoveryToolName) {
+		parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas for any tool below that you have not already surfaced. Surfaced tools persist for the rest of the run.`);
+		if (options.dispatcherName) parts.push(`Surfaced tools are invoked through \`${options.dispatcherName}\` with \`name\` set to the tool name and \`arguments\` matching the loaded schema; they are never added to your tool list directly.`);
+		parts.push("");
+	}
 	parts.push("<searchable_tools>");
 	for (const server of serverNames) {
 		parts.push(`  <server name="${escapeXml(server)}">`);
@@ -16655,14 +16918,15 @@ function buildSearchableCatalog(entries, options) {
 * Returns an uninstall function the run-end teardown calls so handlers
 * never leak across runs.
 */
-function installLazyDisclosureGate(hooks, lazyCanonicalNames, unlocked, discoveryToolName) {
+function installLazyDisclosureGate(hooks, lazyCanonicalNames, unlocked, discoveryToolName, dispatcherName) {
 	if (lazyCanonicalNames.size === 0) return () => {};
 	return hooks.hook("tool:gate", (ctx) => {
 		if (ctx.block) return;
 		if (!lazyCanonicalNames.has(ctx.name)) return;
 		if (unlocked.has(ctx.name)) return;
 		ctx.block = true;
-		ctx.reason = discoveryToolName ? `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded. Call the \`${discoveryToolName}\` tool with names: ["${ctx.name}"] first, then re-issue the call.` : `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded.`;
+		const reissue = dispatcherName ? `re-issue the call through \`${dispatcherName}\`` : "re-issue the call";
+		ctx.reason = discoveryToolName ? `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded. Call the \`${discoveryToolName}\` tool with names: ["${ctx.name}"] first, then ${reissue}.` : `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded.`;
 	});
 }
 /**
@@ -17267,19 +17531,23 @@ function createAgent(rawOptions) {
 				executionContext,
 				behavior: resolvedBehavior
 			});
-			const { disclosure, unlocked, initialUnlocked, dynamicUnlockOrder, recordUnlock: recordDynamicUnlock, tools, injectedToolSearch: shouldInjectToolSearch, hostDefinedToolSearch } = buildRunDisclosureState({
+			const { disclosure, unlocked, initialUnlocked, dynamicUnlockOrder, recordUnlock: recordDynamicUnlock, tools, injectedToolSearch: shouldInjectToolSearch, hostDefinedToolSearch, dispatchMode } = buildRunDisclosureState({
 				tools: toolsPreSearch,
 				mcpToolNames,
 				mcpServers,
 				toolDisclosure,
 				toolSearch,
 				toolAliases: effectiveToolAliases,
-				hasRunToolOverride: options.tools !== void 0
+				hasRunToolOverride: options.tools !== void 0,
+				providerName: runProvider.name
 			});
 			const discoveryToolName = shouldInjectToolSearch ? "tool_search" : hostDefinedToolSearch ? effectiveToolAliases?.tool_search ?? "tool_search" : null;
 			let searchableCatalogText;
 			if (disclosure.lazyEntries.length > 0) {
-				searchableCatalogText = buildSearchableCatalog(disclosure.lazyEntries, { discoveryToolName });
+				searchableCatalogText = buildSearchableCatalog(disclosure.lazyEntries, {
+					discoveryToolName,
+					...dispatchMode ? { dispatcherName: CALL_TOOL_NAME } : {}
+				});
 				system = appendStaticSection(system, searchableCatalogText);
 			}
 			if (surfaceMcpInstructions && mcpConnection?.instructions && mcpConnection.instructions.size > 0) {
@@ -17288,10 +17556,11 @@ function createAgent(rawOptions) {
 			}
 			const aliasMaps = buildAliasMaps(effectiveToolAliases, Object.keys(tools));
 			augmentMcpDoubleUnderscoreAliases(aliasMaps, Object.keys(tools));
+			const wireTailLength = () => dispatchMode ? 0 : dynamicUnlockOrder.length;
 			const formattedToolsCache = /* @__PURE__ */ new Map();
 			function buildFormattedTools(forProvider = runProvider) {
 				const cached = formattedToolsCache.get(forProvider);
-				if (cached && cached.tailLen === dynamicUnlockOrder.length) return cached.value;
+				if (cached && cached.tailLen === wireTailLength()) return cached.value;
 				const specs = [];
 				for (const t of Object.values(tools)) {
 					if (!initialUnlocked.has(t.spec.name)) continue;
@@ -17301,7 +17570,7 @@ function createAgent(rawOptions) {
 						inputSchema: t.spec.inputSchema
 					});
 				}
-				for (const canonical of dynamicUnlockOrder) {
+				for (const canonical of dispatchMode ? [] : dynamicUnlockOrder) {
 					const t = tools[canonical];
 					if (!t) continue;
 					specs.push({
@@ -17312,7 +17581,7 @@ function createAgent(rawOptions) {
 				}
 				const value = specs.length > 0 ? forProvider.formatTools(specs) : [];
 				formattedToolsCache.set(forProvider, {
-					tailLen: dynamicUnlockOrder.length,
+					tailLen: wireTailLength(),
 					value
 				});
 				return value;
@@ -17321,13 +17590,14 @@ function createAgent(rawOptions) {
 			function advertisedToolNames() {
 				const names = [];
 				for (const t of Object.values(tools)) if (initialUnlocked.has(t.spec.name)) names.push(toWireName(t.spec.name, aliasMaps));
-				for (const canonical of dynamicUnlockOrder) if (tools[canonical]) names.push(toWireName(canonical, aliasMaps));
+				for (const canonical of dispatchMode ? [] : dynamicUnlockOrder) if (tools[canonical]) names.push(toWireName(canonical, aliasMaps));
 				return names;
 			}
 			{
 				const disclosedTools = [];
+				const onWire = dispatchMode ? initialUnlocked : unlocked;
 				for (const t of Object.values(tools)) {
-					if (!unlocked.has(t.spec.name)) continue;
+					if (!onWire.has(t.spec.name)) continue;
 					const wireName = aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name;
 					disclosedTools.push({
 						name: wireName,
@@ -17512,7 +17782,7 @@ function createAgent(rawOptions) {
 				recordUnlock: recordDynamicUnlock,
 				defaultLimit: toolSearch?.limit
 			}));
-			perRunUnregisters.push(installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName));
+			perRunUnregisters.push(installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName, dispatchMode ? CALL_TOOL_NAME : void 0));
 			perRunUnregisters.push(installReadBeforeEditHydrationGate(hooks, resolvedBehavior.requireReadBeforeEdit === true, {
 				session: session ?? void 0,
 				getHandle: () => executionHandle,
@@ -17642,6 +17912,10 @@ function createAgent(rawOptions) {
 					tools,
 					formattedTools,
 					rebuildFormattedTools: buildFormattedTools,
+					...dispatchMode ? { dispatcher: {
+						name: CALL_TOOL_NAME,
+						targets: disclosure.lazyCanonicalNames
+					} } : {},
 					aliasMaps,
 					model,
 					system,
@@ -18196,6 +18470,6 @@ function createAgent(rawOptions) {
 	};
 }
 //#endregion
-export { installExtensionFromSpec as $, defaultRepeatGuardNormalize as $n, KEYBINDING_DEF_BY_ACTION as $t, selectFilesFromSession as A, resolveExtensionConfig as An, createSkillsRunScriptTool as At, buildUpToCompactPrompt as B, commitKind as Bn, formatModelLine as Bt, resolveLegacySessionDir as C, createDebugLog as Cn, WAIT_TASK_TIMED_OUT_PREFIX as Ct, resolveTasksDir as D, coerceExtensionConfigInput as Dn, isSpawnTool as Dt, resolveSessionDir as E, clampExtensionConfigNumber as En, createSpawnTool as Et, TRAILER as F, createExtensionBus as Fn, tailTruncate as Ft, summaryToTurn as G, refreshArtifact as Gn, glob as Gt, anchorPreviewFor as H, githubTokenSource as Hn, listFiles as Ht, buildCompactPrompt as I, serializedPayloadBytes as In, readFile$1 as It, CompactPromptTooLongError as J, createArtifactDetectHook as Jn, artifacts_default as Jt, truncateHeadForPtlRetry as K, renderArtifactRow as Kn, edit as Kt, buildFromCompactPrompt as L, BUILTIN_ARTIFACT_KINDS as Ln, looksBinary as Lt, compactConversation as M, sanitizeExtensionConfigActionPatch as Mn, shellKill as Mt, BASE_INSTRUCTIONS as N, toWireConfigSchema as Nn, createShellTool as Nt, buildPostCompactAttachments as O, isValidExtensionConfigItem as On, reserveChildLabel as Ot, NO_TOOLS_PREAMBLE as P, EXTENSION_BUS_MAX_PAYLOAD_BYTES as Pn, shell as Pt, fetchExtensionSource as Q, shouldAutoCompact as Qn, KEYBINDING_DEFS as Qt, buildFullCompactPrompt as R, artifactKindLabel as Rn, multiEdit as Rt, resolveLegacyPersistDir as S, scanExtensionDirectories as Sn, writeFile$1 as St, resolvePersistDir as T, defineExtension as Tn, createToolSearchTool as Tt, sliceForCompaction as U, parseShortstat as Un, createInteractionTool as Ut, ANCHOR_PREVIEW_MAX_CHARS as V, fileKind as Vn, matchModelEntries as Vt, stripImagesFromTurns as W, pullRequestKind as Wn, grep as Wt, createExtensionPromptBridge as X, OUTPUT_RESERVE_TOKENS as Xn, recordArtifact as Xt, EMPTY_EXTENSION_REGISTRY as Y, AUTO_COMPACT_MIN_GROWTH_FRACTION as Yn, RECORD_ARTIFACT_TOOL as Yt, ExtensionInstallError as Z, effectiveContextWindow as Zn, DEFAULT_KEYBINDINGS as Zt, buildPersistedStub as _, defaultExtensionScanPaths as _n, createWorkspaceSurface as _t, stagedToolState as a, matchesBinding as an, hydrateReadStateFromSession as ar, createExtensionHud as at, migrateSessionArtifactDirs as b, isExtensionDefinition as bn, basicTools as bt, INTERRUPT_MESSAGE_FOR_TOOL_USE as c, readKeybindings as cn, resolveReadStateMap as cr, buildExtensionRegistry as ct, TOOL_USE_SKIPPED_MESSAGE as d, stripJsonComments as dn, filterExtensionRegistry as dt, KEYBINDING_KEY_COL_WIDTH as en, defaultRepeatGuardTracked as er, listExtensionCandidates as et, applyCompactSummaryCutoff as f, ALTERNATE_CRED_KEY_SUFFIX as fn, filterRegistryPlugins as ft, PERSISTENCE_PREVIEW_BYTES as g, ENTRY_CANDIDATES as gn, createExtensionHostRuntimeBridge as gt, PERSISTED_STUB_PREFIX as h, registerExtensionHostModules as hn, createArtifactsSurface as ht, isToolStateOps as i, keybindingsPath as in, hashContent as ir, updateInstalledExtension as it, selectRecentFiles as j, resolveExtensionConfigValue as jn, createSkillsReadTool as jt, selectFilesFromReadState as k, isValidExtensionConfigValue as kn, createSkillsUseTool as kt, SHELL_CASCADE_CANCEL_MESSAGE as l, readKeybindingsRaw as ln, composeExtensionPreset as lt, renderStaleReadNotice as m, isReservedCredKey as mn, partitionExtensionCatalog as mt, DEFAULT_MAX_VALUE_BYTES as n, formatBindingForDisplay as nn, stableStringify as nr, readExtensionInstallProvenance as nt, normalizeProviders as o, mergeKeybindings as on, hydrateReadStateFromSessionAsync as or, discoverAndBuildExtensionRegistry as ot, collectNewlyStaleReadPaths as p, alternateCredKey as pn, mergeContributions as pt, CompactInvalidInputError as q, resolveArtifactKind as qn, validateToolArgs as qt, createToolStateController as r, groupBindings as rn, getReadState as rr, removeInstalledExtension as rt, resolveModelTargets as s, parseBindingSpec as sn, readStateKey as sr, buildExtensionPreset as st, createAgent as t, ensureKeybindingsFile as tn, normalizeShellCommand as tr, parseExtensionInstallSource as tt, TOOL_USE_CANCELLED_MESSAGE as u, resolveExtensionKeybindings as un, disposeExtensionRegistry as ut, cleanupPersistedSession as v, discoverExtensions as vn, composePresets as vt, resolveMcpWarningsDir as w, setDebugLogSink as wn, waitTask as wt, rehomePersistedStubs as x, parseExtensionScanPathEnv as xn, basic_default as xt, maybePersistToolResult as y, inlineLoadedExtension as yn, definePreset as yt, buildTailCompactPrompt as z, branchKind as zn, createModelSearchTool as zt };
+export { ExtensionInstallError as $, effectiveContextWindow as $n, DEFAULT_KEYBINDINGS as $t, buildPostCompactAttachments as A, isValidExtensionConfigItem as An, reserveChildLabel as At, buildFullCompactPrompt as B, artifactKindLabel as Bn, multiEdit as Bt, rehomePersistedStubs as C, parseExtensionScanPathEnv as Cn, basic_default as Ct, resolvePersistDir as D, defineExtension as Dn, createToolSearchTool as Dt, resolveMcpWarningsDir as E, setDebugLogSink as En, waitTask as Et, BASE_INSTRUCTIONS as F, toWireConfigSchema as Fn, createShellTool as Ft, sliceForCompaction as G, parseShortstat as Gn, createInteractionTool as Gt, buildUpToCompactPrompt as H, commitKind as Hn, formatModelLine as Ht, NO_TOOLS_PREAMBLE as I, EXTENSION_BUS_MAX_PAYLOAD_BYTES as In, shell as It, truncateHeadForPtlRetry as J, renderArtifactRow as Jn, edit as Jt, stripImagesFromTurns as K, pullRequestKind as Kn, grep as Kt, TRAILER as L, createExtensionBus as Ln, tailTruncate as Lt, selectFilesFromSession as M, resolveExtensionConfig as Mn, createSkillsRunScriptTool as Mt, selectRecentFiles as N, resolveExtensionConfigValue as Nn, createSkillsReadTool as Nt, resolveSessionDir as O, clampExtensionConfigNumber as On, createSpawnTool as Ot, compactConversation as P, sanitizeExtensionConfigActionPatch as Pn, shellKill as Pt, createExtensionPromptBridge as Q, OUTPUT_RESERVE_TOKENS as Qn, recordArtifact as Qt, buildCompactPrompt as R, serializedPayloadBytes as Rn, readFile$1 as Rt, migrateSessionArtifactDirs as S, isExtensionDefinition as Sn, basicTools as St, resolveLegacySessionDir as T, createDebugLog as Tn, WAIT_TASK_TIMED_OUT_PREFIX as Tt, ANCHOR_PREVIEW_MAX_CHARS as U, fileKind as Un, matchModelEntries as Ut, buildTailCompactPrompt as V, branchKind as Vn, createModelSearchTool as Vt, anchorPreviewFor as W, githubTokenSource as Wn, listFiles as Wt, CompactPromptTooLongError as X, createArtifactDetectHook as Xn, artifacts_default as Xt, CompactInvalidInputError as Y, resolveArtifactKind as Yn, validateToolArgs as Yt, EMPTY_EXTENSION_REGISTRY as Z, AUTO_COMPACT_MIN_GROWTH_FRACTION as Zn, RECORD_ARTIFACT_TOOL as Zt, PERSISTED_STUB_PREFIX as _, registerExtensionHostModules as _n, createArtifactsSurface as _t, stagedToolState as a, groupBindings as an, getReadState as ar, removeInstalledExtension as at, cleanupPersistedSession as b, discoverExtensions as bn, composePresets as bt, INTERRUPT_MESSAGE_FOR_TOOL_USE as c, mergeKeybindings as cn, hydrateReadStateFromSessionAsync as cr, discoverAndBuildExtensionRegistry as ct, TOOL_USE_SKIPPED_MESSAGE as d, readKeybindingsRaw as dn, composeExtensionPreset as dt, KEYBINDING_DEFS as en, shouldAutoCompact as er, fetchExtensionSource as et, applyCompactSummaryCutoff as f, resolveExtensionKeybindings as fn, disposeExtensionRegistry as ft, unwrapCallTool as g, isReservedCredKey as gn, partitionExtensionCatalog as gt, CALL_TOOL_NAME as h, alternateCredKey as hn, mergeContributions as ht, isToolStateOps as i, formatBindingForDisplay as in, stableStringify as ir, readExtensionInstallProvenance as it, selectFilesFromReadState as j, isValidExtensionConfigValue as jn, createSkillsUseTool as jt, resolveTasksDir as k, coerceExtensionConfigInput as kn, isSpawnTool as kt, SHELL_CASCADE_CANCEL_MESSAGE as l, parseBindingSpec as ln, readStateKey as lr, buildExtensionPreset as lt, renderStaleReadNotice as m, ALTERNATE_CRED_KEY_SUFFIX as mn, filterRegistryPlugins as mt, DEFAULT_MAX_VALUE_BYTES as n, KEYBINDING_KEY_COL_WIDTH as nn, defaultRepeatGuardTracked as nr, listExtensionCandidates as nt, normalizeProviders as o, keybindingsPath as on, hashContent as or, updateInstalledExtension as ot, collectNewlyStaleReadPaths as p, stripJsonComments as pn, filterExtensionRegistry as pt, summaryToTurn as q, refreshArtifact as qn, glob as qt, createToolStateController as r, ensureKeybindingsFile as rn, normalizeShellCommand as rr, parseExtensionInstallSource as rt, resolveModelTargets as s, matchesBinding as sn, hydrateReadStateFromSession as sr, createExtensionHud as st, createAgent as t, KEYBINDING_DEF_BY_ACTION as tn, defaultRepeatGuardNormalize as tr, installExtensionFromSpec as tt, TOOL_USE_CANCELLED_MESSAGE as u, readKeybindings as un, resolveReadStateMap as ur, buildExtensionRegistry as ut, PERSISTENCE_PREVIEW_BYTES as v, ENTRY_CANDIDATES as vn, createExtensionHostRuntimeBridge as vt, resolveLegacyPersistDir as w, scanExtensionDirectories as wn, writeFile$1 as wt, maybePersistToolResult as x, inlineLoadedExtension as xn, definePreset as xt, buildPersistedStub as y, defaultExtensionScanPaths as yn, createWorkspaceSurface as yt, buildFromCompactPrompt as z, BUILTIN_ARTIFACT_KINDS as zn, looksBinary as zt };
 
-//# sourceMappingURL=agent-9gf8ZlBR.js.map
+//# sourceMappingURL=agent-_xxElOgH.js.map