zidane 5.13.0 → 5.13.2

package/dist/acp-cli.js

@@ -0,0 +1,713 @@
+#!/usr/bin/env bun
+import { b as openaiCompat } from "./messages-DEsLGBB9.js";
+import { n as createSandboxContext, r as createProcessContext } from "./contexts-DHi8LPCp.js";
+import { i as basic_default } from "./presets-HDIxliiq.js";
+import "./session-BDWZZaYa.js";
+import { f as arcee, i as openai, l as cerebras, p as anthropic, r as openrouter, t as xai, u as baseten } from "./providers-Cz-RNYZO.js";
+import { t as runAcpStdioServer } from "./acp-BqIU2mo-.js";
+import { f as credKeyOf, i as readCredentials, l as BUILTIN_PROVIDERS, r as credentialsPath, t as resolveStorageDirs } from "./xdg-zlSeVBhQ.js";
+import { createDaytonaProvider } from "./contexts/daytona.js";
+import { createDockerContext } from "./contexts/docker.js";
+import { createE2BProvider } from "./contexts/e2b.js";
+import "./session/sqlite.js";
+import { basename } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+//#region src/acp/credential-bridge.ts
+/**
+* Bridge the user's existing zidane credential store into the process
+* environment so the ACP agent authenticates with the SAME login the TUI /
+* `zidane auth` already set up — no secrets in the editor's `settings.json`.
+*
+* ACP gives the client (e.g. Zed) no way to forward its own provider API keys
+* to an external agent: provider/auth is agent-owned. The only client-driven
+* channel is the `agent_servers.<name>.env` block, i.e. literal secrets in
+* settings. This bridge removes that need by reading the on-disk store the rest
+* of zidane manages:
+*
+*   - OAuth providers (Anthropic / OpenAI Codex / xAI): point
+*     `ZIDANE_CREDENTIALS_PATH` at the store so the harness providers read and
+*     refresh from it.
+*   - API-key providers (OpenRouter / Cerebras / Baseten / Arcee / …): inject
+*     the stored key into the provider's env var.
+*
+* Precedence is "explicit env wins": an env var already set (e.g. by the
+* editor's `env` block) is never overwritten — the store only FILLS GAPS. The
+* whole bridge no-ops when `ZIDANE_CREDENTIALS_PATH` is already set (the caller
+* is managing credentials explicitly) or when no store file exists (so
+* `~/.credentials.json` from a legacy `bun run auth` keeps working untouched).
+*/
+/**
+* Apply the stored credentials to `env`. Returns the bridged file path, or
+* `null` when nothing was applied (no store, or an explicit path override).
+*/
+function bridgeStoredCredentials(options = {}) {
+	const env = options.env ?? process.env;
+	if (env.ZIDANE_CREDENTIALS_PATH) return null;
+	const dataDir = options.dataDir ?? resolveStorageDirs({ env }).configDir;
+	const path = credentialsPath(dataDir);
+	if (!existsSync(path)) return null;
+	env.ZIDANE_CREDENTIALS_PATH = path;
+	const creds = readCredentials(dataDir);
+	for (const descriptor of Object.values(BUILTIN_PROVIDERS)) {
+		const cred = creds[credKeyOf(descriptor)];
+		if (cred?.kind !== "apikey") continue;
+		if (descriptor.envKey && cred.value && !env[descriptor.envKey]) env[descriptor.envKey] = cred.value;
+		for (const field of descriptor.customFields ?? []) {
+			const value = cred.customFields?.[field.key];
+			if (value && !env[field.envVar]) env[field.envVar] = value;
+		}
+	}
+	return path;
+}
+//#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/cli-shared.ts
+/**
+* Build the execution context for a CLI run: `process` (default), `docker`,
+* `e2b`, or `daytona`.
+*
+* The `e2b` backend reads its `E2B_API_KEY` / `E2B_DOMAIN` / `E2B_TEMPLATE`
+* from the environment (point `E2B_DOMAIN` at a self-hosted cluster, and set
+* `E2B_TEMPLATE` to a template that exists there — the default `base` does
+* not); `--cwd` becomes the sandbox working directory.
+*
+* The Daytona backend reads `DAYTONA_API_KEY` / `DAYTONA_API_URL` /
+* `DAYTONA_TARGET` from the environment. `--cwd` becomes the sandbox working
+* directory.
+*
+* `env` (from `--env` / `--pass-env`) is forwarded to whichever context is
+* selected: baked into remote sandboxes at create time, set on the Docker
+* container, or merged into the in-process command environment.
+*
+* `pregame` (from `--pregame`) is supported by the remote sandbox providers:
+* a setup script uploaded and run in the sandbox once it's ready, before
+* prompting begins.
+*
+* `sandboxId` (from `--sandbox`) attaches to a pre-existing remote sandbox
+* instead of creating a fresh one.
+*/
+function createCliExecution(type, opts) {
+	switch (type) {
+		case "docker": return createDockerContext({
+			image: opts.image,
+			cwd: opts.cwd,
+			env: opts.env
+		});
+		case "e2b": return createSandboxContext(createE2BProvider({
+			cwd: opts.cwd,
+			env: opts.env,
+			...opts.pregame ? { pregame: opts.pregame } : {},
+			...opts.sandboxId ? { sandboxId: opts.sandboxId } : {},
+			...opts.sandboxOnDestroy ? { onDestroy: opts.sandboxOnDestroy } : {}
+		}));
+		case "daytona": return createSandboxContext(createDaytonaProvider({
+			cwd: opts.cwd,
+			env: opts.env,
+			...opts.pregame ? { pregame: opts.pregame } : {},
+			...opts.sandboxId ? { sandboxId: opts.sandboxId } : {},
+			...opts.sandboxOnDestroy ? { onDestroy: opts.sandboxOnDestroy } : {}
+		}));
+		default: return createProcessContext({
+			cwd: opts.cwd,
+			env: opts.env
+		});
+	}
+}
+//#endregion
+//#region src/start/options.ts
+const startProviders = {
+	anthropic,
+	openai,
+	openrouter,
+	cerebras,
+	xai,
+	arcee,
+	baseten
+};
+const startPresets = { basic: basic_default };
+function resolvePreset(name) {
+	const preset = startPresets[name];
+	if (!preset) throw new Error(`Unknown preset: ${name}. Available: ${Object.keys(startPresets).join(", ")}`);
+	return preset;
+}
+function createStartProvider(input) {
+	const options = typeof input === "string" ? { provider: input } : input;
+	const name = options.provider;
+	if (name === "local" || name === "openai-compat") return createLocalCompatProvider(options, name);
+	const providerFactory = startProviders[name];
+	if (!providerFactory) throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(startProviders).join(", ")}, local, openai-compat`);
+	warnIgnoredLocalProviderOptions(options, name);
+	return providerFactory();
+}
+function createLocalCompatProvider(options, name) {
+	const baseURL = options.baseURL ?? process.env.LOCAL_LLM_BASE_URL;
+	if (!baseURL) throw new Error("No base URL for the local provider. Pass --base-url or set LOCAL_LLM_BASE_URL (e.g. http://localhost:11434/v1 for Ollama, http://localhost:8000/v1 for vLLM).");
+	const apiKey = (options.apiKeyEnv ? process.env[options.apiKeyEnv] : void 0) ?? process.env.LOCAL_LLM_API_KEY ?? "no-key";
+	const capabilities = {
+		vision: options.vision ?? false,
+		imageInToolResult: options.imageInToolResult ?? false
+	};
+	if (capabilities.imageInToolResult) capabilities.vision = true;
+	const extraBodyParams = { stream_options: { include_usage: true } };
+	if (options.temperature !== void 0) extraBodyParams.temperature = options.temperature;
+	if (options.seed !== void 0) extraBodyParams.seed = options.seed;
+	return openaiCompat({
+		name,
+		baseURL,
+		apiKey,
+		extraHeaders: resolveLocalExtraHeaders(options),
+		capabilities,
+		...options.model ? { defaultModel: options.model } : process.env.LOCAL_LLM_DEFAULT_MODEL ? { defaultModel: process.env.LOCAL_LLM_DEFAULT_MODEL } : {},
+		extraBodyParams
+	});
+}
+function warnIgnoredLocalProviderOptions(options, provider) {
+	const ignored = [
+		options.baseURL !== void 0 ? "--base-url" : null,
+		options.apiKeyEnv !== void 0 ? "--api-key-env" : null,
+		options.headersEnv !== void 0 ? "--headers-env" : null,
+		options.extraHeaders !== void 0 ? "--header" : null,
+		options.vision !== void 0 ? "--vision" : null,
+		options.imageInToolResult !== void 0 ? "--image-in-tool-result" : null,
+		options.temperature !== void 0 ? "--temperature" : null,
+		options.seed !== void 0 ? "--seed" : null
+	].filter((flag) => flag !== null);
+	if (ignored.length > 0) console.error(`[start] ${ignored.join(", ")} only apply to --provider local|openai-compat; ignored for '${provider}'.`);
+}
+function resolveLocalExtraHeaders(options) {
+	return {
+		...process.env.LOCAL_LLM_AUTHORIZATION ? { Authorization: process.env.LOCAL_LLM_AUTHORIZATION } : {},
+		...readHeadersEnv(options.headersEnv ?? "LOCAL_LLM_HEADERS"),
+		...options.extraHeaders ?? {}
+	};
+}
+function readHeadersEnv(envName) {
+	const raw = process.env[envName];
+	if (!raw) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`${envName} must contain a JSON object of string headers.`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${envName} must contain a JSON object of string headers.`);
+	const headers = {};
+	for (const [name, value] of Object.entries(parsed)) {
+		if (typeof value !== "string") throw new Error(`${envName} header "${name}" must be a string.`);
+		headers[name] = value;
+	}
+	return headers;
+}
+//#endregion
+//#region src/acp-cli.ts
+const acpArgOptions = {
+	"models": { type: "string" },
+	"model-option": {
+		type: "string",
+		multiple: true
+	},
+	"no-credential-store": {
+		type: "boolean",
+		default: false
+	}
+};
+async function main() {
+	const argv = Bun.argv.slice(2);
+	if (isHelp(argv)) {
+		process.stdout.write(`${usage()}\n`);
+		return;
+	}
+	const values = parseStartArgValues(argv, {
+		...startLocalArgOptions,
+		...acpArgOptions
+	});
+	const options = buildStartLocalOptions(values, {
+		requirePrompt: false,
+		usage
+	});
+	if (values["no-credential-store"] !== true) {
+		const bridged = bridgeStoredCredentials();
+		if (bridged) process.stderr.write(`[zidane-acp] using stored credentials from ${bridged}\n`);
+	}
+	const registry = buildModelRegistry(options, values);
+	const store = options.sessionDb ? (await import("./session/sqlite.js")).createSqliteStore({ path: options.sessionDb }) : void 0;
+	const handle = runAcpStdioServer({
+		...registry ? {
+			models: registry.models,
+			...registry.defaultModelId ? { defaultModelId: registry.defaultModelId } : {}
+		} : { provider: buildBaseProvider(options) },
+		model: options.model,
+		preset: resolvePreset(options.preset),
+		system: options.system,
+		store,
+		framing: "newline",
+		agentOptions: { ...options.mcp ? { mcpServers: options.mcp } : {} },
+		execution: (request) => createCliExecution(options.context, {
+			image: options.image,
+			cwd: request.cwd || options.cwd,
+			env: options.env,
+			pregame: options.pregame,
+			sandboxId: options.sandboxId,
+			sandboxOnDestroy: options.sandboxOnDestroy
+		}),
+		agentInfo: {
+			name: "zidane",
+			title: "Zidane",
+			version: process.env.npm_package_version ?? "1"
+		},
+		permission: { enabled: true }
+	});
+	const shutdown = async () => {
+		await handle.close();
+		store?.close?.();
+	};
+	process.once("SIGINT", () => {
+		shutdown().finally(() => process.exit(130));
+	});
+	process.once("SIGTERM", () => {
+		shutdown().finally(() => process.exit(143));
+	});
+}
+function usage() {
+	return [
+		"Usage: zidane-acp [provider/context options]",
+		"",
+		"Runs Zidane as an ACP v1 agent over stdio. Prompts are received through ACP session/prompt.",
+		"",
+		"Common options:",
+		"  --provider anthropic|openai|openrouter|cerebras|xai|arcee|baseten|local|openai-compat",
+		"  --model <id>",
+		"  --models <id,id,...>                    advertise a model selector (all on --provider)",
+		"  --model-option provider:model[:label]   add a cross-provider selectable model (repeatable)",
+		"  --context process|docker|e2b|daytona",
+		"  --cwd <path>",
+		"  --session-db <path>",
+		"  --mcp <json>",
+		"  --no-credential-store                   ignore ~/.zidane credentials; use only env",
+		"",
+		"With --models / --model-option, ACP clients (e.g. Zed) can switch models at",
+		"runtime; each model resolves its own provider credentials when first selected.",
+		"",
+		"Credentials: by default zidane-acp reads your existing zidane login from",
+		"~/.zidane/credentials.json (run `zidane auth` once), so no API keys are needed",
+		"in the editor config. Explicit env vars always win."
+	].join("\n");
+}
+function isHelp(argv) {
+	return argv.includes("--help") || argv.includes("-h");
+}
+/** Build a `createStartProvider` config from the parsed CLI options. */
+function providerConfig(options, provider, model) {
+	return {
+		provider,
+		model,
+		baseURL: options.baseURL,
+		apiKeyEnv: options.apiKeyEnv,
+		headersEnv: options.headersEnv,
+		extraHeaders: options.extraHeaders,
+		vision: options.vision,
+		imageInToolResult: options.imageInToolResult,
+		temperature: options.temperature,
+		seed: options.seed
+	};
+}
+function buildBaseProvider(options) {
+	return createStartProvider(providerConfig(options, options.provider, options.model));
+}
+/**
+* Assemble the selectable-model registry from `--model-option` (cross-provider,
+* each lazily building its own provider) and `--models` (same `--provider`,
+* sharing one provider instance). Returns `undefined` when neither flag is set
+* so the caller falls back to a single provider.
+*/
+function buildModelRegistry(options, values) {
+	const modelsFlag = values.models?.trim();
+	const modelOptionFlags = values["model-option"] ?? [];
+	if (!modelsFlag && modelOptionFlags.length === 0) return void 0;
+	const choices = [];
+	for (const raw of modelOptionFlags) choices.push(parseModelOption(raw, options));
+	if (modelsFlag) {
+		const models = modelsFlag.split(",").map((model) => model.trim()).filter(Boolean);
+		if (models.length === 0) throw new StartUsageError("--models must list at least one model id.");
+		const baseProvider = buildBaseProvider(options);
+		for (const model of models) choices.push({
+			id: model,
+			name: model,
+			model,
+			provider: baseProvider
+		});
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const choice of choices) {
+		if (seen.has(choice.id)) throw new StartUsageError(`Duplicate model id "${choice.id}" across --models / --model-option.`);
+		seen.add(choice.id);
+	}
+	return {
+		models: choices,
+		defaultModelId: options.model && choices.find((choice) => choice.id === options.model || choice.model === options.model)?.id || choices[0].id
+	};
+}
+function parseModelOption(raw, options) {
+	const parts = raw.split(":");
+	if (parts.length < 2 || !parts[0] || !parts[1]) throw new StartUsageError(`--model-option must be "provider:model[:label]", got '${raw}'.`);
+	const providerName = parts[0];
+	if (!startProviderNames.includes(providerName)) throw new StartUsageError(`--model-option provider must be one of ${startProviderNames.join("|")}, got '${providerName}'.`);
+	const model = parts[1];
+	const label = parts.slice(2).join(":").trim() || void 0;
+	const isLocal = providerName === "local" || providerName === "openai-compat";
+	const provider = () => createStartProvider(isLocal ? providerConfig(options, providerName, model) : {
+		provider: providerName,
+		model
+	});
+	return {
+		id: `${providerName}:${model}`,
+		name: label ?? model,
+		model,
+		provider
+	};
+}
+main().catch((err) => {
+	if (err instanceof StartUsageError) process.stderr.write(`${err.message}\n`);
+	else process.stderr.write(`ACP server error: ${err instanceof Error ? err.message : String(err)}\n`);
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=acp-cli.js.map