zidane 5.10.0 → 5.10.2

package/dist/{tools-ycHDeHBZ.js → tools-Bk9TqmCV.js}

@@ -4,13 +4,13 @@ import { a as formatTaskStatus, i as formatDuration, o as formatTaskSummary, s a
 import { a as createCursorOAuthProvider, c as arcee, f as ANTHROPIC_EXTRA_MODELS, l as anthropic, n as openai, o as generatePkce, p as FAST_MODE_OPTIONS, r as local, s as cerebras, t as openrouter } from "./providers-BxHepM_P.js";
 import { i as AgentProviderError, l as errorMessage, n as AgentBudgetExceededError, o as AgentToolPairingError, p as toTypedError, t as AgentAbortedError } from "./errors-B-GeaKTX.js";
 import { E as appendStaticSection, a as detectTurnInterruption, c as filterUnresolvedToolUses, k as renderSystemForWire, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-DdfOKKx_.js";
-import { i as toolOutputByteLength, n as documentBlockMarker, r as toolOutputBudgetByteLength, t as DEFAULT_AGENT_CLOCK } from "./types-BiobHM1D.js";
+import { a as toolResultToText, i as toolOutputByteLength, n as documentBlockMarker, r as toolOutputBudgetByteLength, t as DEFAULT_AGENT_CLOCK } from "./types-BiobHM1D.js";
 import { t as reconcileImageMediaType } from "./image-sniff-B7uFSNO1.js";
-import { n as createProcessContext } from "./contexts-CbI8dRfI.js";
+import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-GKAWYq07.js";
 import { i as styleReplacementForVia, n as resolveOldString, r as stripLineNumberPrefixes, t as describeVia } from "./edit-utils-EGosADZq.js";
 import { a as invalidateReadStatePath, n as getToolDedupState, o as readStateKey, r as hashContent, s as resolveReadStateMap } from "./read-state-CDVYj7q-.js";
 import { S as escapeXml, d as buildCatalog, n as stripShellInterpolations, p as installAllowedToolsGate, r as resolveSkills, t as interpolateShellCommands, v as validateResourcePathReal, x as createSkillActivationState } from "./interpolate-DwVIJpB3.js";
-import { n as connectMcpServers } from "./mcp-DzuTfq-I.js";
+import { n as connectMcpServers } from "./mcp-BdN9UjTO.js";
 import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { createHooks } from "hookable";
@@ -4660,7 +4660,7 @@ function buildShellDescription({ allowBackground, registeredCanonicals, toolAlia
 		}
 		if (swaps.length > 0) lines.push("", "When a dedicated tool fits, prefer it over shell:", ...swaps, "", "Re-running `ls`/`cat` on the same path is not useful — the prior result is still current unless you wrote to that path since.");
 	}
-	if (allowBackground) lines.push("", "Long-running commands (`npm run dev`, `python train.py`, anything that would otherwise block your turn for minutes) → `run_in_background: true`. The call returns immediately with `{ task_id, output_path, pid }`; stdout + stderr stream to the log file at `output_path`.", "", "After spawning a background task: end your current turn (do NOT keep iterating). A `<task-notification>` arrives on the agent's NEXT user-turn with the final status. Polling the log file in a loop wastes tokens and blocks your turn — the notification IS the wake-up. If you NEED to check progress immediately (rare), call `read_file({ path: output_path, ... })` exactly once and decide. To terminate, use `shell_kill({ task_id })`.", "", "When called from inside a `spawn`'d subagent: you have NO next user-turn — your `agent.run` ends as soon as you finish responding. Start the background task, return a brief summary including the `task_id`, and end your turn. Ownership of the task is transferred to the parent agent when your run finishes; the parent will see the notification on ITS next user-turn.");
+	if (allowBackground) lines.push("", "Long-running commands (`npm run dev`, `python train.py`, anything that would otherwise block your turn for minutes) → `run_in_background: true`. The call returns immediately with `{ task_id, output_path, pid }`; stdout + stderr stream to the log file at `output_path`.", "", "After spawning a background task: end your current turn (do NOT keep iterating). A `<task-notification>` arrives on the agent's NEXT user-turn with the final status. Polling the log file in a loop wastes tokens and blocks your turn — the notification IS the wake-up. If you NEED to check progress immediately (rare), call `read_file({ path: output_path, ... })` exactly once and decide. To terminate, use `shell_kill({ task_id })`. If — and only if — your very next step depends on the task's outcome, block on it with `wait_task({ task_id })` instead of polling.", "", "When called from inside a `spawn`'d subagent: you have NO next user-turn — your `agent.run` ends as soon as you finish responding. Start the background task, return a brief summary including the `task_id`, and end your turn. Ownership of the task is transferred to the parent agent when your run finishes; the parent will see the notification on ITS next user-turn.");
 	return lines.join("\n");
 }
 /**
@@ -4802,13 +4802,24 @@ async function runBackground(command, ctx) {
 	if (typeof tasksDir !== "string" || tasksDir.length === 0) return "shell error: background mode requires `behavior.tasksDir` to be set on the agent. The host has not opted into background tasks — either fall back to foreground (drop `run_in_background`) or ask the user to enable it.";
 	if (!ctx.execution.execBackground) return `shell error: the active execution context (${ctx.execution.type}) does not support background tasks. Fall back to foreground (drop \`run_in_background\`).`;
 	try {
+		const outputCap = ctx.behavior?.backgroundOutputCap;
+		const stallWatchdogMs = ctx.behavior?.backgroundStallWatchdogMs;
 		const handle = await ctx.execution.execBackground(ctx.handle, command, {
 			outputDir: tasksDir,
 			onExit: (info) => {
 				Promise.resolve(ctx.hooks.callHook("background:exit", info)).catch((err) => {
 					if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/shell] background:exit hook rejected: ${err instanceof Error ? err.message : String(err)}\n`);
 				});
-			}
+			},
+			...typeof outputCap === "number" && outputCap > 0 ? { maxOutputBytes: outputCap } : {},
+			...typeof stallWatchdogMs === "number" && stallWatchdogMs > 0 ? {
+				stallTimeoutMs: stallWatchdogMs,
+				onStall: (info) => {
+					Promise.resolve(ctx.hooks.callHook("background:stall", info)).catch((err) => {
+						if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/shell] background:stall hook rejected: ${err instanceof Error ? err.message : String(err)}\n`);
+					});
+				}
+			} : {}
 		});
 		Promise.resolve(ctx.hooks.callHook("background:start", {
 			taskId: handle.taskId,
@@ -5332,6 +5343,60 @@ function createToolSearchTool(options) {
 	};
 }
 //#endregion
+//#region src/tools/wait-task.ts
+/**
+* Stable prefix on the timed-out result. The agent's notification
+* suppression keys on it: results carrying this prefix mean the task is
+* still running, so the pending `<task-notification>` must survive.
+*/
+const WAIT_TASK_TIMED_OUT_PREFIX = "wait_task: timed out";
+const DEFAULT_TIMEOUT_MS = 12e4;
+const MAX_TIMEOUT_MS = 30 * 6e4;
+const waitTask = {
+	spec: {
+		name: "wait_task",
+		description: [
+			"Wait for a background task started by `shell({ run_in_background: true })` to exit, then return its final status.",
+			"Returns immediately when the task has already terminated. On timeout the task keeps running and you can wait again, keep working, or `shell_kill` it.",
+			"Prefer ending your turn and receiving the `<task-notification>` when you have other useful work or nothing depends on the result; use wait_task only when the next step genuinely needs the task's outcome."
+		].join("\n"),
+		inputSchema: {
+			type: "object",
+			properties: {
+				task_id: {
+					type: "string",
+					description: "The task id returned by a prior `shell({ run_in_background: true })` call."
+				},
+				timeout_ms: {
+					type: "integer",
+					description: `Max milliseconds to wait before giving up (task keeps running). Default: ${DEFAULT_TIMEOUT_MS}. Capped at ${MAX_TIMEOUT_MS}.`
+				}
+			},
+			required: ["task_id"],
+			additionalProperties: false
+		}
+	},
+	async execute(input, ctx) {
+		const taskId = input.task_id;
+		if (!ctx.execution.waitBackground) return `wait_task error: the active execution context (${ctx.execution.type}) does not support waiting on background tasks.`;
+		if (ctx.execution.listBackground) {
+			if (!(await ctx.execution.listBackground(ctx.handle)).some((e) => e.taskId === taskId)) return `wait_task: no such task "${taskId}". It may have already exited and been cleaned up, or it was never started in this session.`;
+		}
+		const requested = typeof input.timeout_ms === "number" && Number.isFinite(input.timeout_ms) && input.timeout_ms > 0 ? input.timeout_ms : DEFAULT_TIMEOUT_MS;
+		const timeoutMs = Math.min(requested, MAX_TIMEOUT_MS);
+		const info = await ctx.execution.waitBackground(ctx.handle, taskId, {
+			timeoutMs,
+			signal: ctx.signal
+		});
+		if (!info) return [`${WAIT_TASK_TIMED_OUT_PREFIX} after ${formatDuration(timeoutMs)} — ${taskId} is still running.`, "You can wait again with a longer timeout, continue with other work (a `<task-notification>` arrives when it exits), or terminate it with `shell_kill`."].join("\n");
+		return [
+			`Task ${info.taskId} ${formatTaskStatus(info)} after ${formatDuration(info.durationMs)}.`,
+			`  command: ${previewLine(info.command, 60)}`,
+			`  output:  ${info.outputPath}`
+		].join("\n");
+	}
+};
+//#endregion
 //#region src/agent.ts
 /**
 * Single builder for a {@link ContextAssembly}, shared by the per-run snapshot
@@ -5441,6 +5506,69 @@ function renderTaskNotificationXml(info) {
 		"</task-notification>"
 	].join("\n");
 }
+/**
+* Safety margin for the read-ack ordering comparison, which crosses two
+* clock domains: `turn.createdAt` comes from the host's `AgentClock`
+* (possibly a journaled clock) while `TaskEntry.endedAt` comes from the
+* execution context's wall clock (possibly a remote runner). The turn
+* timestamp already UNDERSTATES the actual read time (the assistant turn
+* is created before its tool executes), so the only false-suppression
+* window is the runner clock lagging the host clock. Requiring the read
+* to land this many ms after the exit absorbs that skew: within the
+* margin we fail open (redundant notification — harmless), and false
+* suppression needs cross-machine skew beyond it (broken NTP territory).
+*/
+const READ_ACK_CLOCK_SKEW_MARGIN_MS = 5e3;
+function collectTaskAcksFromTurns(turns) {
+	const taskIds = /* @__PURE__ */ new Set();
+	const outputPaths = /* @__PURE__ */ new Map();
+	const pendingWaits = /* @__PURE__ */ new Map();
+	for (const turn of turns) for (const block of turn.content) {
+		if (block.type === "text") {
+			if (block.text.startsWith("<task-notification>")) {
+				const match = block.text.match(/<task-id>([^<]+)<\/task-id>/);
+				if (match) taskIds.add(match[1]);
+			}
+			continue;
+		}
+		if (block.type === "tool_call") {
+			if (block.name === "shell_kill" && typeof block.input.task_id === "string") taskIds.add(block.input.task_id);
+			else if (block.name === "wait_task" && typeof block.input.task_id === "string") pendingWaits.set(block.id, block.input.task_id);
+			else if ((block.name === "read_file" || block.name === "read") && typeof block.input.path === "string" && block.input.path.length > 0) {
+				const path = resolve(block.input.path);
+				outputPaths.set(path, Math.max(outputPaths.get(path) ?? 0, turn.createdAt));
+			}
+			continue;
+		}
+		if (block.type === "tool_result" && !block.isError) {
+			const waitedTaskId = pendingWaits.get(block.callId);
+			if (waitedTaskId !== void 0) {
+				if ((typeof block.output === "string" ? block.output : toolResultToText(block.output)).startsWith("Task ")) taskIds.add(waitedTaskId);
+			}
+		}
+	}
+	return {
+		taskIds,
+		outputPaths
+	};
+}
+/**
+* Wire format for a stall-watchdog signal. Distinct outer tag from
+* `<task-notification>` so the model can tell "still running, but quiet"
+* apart from "terminated". Fields mirror {@link TaskStallInfo}.
+*/
+function renderTaskStallXml(info) {
+	return [
+		"<task-stall>",
+		`  <task-id>${escapeXml(info.taskId)}</task-id>`,
+		`  <command>${escapeXml(info.command)}</command>`,
+		`  <output-file>${escapeXml(info.outputPath)}</output-file>`,
+		`  <stalled-for-ms>${info.stalledForMs}</stalled-for-ms>`,
+		`  <bytes-written>${info.bytesWritten}</bytes-written>`,
+		`  <hint>The task is still running but has produced no output for the reported window. It may be stuck at an interactive prompt — read the output file tail; if it ends in a question, kill it with shell_kill and re-run with piped input or a --yes flag.</hint>`,
+		"</task-stall>"
+	].join("\n");
+}
 const HOOK_EVENT_SET = new Set([
 	"system:before",
 	"agent:start",
@@ -5496,6 +5624,7 @@ const HOOK_EVENT_SET = new Set([
 	"mcp:close",
 	"mcp:bootstrap:start",
 	"mcp:bootstrap:end",
+	"mcp:bootstrap:settled",
 	"mcp:tools:list",
 	"mcp:auth:required",
 	"mcp:auth:url",
@@ -5510,6 +5639,8 @@ const HOOK_EVENT_SET = new Set([
 	"background:start",
 	"background:exit",
 	"background:reassign",
+	"background:stall",
+	"background:reconcile",
 	"skills:resolve",
 	"skills:catalog",
 	"skills:activate",
@@ -5624,6 +5755,12 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		persistMaxBytes: runBehavior?.persistMaxBytes ?? agentBehavior?.persistMaxBytes,
 		tasksDir: runBehavior?.tasksDir ?? agentBehavior?.tasksDir,
 		disableBackgroundTasks: runBehavior?.disableBackgroundTasks ?? agentBehavior?.disableBackgroundTasks,
+		backgroundOutputCap: runBehavior?.backgroundOutputCap ?? agentBehavior?.backgroundOutputCap,
+		backgroundStallWatchdogMs: runBehavior?.backgroundStallWatchdogMs ?? agentBehavior?.backgroundStallWatchdogMs,
+		extensions: runBehavior?.extensions || agentBehavior?.extensions ? {
+			...agentBehavior?.extensions,
+			...runBehavior?.extensions
+		} : void 0,
 		strictToolPairing: runBehavior?.strictToolPairing ?? agentBehavior?.strictToolPairing ?? false,
 		maxConsecutivePauseTurns: runBehavior?.maxConsecutivePauseTurns ?? agentBehavior?.maxConsecutivePauseTurns,
 		persistTurns: runBehavior?.persistTurns ?? agentBehavior?.persistTurns
@@ -5874,6 +6011,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		idleResolve = void 0;
 	}
 	const pendingTaskNotifications = /* @__PURE__ */ new Map();
+	const pendingStallNotifications = /* @__PURE__ */ new Map();
+	const notifiedTaskIds = /* @__PURE__ */ new Set();
 	const pendingToolCancels = /* @__PURE__ */ new Map();
 	let executionHandle = null;
 	let mcpConnection = null;
@@ -6068,11 +6207,15 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			} : runBaseTools;
 			const toolsPreSearch = {};
 			for (const tool of Object.values(mergedWithSkills)) toolsPreSearch[tool.spec.name] = tool;
-			if (toolsPreSearch.shell === shell) toolsPreSearch.shell = createShellTool({
-				allowBackground: typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0 && resolvedBehavior.disableBackgroundTasks !== true,
-				registeredCanonicals: new Set(Object.keys(toolsPreSearch)),
-				...effectiveToolAliases ? { toolAliases: effectiveToolAliases } : {}
-			});
+			if (toolsPreSearch.shell === shell) {
+				const detachedTasks = resolveDetachedTasksCapability(executionContext);
+				const bgDisabled = resolvedBehavior?.disableBackgroundTasks === true || resolvedBehavior?.disableBackgroundTasks === "non-durable" && detachedTasks !== "durable";
+				toolsPreSearch.shell = createShellTool({
+					allowBackground: typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0 && !bgDisabled && detachedTasks !== "none",
+					registeredCanonicals: new Set(Object.keys(toolsPreSearch)),
+					...effectiveToolAliases ? { toolAliases: effectiveToolAliases } : {}
+				});
+			}
 			const disclosure = partitionToolDisclosure(toolsPreSearch, mcpToolNames, mcpServers, toolDisclosure, effectiveToolAliases);
 			const unlocked = new Set(disclosure.eagerCanonicalNames);
 			const initialUnlocked = new Set(disclosure.eagerCanonicalNames);
@@ -6197,13 +6340,48 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			}
 			const runTurnStart = turns.length;
 			if (options.system) await hooks.callHook("system:before", { system: options.system });
+			const reconciled = new Map(pendingTaskNotifications);
+			pendingTaskNotifications.clear();
+			if (executionContext.listBackground && executionHandle && typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0) try {
+				const entries = await executionContext.listBackground(executionHandle);
+				const acks = entries.some((e) => e.status !== "running") ? collectTaskAcksFromTurns(session ? session.turns : turns) : void 0;
+				for (const entry of entries) {
+					if (entry.status === "running" || notifiedTaskIds.has(entry.taskId) || reconciled.has(entry.taskId)) continue;
+					if (acks) {
+						if (acks.taskIds.has(entry.taskId)) continue;
+						const readAt = acks.outputPaths.get(resolve(entry.outputPath));
+						if (readAt !== void 0 && entry.endedAt !== void 0 && readAt >= entry.endedAt + READ_ACK_CLOCK_SKEW_MARGIN_MS) continue;
+					}
+					reconciled.set(entry.taskId, {
+						taskId: entry.taskId,
+						status: entry.status,
+						exitCode: entry.exitCode ?? 0,
+						...entry.signal ? { signal: entry.signal } : {},
+						outputPath: entry.outputPath,
+						durationMs: Math.max(0, (entry.endedAt ?? entry.startedAt) - entry.startedAt),
+						command: entry.command
+					});
+				}
+			} catch (err) {
+				if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/agent] background reconcile failed: ${err instanceof Error ? err.message : String(err)}\n`);
+			}
+			const reconcileCtx = { exits: [...reconciled.values()] };
+			if (reconcileCtx.exits.length > 0) await hooks.callHook("background:reconcile", reconcileCtx);
+			for (const taskId of reconciled.keys()) {
+				notifiedTaskIds.add(taskId);
+				pendingStallNotifications.delete(taskId);
+			}
 			const drainedNotifications = [];
-			if (pendingTaskNotifications.size > 0) {
-				for (const notif of pendingTaskNotifications.values()) drainedNotifications.push({
+			for (const notif of reconcileCtx.exits) drainedNotifications.push({
+				type: "text",
+				text: renderTaskNotificationXml(notif)
+			});
+			if (pendingStallNotifications.size > 0) {
+				for (const stall of pendingStallNotifications.values()) drainedNotifications.push({
 					type: "text",
-					text: renderTaskNotificationXml(notif)
+					text: renderTaskStallXml(stall)
 				});
-				pendingTaskNotifications.clear();
+				pendingStallNotifications.clear();
 			}
 			let lastPersistedTurnCount = turns.length;
 			const promptParts = canonicalizePrompt(options.prompt);
@@ -6521,6 +6699,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		followUpQueue.length = 0;
 		lastContextAssembly = null;
 		pendingTaskNotifications.clear();
+		pendingStallNotifications.clear();
 		const cleared = skillActivationState.clear();
 		for (const record of cleared) await hooks.callHook("skills:deactivate", {
 			skill: record.skill,
@@ -6559,11 +6738,32 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			durationMs: ctx.durationMs,
 			command: ctx.command
 		});
+		pendingStallNotifications.delete(ctx.taskId);
+	});
+	hooks.hook("background:stall", (ctx) => {
+		pendingStallNotifications.set(ctx.taskId, {
+			taskId: ctx.taskId,
+			command: ctx.command,
+			outputPath: ctx.outputPath,
+			stalledForMs: ctx.stalledForMs,
+			bytesWritten: ctx.bytesWritten
+		});
 	});
+	const suppressTaskNotification = (taskId) => {
+		pendingTaskNotifications.delete(taskId);
+		pendingStallNotifications.delete(taskId);
+		notifiedTaskIds.add(taskId);
+	};
 	hooks.hook("tool:after", (ctx) => {
 		if (ctx.name === "shell_kill") {
 			const taskId = ctx.input?.task_id;
-			if (typeof taskId === "string") pendingTaskNotifications.delete(taskId);
+			if (typeof taskId === "string") suppressTaskNotification(taskId);
+			return;
+		}
+		if (ctx.name === "wait_task") {
+			const taskId = ctx.input?.task_id;
+			const timedOut = typeof ctx.result === "string" && ctx.result.startsWith("wait_task: timed out");
+			if (typeof taskId === "string" && !timedOut && typeof ctx.result === "string" && ctx.result.startsWith("Task ")) suppressTaskNotification(taskId);
 			return;
 		}
 		if (ctx.name === "read_file" || ctx.name === "read") {
@@ -6571,7 +6771,11 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			if (typeof rawPath !== "string" || rawPath.length === 0) return;
 			const requested = resolve(rawPath);
 			for (const notif of pendingTaskNotifications.values()) if (resolve(notif.outputPath) === requested) {
-				pendingTaskNotifications.delete(notif.taskId);
+				suppressTaskNotification(notif.taskId);
+				return;
+			}
+			for (const stall of pendingStallNotifications.values()) if (resolve(stall.outputPath) === requested) {
+				pendingStallNotifications.delete(stall.taskId);
 				return;
 			}
 		}
@@ -6628,6 +6832,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		if (destroyed) return;
 		destroyed = true;
 		pendingTaskNotifications.clear();
+		pendingStallNotifications.clear();
 		if (abortController && !abortController.signal.aborted) abortController.abort("agent-destroyed");
 		for (const controller of pendingToolCancels.values()) if (!controller.signal.aborted) controller.abort("agent-destroyed");
 		pendingToolCancels.clear();
@@ -6643,6 +6848,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			executionHandle = null;
 		}
 		pendingTaskNotifications.clear();
+		pendingStallNotifications.clear();
+		notifiedTaskIds.clear();
 		skillsCleanup();
 		skillsCleanup = () => {};
 		lastContextAssembly = null;
@@ -8376,6 +8583,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { resolvePersistDir as A, getModelInfo as B, validateToolArgs as C, cleanupPersistedSession as D, buildPersistedStub as E, cerebrasDescriptor as F, openaiDescriptor as G, modelOptionsFor as H, credKeyOf as I, restoreModelOptions as J, openrouterDescriptor as K, effectiveContextWindow as L, BUILTIN_PROVIDERS as M, OUTPUT_RESERVE_TOKENS as N, maybePersistToolResult as O, anthropicDescriptor as P, enabledModelOptions as R, TOOL_USE_SKIPPED_MESSAGE as S, PERSISTENCE_PREVIEW_BYTES as T, modelSupportsReasoning as U, localDescriptor as V, modelsForDescriptor as W, createShellTool as _, multiEdit as a, SHELL_CASCADE_CANCEL_MESSAGE as b, grep as c, createAgent as d, createToolSearchTool as f, createSkillsReadTool as g, alwaysQuote as h, readFile$1 as i, resolveTasksDir as j, resolveMcpWarningsDir as k, glob$1 as l, createSkillsRunScriptTool as m, createSpawnTool as n, listFiles as o, createSkillsUseTool as p, piIdOf as q, shellKill as r, createInteractionTool as s, writeFile$1 as t, edit as u, shell as v, PERSISTED_STUB_PREFIX as w, TOOL_USE_CANCELLED_MESSAGE as x, INTERRUPT_MESSAGE_FOR_TOOL_USE as y, getContextWindow as z };
+export { maybePersistToolResult as A, enabledModelOptions as B, TOOL_USE_CANCELLED_MESSAGE as C, PERSISTENCE_PREVIEW_BYTES as D, PERSISTED_STUB_PREFIX as E, OUTPUT_RESERVE_TOKENS as F, modelSupportsReasoning as G, getModelInfo as H, anthropicDescriptor as I, openrouterDescriptor as J, modelsForDescriptor as K, cerebrasDescriptor as L, resolvePersistDir as M, resolveTasksDir as N, buildPersistedStub as O, BUILTIN_PROVIDERS as P, credKeyOf as R, SHELL_CASCADE_CANCEL_MESSAGE as S, validateToolArgs as T, localDescriptor as U, getContextWindow as V, modelOptionsFor as W, restoreModelOptions as X, piIdOf as Y, alwaysQuote as _, multiEdit as a, shell as b, grep as c, createAgent as d, WAIT_TASK_TIMED_OUT_PREFIX as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveMcpWarningsDir as j, cleanupPersistedSession as k, glob$1 as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, waitTask as p, openaiDescriptor as q, shellKill as r, createInteractionTool as s, writeFile$1 as t, edit as u, createSkillsReadTool as v, TOOL_USE_SKIPPED_MESSAGE as w, INTERRUPT_MESSAGE_FOR_TOOL_USE as x, createShellTool as y, effectiveContextWindow as z };
 
-//# sourceMappingURL=tools-ycHDeHBZ.js.map
+//# sourceMappingURL=tools-Bk9TqmCV.js.map