zidane 5.13.4 → 5.13.6

package/dist/{acp-BqIU2mo-.js → acp-BRQvvdnO.js}

@@ -7,8 +7,10 @@ import { l as errorMessage } from "./errors-BpPfMo_4.js";
 import { t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { i as basic_default } from "./presets-HDIxliiq.js";
 import { r as loadSession, t as createSession } from "./session-BDWZZaYa.js";
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
+import { readFileSync } from "node:fs";
 import { Buffer } from "node:buffer";
+import { parseArgs } from "node:util";
 //#region src/acp/json-rpc.ts
 function createJsonRpcConnection(options) {
 	let nextId = 1;
@@ -183,6 +185,342 @@ function isObject$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 //#endregion
+//#region src/start/shared-options.ts
+const validThinkingLevels = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"adaptive"
+];
+const startProviderNames = [
+	"anthropic",
+	"openai",
+	"openrouter",
+	"cerebras",
+	"xai",
+	"arcee",
+	"baseten",
+	"local",
+	"openai-compat"
+];
+const startPresetNames = ["basic"];
+const startFormatNames = ["zidane", "provider"];
+var StartUsageError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "StartUsageError";
+	}
+};
+/**
+* The shared `bun start` / `zidane run` option table. Exported so
+* `parseStartArgs` (start CLI) can compose it with the Restate-only options
+* and parse argv ONCE — two diverging tables would let new flags silently
+* drift between the two parsers.
+*/
+const startLocalArgOptions = {
+	"help": {
+		type: "boolean",
+		short: "h",
+		default: false
+	},
+	"prompt": {
+		type: "string",
+		short: "p"
+	},
+	"model": {
+		type: "string",
+		short: "m"
+	},
+	"preset": {
+		type: "string",
+		short: "t",
+		default: "basic"
+	},
+	"system": {
+		type: "string",
+		short: "s"
+	},
+	"thinking": {
+		type: "string",
+		default: "off"
+	},
+	"provider": {
+		type: "string",
+		default: "anthropic"
+	},
+	"base-url": { type: "string" },
+	"api-key-env": { type: "string" },
+	"headers-env": { type: "string" },
+	"header": {
+		type: "string",
+		multiple: true
+	},
+	"vision": { type: "boolean" },
+	"image-in-tool-result": { type: "boolean" },
+	"temperature": { type: "string" },
+	"seed": { type: "string" },
+	"context": {
+		type: "string",
+		short: "c",
+		default: "process"
+	},
+	"image": { type: "string" },
+	"cwd": { type: "string" },
+	"env": {
+		type: "string",
+		multiple: true
+	},
+	"pass-env": {
+		type: "string",
+		multiple: true
+	},
+	"pregame": { type: "string" },
+	"sandbox": { type: "string" },
+	"sandbox-on-destroy": { type: "string" },
+	"mcp": { type: "string" },
+	"session-db": { type: "string" },
+	"session-id": { type: "string" },
+	"json": {
+		type: "boolean",
+		default: false
+	},
+	"stream-json": {
+		type: "boolean",
+		default: false
+	},
+	"format": {
+		type: "string",
+		default: "zidane"
+	}
+};
+/**
+* Strict argv parse shared by the start CLIs. `strict: true` rejects unknown
+* flags and stray positionals loudly — without it, a typo'd flag's value
+* silently leaks into the run (e.g. as a bogus prompt). Parse failures are
+* rethrown as {@link StartUsageError}.
+*/
+function parseStartArgValues(argv, options) {
+	try {
+		const { values } = parseArgs({
+			args: [...argv],
+			options,
+			strict: true
+		});
+		return values;
+	} catch (err) {
+		throw new StartUsageError(`${err instanceof Error ? err.message : String(err)}\n\nRun with --help for usage.`);
+	}
+}
+/** Assemble {@link StartLocalOptions} from already-parsed argv values. */
+function buildStartLocalOptions(values, config = {}) {
+	const { requirePrompt = true, usage = startLocalUsage } = config;
+	if (values.help === true) throw new StartUsageError(usage());
+	const prompt = values.prompt;
+	if (requirePrompt && (!prompt || prompt.trim() === "")) throw new StartUsageError(usage());
+	const thinkingRaw = values.thinking || "off";
+	if (!validThinkingLevels.includes(thinkingRaw)) throw new Error(`Unknown thinking level: ${thinkingRaw}. Available: ${validThinkingLevels.join(", ")}`);
+	const provider = values.provider || "anthropic";
+	if (!startProviderNames.includes(provider)) throw new Error(`Unknown provider: ${provider}. Available: ${startProviderNames.join(", ")}`);
+	const preset = values.preset || "basic";
+	if (!startPresetNames.includes(preset)) throw new Error(`Unknown preset: ${preset}. Available: ${startPresetNames.join(", ")}`);
+	if (values.json === true && values["stream-json"] === true) throw new StartUsageError("Use either `--json` or `--stream-json`, not both.");
+	const format = values.format || "zidane";
+	if (!startFormatNames.includes(format)) throw new Error(`Unknown format: ${format}. Available: ${startFormatNames.join(", ")}`);
+	const baseURL = values["base-url"];
+	const apiKeyEnv = values["api-key-env"];
+	const headersEnv = values["headers-env"];
+	const extraHeaders = parseHeaderArgs(values.header, "--header");
+	const temperature = parseOptionalNumber(values.temperature, "--temperature");
+	const seed = parseOptionalInteger(values.seed, "--seed");
+	const env = parseEnvArgs(values.env, values["pass-env"]);
+	const context = values.context || "process";
+	const pregame = loadPregame(values.pregame, context);
+	const sandboxId = resolveSandboxId(values.sandbox, context);
+	const sandboxOnDestroy = resolveSandboxOnDestroy(values["sandbox-on-destroy"], context);
+	return {
+		system: values.system,
+		prompt: prompt ?? "",
+		model: values.model,
+		...baseURL !== void 0 ? { baseURL } : {},
+		...apiKeyEnv !== void 0 ? { apiKeyEnv } : {},
+		...headersEnv !== void 0 ? { headersEnv } : {},
+		...Object.keys(extraHeaders).length > 0 ? { extraHeaders } : {},
+		...values.vision === true ? { vision: true } : {},
+		...values["image-in-tool-result"] === true ? { imageInToolResult: true } : {},
+		...temperature !== void 0 ? { temperature } : {},
+		...seed !== void 0 ? { seed } : {},
+		preset,
+		thinking: thinkingRaw,
+		provider,
+		context,
+		image: values.image,
+		cwd: values.cwd,
+		...Object.keys(env).length > 0 ? { env } : {},
+		...pregame ? { pregame } : {},
+		...sandboxId ? { sandboxId } : {},
+		...sandboxOnDestroy ? { sandboxOnDestroy } : {},
+		mcp: parseMcpConfig(values.mcp),
+		sessionDb: values["session-db"],
+		sessionId: values["session-id"],
+		json: values.json === true,
+		streamJson: values["stream-json"] === true,
+		format
+	};
+}
+function startLocalUsage() {
+	return [
+		`Usage: bun start --prompt "your message" \\`,
+		`         [--provider ${startProviderNames.join("|")}] [--model <id>] [--thinking ${validThinkingLevels.join("|")}]`,
+		`         [--base-url <url>] [--api-key-env <NAME>] [--headers-env <NAME>] [--header 'Name: value']`,
+		`         [--vision] [--image-in-tool-result] [--temperature <f>] [--seed <n>]`,
+		`         [--context process|docker|e2b|daytona] [--image node:22] [--cwd /workspace]`,
+		`         [--env KEY=VALUE ...] [--pass-env VARNAME ...] [--pregame setup.sh] [--sandbox <id>] [--sandbox-on-destroy kill|pause|leave]`,
+		`         [--mcp '[...]'] [--session-db ./sessions.db] [--session-id <id>] [--json|--stream-json] [--format zidane|provider]`,
+		``,
+		`  --stream-json streams COMPLETE TURNS as JSONL (one line per turn), then the result.`,
+		`  For the full event stream (text deltas, tool calls, …) use the headless CLI's`,
+		`  --output-format stream-json instead.`
+	].join("\n");
+}
+/**
+* Parse the `--mcp` argument: inline JSON (object or array) or a path to a JSON
+* file. Validates that each server declares the fields its transport requires.
+*/
+function parseMcpConfig(raw) {
+	if (!raw) return void 0;
+	let text = raw.trim();
+	if (!text.startsWith("[") && !text.startsWith("{")) text = readFileSync(text, "utf8");
+	const parsed = JSON.parse(text);
+	const configs = Array.isArray(parsed) ? parsed : [parsed];
+	for (const config of configs) {
+		if (!config.name || !config.transport) throw new Error(`Invalid MCP config: each server needs "name" and "transport". Got: ${JSON.stringify(config)}`);
+		if (config.transport === "stdio" && !config.command) throw new Error(`MCP server "${config.name}": stdio transport requires "command"`);
+		if ((config.transport === "sse" || config.transport === "streamable-http") && !config.url) throw new Error(`MCP server "${config.name}": ${config.transport} transport requires "url"`);
+	}
+	return configs;
+}
+function parseOptionalNumber(raw, flag) {
+	if (raw === void 0) return void 0;
+	const value = Number(raw);
+	if (Number.isNaN(value)) throw new Error(`${flag} must be a number, got '${raw}'.`);
+	return value;
+}
+function parseOptionalInteger(raw, flag) {
+	if (raw === void 0) return void 0;
+	const value = Number(raw);
+	if (!Number.isInteger(value)) throw new Error(`${flag} must be an integer, got '${raw}'.`);
+	return value;
+}
+/**
+* Build the execution-context environment from `--pass-env VARNAME` (forward
+* the named variable from the current shell) and `--env KEY=VALUE` (set a
+* value explicitly). `--pass-env` is applied first so an explicit `--env`
+* wins when both name the same key. An unset `--pass-env` variable is a hard
+* error rather than a silently-empty value.
+*/
+function parseEnvArgs(envArgs, passEnvArgs, source = process.env) {
+	const env = {};
+	for (const name of passEnvArgs ?? []) {
+		const key = name.trim();
+		if (!key) throw new Error("--pass-env requires a variable name.");
+		const value = source[key];
+		if (value === void 0) throw new Error(`--pass-env ${key}: environment variable ${key} is not set.`);
+		env[key] = value;
+	}
+	for (const item of envArgs ?? []) {
+		const eq = item.indexOf("=");
+		const key = eq === -1 ? "" : item.slice(0, eq).trim();
+		if (!key) throw new Error(`--env must be formatted as KEY=VALUE, got '${item}'.`);
+		env[key] = item.slice(eq + 1);
+	}
+	return env;
+}
+/**
+* Resolve the `--pregame <file>` setup script. Returns `undefined` when no path
+* is given. The script only runs in remote sandbox contexts (it's uploaded into
+* the ready sandbox before prompting); for any other context this warns and
+* ignores it rather than failing. For supported contexts the file is read
+* eagerly — consistent with `--prompt-file`/`--schema` — so a missing or
+* unreadable file surfaces as a usage error up front rather than mid-spawn.
+* The returned `name` is the basename used for the uploaded file.
+*/
+function loadPregame(path, context) {
+	if (!path) return void 0;
+	if (!supportsRemoteSandboxFlags(context)) {
+		console.error(`--pregame is only supported with --context e2b or daytona; ignoring it for context '${context}'.`);
+		return;
+	}
+	let content;
+	try {
+		content = readFileSync(path, "utf8");
+	} catch (err) {
+		throw new Error(`--pregame: failed to read '${path}': ${err.message}`);
+	}
+	return {
+		name: basename(path),
+		content
+	};
+}
+/**
+* Resolve the `--sandbox <id>` argument. Returns `undefined` when no id is
+* given. Connecting to a pre-existing sandbox is supported by the remote
+* sandbox providers; for any other context this warns and ignores it rather
+* than failing, mirroring {@link loadPregame}. A blank value (e.g.
+* `--sandbox ''`) is treated as absent.
+*/
+function resolveSandboxId(raw, context) {
+	const id = raw?.trim();
+	if (!id) return void 0;
+	if (!supportsRemoteSandboxFlags(context)) {
+		console.error(`--sandbox is only supported with --context e2b or daytona; ignoring it for context '${context}'.`);
+		return;
+	}
+	return id;
+}
+const validSandboxOnDestroyValues = [
+	"kill",
+	"pause",
+	"leave"
+];
+/**
+* Resolve the `--sandbox-on-destroy kill|pause|leave` argument. Returns
+* `undefined` when not set (the provider defaults to `'kill'` / delete).
+* Applies to remote sandbox contexts; warns and ignores for any other context,
+* mirroring {@link resolveSandboxId} and {@link loadPregame}.
+*/
+function resolveSandboxOnDestroy(raw, context) {
+	const value = raw?.trim();
+	if (!value) return void 0;
+	if (!supportsRemoteSandboxFlags(context)) {
+		console.error(`--sandbox-on-destroy is only supported with --context e2b or daytona; ignoring it for context '${context}'.`);
+		return;
+	}
+	if (!validSandboxOnDestroyValues.includes(value)) throw new StartUsageError(`--sandbox-on-destroy must be kill|pause|leave, got '${value}'.`);
+	return value;
+}
+function supportsRemoteSandboxFlags(context) {
+	return context === "e2b" || context === "daytona";
+}
+function parseHeaderArgs(raw, flag) {
+	if (!raw || raw.length === 0) return {};
+	const headers = {};
+	for (const item of raw) {
+		const colon = item.indexOf(":");
+		const equals = item.indexOf("=");
+		const separator = colon === -1 ? equals : equals === -1 ? colon : Math.min(colon, equals);
+		if (separator <= 0) throw new Error(`${flag} must be formatted as "Name: value" or "Name=value".`);
+		const name = item.slice(0, separator).trim();
+		const value = item.slice(separator + 1).trim();
+		if (!name || !value) throw new Error(`${flag} must include both a header name and value.`);
+		headers[name] = value;
+	}
+	return headers;
+}
+//#endregion
 //#region src/acp/mapping.ts
 function acpMcpServersToZidane(servers) {
 	if (!servers) return [];
@@ -635,6 +973,19 @@ function seedReadState(ctx, path, content, offset, limit) {
 //#region src/acp/server.ts
 const ACP_AGENT_VERSION = "1";
 const MODEL_CONFIG_ID = "model";
+const MODE_CONFIG_ID = "mode";
+const THINKING_CONFIG_ID = "thinking";
+const MODEL_OPTION_CONFIG_PREFIX = "model_option:";
+const PLAN_MODE_ID = "plan";
+const PLAN_READ_ONLY_TOOLS = new Set([
+	"read_file",
+	"list_files",
+	"grep",
+	"glob",
+	"web_search",
+	"fetch_url",
+	"skills_read"
+]);
 const DEFAULT_PERMISSION_OPTIONS = [
 	{
 		optionId: "allow_once",
@@ -689,18 +1040,35 @@ var AcpServerImpl = class {
 		return ((this.options.model ? this.modelChoices.find((choice) => choice.id === this.options.model || choice.model === this.options.model) : void 0) ?? this.modelChoices[0]).id;
 	}
 	buildDefaultConfigOptions(userConfig) {
-		if (this.modelChoices.length === 0) return userConfig;
-		return [{
-			id: MODEL_CONFIG_ID,
-			name: "Model",
+		const reserved = new Set([MODE_CONFIG_ID]);
+		const options = [{
+			id: MODE_CONFIG_ID,
+			name: "Mode",
 			type: "select",
-			category: "model",
-			currentValue: this.defaultModelChoiceId,
-			options: this.modelChoices.map((choice) => ({
-				value: choice.id,
-				name: choice.name ?? choice.model
+			category: "mode",
+			currentValue: this.defaultModeId,
+			options: this.modes.map((mode) => ({
+				value: mode.id,
+				name: mode.name,
+				...mode.description ? { description: mode.description } : {}
 			}))
-		}, ...userConfig.filter((option) => option.id !== MODEL_CONFIG_ID)];
+		}];
+		if (this.modelChoices.length > 0) {
+			reserved.add(MODEL_CONFIG_ID);
+			options.push({
+				id: MODEL_CONFIG_ID,
+				name: "Model",
+				type: "select",
+				category: "model",
+				currentValue: this.defaultModelChoiceId,
+				options: this.modelChoices.map((choice) => ({
+					value: choice.id,
+					name: choice.name ?? choice.model
+				}))
+			});
+		}
+		options.push(...this.modelDependentConfigOptions(this.defaultModelChoiceId));
+		return [...options, ...userConfig.filter((option) => !reserved.has(option.id) && !isGeneratedModelOptionConfig(option.id) && option.id !== THINKING_CONFIG_ID)];
 	}
 	providerForChoiceId(id) {
 		const choice = this.modelChoices.find((candidate) => candidate.id === id);
@@ -911,6 +1279,8 @@ var AcpServerImpl = class {
 				stats = await runtime.agent.run({
 					prompt: mapped.prompt,
 					...runtime.runModel ? { model: runtime.runModel } : {},
+					...this.runConfig(runtime),
+					...this.toolsForMode(runtime),
 					...this.options.system ? { system: this.options.system } : {},
 					signal: abortController.signal
 				});
@@ -938,21 +1308,33 @@ var AcpServerImpl = class {
 	}
 	async setMode(params) {
 		const runtime = this.requireSession(params.sessionId);
-		if (!this.modes.some((mode) => mode.id === params.modeId)) throw new AcpProtocolError(-32602, `Unknown mode: ${params.modeId}`);
-		runtime.modeId = params.modeId;
+		const configOptions = this.selectMode(runtime, params.modeId);
 		await this.sessionUpdate(params.sessionId, {
 			sessionUpdate: "current_mode_update",
 			currentModeId: params.modeId
 		});
+		await this.sessionUpdate(params.sessionId, {
+			sessionUpdate: "config_option_update",
+			configOptions
+		});
 		return {};
 	}
 	async setConfigOption(params) {
 		const runtime = this.requireSession(params.sessionId);
 		const isModelSwitch = this.modelChoices.length > 0 && params.configId === MODEL_CONFIG_ID;
+		const isModeSwitch = params.configId === MODE_CONFIG_ID;
 		if (isModelSwitch && runtime.inFlight) throw new AcpProtocolError(-32600, "Cannot switch model while a prompt is in flight.");
-		const configOptions = this.applyConfigSelection(runtime, params.configId, params.value);
+		let configOptions = this.applyConfigSelection(runtime, params.configId, params.value);
 		if (isModelSwitch) this.selectModel(runtime, params.value);
+		if (isModeSwitch) {
+			runtime.modeId = params.value;
+			await this.sessionUpdate(params.sessionId, {
+				sessionUpdate: "current_mode_update",
+				currentModeId: params.value
+			});
+		}
 		runtime.config.set(params.configId, params.value);
+		if (isModelSwitch) configOptions = runtime.configOptions;
 		await this.sessionUpdate(params.sessionId, {
 			sessionUpdate: "config_option_update",
 			configOptions
@@ -969,6 +1351,78 @@ var AcpServerImpl = class {
 		if (!choice) throw new AcpProtocolError(-32602, `Unknown model: ${choiceId}`);
 		runtime.setProviderDelegate?.(this.providerForChoiceId(choice.id));
 		runtime.runModel = choice.model;
+		this.refreshModelDependentConfigOptions(runtime, choice.id);
+	}
+	selectMode(runtime, modeId) {
+		if (!this.modes.some((mode) => mode.id === modeId)) throw new AcpProtocolError(-32602, `Unknown mode: ${modeId}`);
+		runtime.modeId = modeId;
+		return this.applyConfigSelection(runtime, MODE_CONFIG_ID, modeId);
+	}
+	runConfig(runtime) {
+		const thinking = configValue(runtime.configOptions, THINKING_CONFIG_ID);
+		const modelOptions = {};
+		for (const option of runtime.configOptions) {
+			if (!isGeneratedModelOptionConfig(option.id) || option.currentValue !== "on") continue;
+			modelOptions[option.id.slice(13)] = true;
+		}
+		return {
+			...isThinkingLevel(thinking) ? { thinking } : {},
+			...Object.keys(modelOptions).length > 0 ? { modelOptions } : {}
+		};
+	}
+	toolsForMode(runtime) {
+		if (runtime.modeId !== PLAN_MODE_ID) return {};
+		return { tools: filterPlanTools(runtime.tools) };
+	}
+	refreshModelDependentConfigOptions(runtime, choiceId) {
+		const insertAfter = (option) => option.id === MODEL_CONFIG_ID;
+		const base = runtime.configOptions.filter((option) => option.id !== THINKING_CONFIG_ID && !isGeneratedModelOptionConfig(option.id));
+		const generated = this.modelDependentConfigOptions(choiceId, runtime.config);
+		const index = base.findIndex(insertAfter);
+		runtime.configOptions = index === -1 ? [...base, ...generated] : [
+			...base.slice(0, index + 1),
+			...generated,
+			...base.slice(index + 1)
+		];
+	}
+	modelDependentConfigOptions(choiceId, previous) {
+		if (!choiceId) return [];
+		const choice = this.modelChoices.find((candidate) => candidate.id === choiceId);
+		if (!choice) return [];
+		const options = [];
+		if (choice.reasoning === true) {
+			const current = previous?.get(THINKING_CONFIG_ID);
+			options.push({
+				id: THINKING_CONFIG_ID,
+				name: "Thinking",
+				type: "select",
+				category: "thought_level",
+				currentValue: isThinkingLevel(current) ? current : "off",
+				options: validThinkingLevels.map((level) => ({
+					value: level,
+					name: thinkingLabel(level)
+				}))
+			});
+		}
+		for (const option of choice.options ?? []) {
+			const id = `${MODEL_OPTION_CONFIG_PREFIX}${option.id}`;
+			const current = previous?.get(id);
+			options.push({
+				id,
+				name: option.label,
+				type: "select",
+				currentValue: current === "on" ? "on" : "off",
+				...option.description ? { description: option.description } : {},
+				options: [{
+					value: "off",
+					name: "Off"
+				}, {
+					value: "on",
+					name: "On"
+				}]
+			});
+		}
+		return options;
 	}
 	/** Reflect a `select` choice back into the advertised option set's `currentValue`. */
 	applyConfigSelection(runtime, configId, value) {
@@ -1035,6 +1489,7 @@ var AcpServerImpl = class {
 			execution,
 			agent,
 			provider,
+			tools: wrappedTools,
 			modeId: this.defaultModeId,
 			configOptions: cloneConfigOptions(this.defaultConfigOptions),
 			config: /* @__PURE__ */ new Map(),
@@ -1086,6 +1541,16 @@ var AcpServerImpl = class {
 	}
 	installHookAdapter(runtime) {
 		const seenTools = /* @__PURE__ */ new Set();
+		runtime.agent.hooks.hook("tool:gate", (ctx) => {
+			if (runtime.modeId !== PLAN_MODE_ID || isPlanReadOnlyTool(ctx.name)) return;
+			ctx.block = true;
+			ctx.reason = `Plan mode is read-only. Switch to Build mode before using \`${ctx.name}\`.`;
+		});
+		runtime.agent.hooks.hook("mcp:tool:gate", (ctx) => {
+			if (runtime.modeId !== PLAN_MODE_ID) return;
+			ctx.block = true;
+			ctx.reason = `Plan mode is read-only. Switch to Build mode before using MCP tool \`${ctx.tool}\`.`;
+		});
 		runtime.agent.hooks.hook("stream:text", ({ delta, turnId }) => {
 			this.sessionUpdate(runtime.sessionId, {
 				sessionUpdate: "agent_message_chunk",
@@ -1308,6 +1773,14 @@ function mergeMcpServers(...sources) {
 	for (const source of sources) for (const server of source ?? []) byName.set(server.name, server);
 	return [...byName.values()];
 }
+function filterPlanTools(tools) {
+	const filtered = {};
+	for (const [key, tool] of Object.entries(tools ?? {})) if (isPlanReadOnlyTool(tool.spec.name)) filtered[key] = tool;
+	return filtered;
+}
+function isPlanReadOnlyTool(name) {
+	return PLAN_READ_ONLY_TOOLS.has(name);
+}
 function cloneConfigOptions(options) {
 	return options.map((option) => ({
 		...option,
@@ -1323,6 +1796,18 @@ function configOptionHasValue(option, value) {
 	} else if (item.value === value) return true;
 	return false;
 }
+function configValue(options, id) {
+	return options.find((option) => option.id === id)?.currentValue;
+}
+function isGeneratedModelOptionConfig(id) {
+	return id.startsWith(MODEL_OPTION_CONFIG_PREFIX);
+}
+function isThinkingLevel(value) {
+	return typeof value === "string" && validThinkingLevels.includes(value);
+}
+function thinkingLabel(level) {
+	return level === "xhigh" ? "Extra high" : level.charAt(0).toUpperCase() + level.slice(1);
+}
 function sameStringArray(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -1405,6 +1890,6 @@ function runAcpStdioServer(options) {
 	};
 }
 //#endregion
-export { acpMcpServersToZidane as a, stopReasonFromRun as c, createJsonRpcConnection as d, wrapToolsForAcpClient as i, toolResultToAcpContent as l, AcpProtocolError as n, acpPromptToPromptParts as o, createAcpServer as r, sessionBlocksToAcp as s, runAcpStdioServer as t, JsonRpcRemoteError as u };
+export { acpMcpServersToZidane as a, stopReasonFromRun as c, buildStartLocalOptions as d, parseStartArgValues as f, createJsonRpcConnection as g, JsonRpcRemoteError as h, wrapToolsForAcpClient as i, toolResultToAcpContent as l, startProviderNames as m, AcpProtocolError as n, acpPromptToPromptParts as o, startLocalArgOptions as p, createAcpServer as r, sessionBlocksToAcp as s, runAcpStdioServer as t, StartUsageError as u };
 
-//# sourceMappingURL=acp-BqIU2mo-.js.map
+//# sourceMappingURL=acp-BRQvvdnO.js.map