zidane 5.13.3 → 5.13.5

package/dist/acp-cli.js

@@ -4,15 +4,14 @@ import { n as createSandboxContext, r as createProcessContext } from "./contexts
 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 { d as buildStartLocalOptions, f as parseStartArgValues, m as startProviderNames, p as startLocalArgOptions, t as runAcpStdioServer, u as StartUsageError } from "./acp-CJ1yHdpK.js";
+import { a as readCredentials, b as modelsForDescriptor, i as credentialsPath, n as resolveStorageDirs, p as credKeyOf, t as detectAuth, u as BUILTIN_PROVIDERS } from "./auth-QA4WuQK5.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";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
 //#region src/acp/credential-bridge.ts
 /**
 * Bridge the user's existing zidane credential store into the process
@@ -61,342 +60,6 @@ function bridgeStoredCredentials(options = {}) {
 	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`,
@@ -565,8 +228,9 @@ async function main() {
 		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")).createTuiStore(options.sessionDb) : void 0;
+	const registry = buildModelRegistry(options, values) ?? buildAutoModelRegistry(options, argv);
+	const sessionDb = options.sessionDb ?? defaultAcpSessionDbPath();
+	const store = (await import("./session/sqlite.js")).createTuiStore(sessionDb);
 	const handle = runAcpStdioServer({
 		...registry ? {
 			models: registry.models,
@@ -617,12 +281,13 @@ function usage() {
 		"  --model-option provider:model[:label]   add a cross-provider selectable model (repeatable)",
 		"  --context process|docker|e2b|daytona",
 		"  --cwd <path>",
-		"  --session-db <path>",
+		`  --session-db <path>                    default: ${defaultAcpSessionDbPath()}`,
 		"  --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.",
+		"Without --provider / --model / --models / --model-option, zidane-acp",
+		"auto-advertises models for every configured provider. Explicit flags keep",
+		"the old deterministic single-provider or curated-picker behavior.",
 		"",
 		"Credentials: by default zidane-acp reads Zidane's app credential store",
 		"(~/.zidane/credentials.json), so no API keys are needed in the editor config.",
@@ -670,6 +335,7 @@ function buildModelRegistry(options, values) {
 			id: model,
 			name: model,
 			model,
+			...modelChoiceMetadata(options.provider, model),
 			provider: baseProvider
 		});
 	}
@@ -683,6 +349,66 @@ function buildModelRegistry(options, values) {
 		defaultModelId: options.model && choices.find((choice) => choice.id === options.model || choice.model === options.model)?.id || choices[0].id
 	};
 }
+function buildAutoModelRegistry(options, argv) {
+	if (hasExplicitProviderTarget(argv)) return void 0;
+	const dataDir = resolveStorageDirs({ env: process.env }).configDir;
+	const available = detectAuth(dataDir, BUILTIN_PROVIDERS, process.env).filter((provider) => provider.available);
+	if (available.length === 0) return void 0;
+	const choices = [];
+	const providers = /* @__PURE__ */ new Map();
+	const providerFor = (key) => {
+		let provider = providers.get(key);
+		if (!provider) {
+			const descriptor = BUILTIN_PROVIDERS[key];
+			if (!descriptor) throw new StartUsageError(`Unknown configured provider: ${key}`);
+			provider = descriptor.factory();
+			providers.set(key, provider);
+		}
+		return provider;
+	};
+	for (const auth of available) {
+		const descriptor = BUILTIN_PROVIDERS[auth.key];
+		if (!descriptor) continue;
+		const models = promoteDefaultModel(modelsForDescriptor(descriptor), descriptor.defaultModel);
+		for (const model of models) choices.push({
+			id: `${descriptor.key}:${model.id}`,
+			name: `${model.name ?? model.id} (${descriptor.label})`,
+			model: model.id,
+			...model.reasoning === true ? { reasoning: true } : {},
+			...model.options?.length ? { options: model.options.map((option) => ({
+				id: option.id,
+				label: option.label,
+				...option.description ? { description: option.description } : {}
+			})) } : {},
+			provider: () => providerFor(descriptor.key)
+		});
+	}
+	if (choices.length === 0) return void 0;
+	return {
+		models: choices,
+		defaultModelId: choices.find((choice) => choice.id === `${options.provider}:${options.model}` || choice.model === options.model)?.id ?? choices[0].id
+	};
+}
+function promoteDefaultModel(models, defaultModel) {
+	if (!defaultModel) return models;
+	const index = models.findIndex((model) => model.id === defaultModel);
+	if (index <= 0) return models;
+	const next = models.slice();
+	const [selected] = next.splice(index, 1);
+	next.unshift(selected);
+	return next;
+}
+function hasExplicitProviderTarget(argv) {
+	return hasArg(argv, "provider") || hasArg(argv, "model", "m") || hasArg(argv, "models") || hasArg(argv, "model-option");
+}
+function hasArg(argv, long, short) {
+	const longFlag = `--${long}`;
+	const shortFlag = short ? `-${short}` : void 0;
+	return argv.some((arg) => arg === longFlag || arg.startsWith(`${longFlag}=`) || shortFlag !== void 0 && (arg === shortFlag || arg.startsWith(`${shortFlag}=`)));
+}
+function defaultAcpSessionDbPath() {
+	return resolve(resolveStorageDirs({ env: process.env }).dataDir, "acp-sessions.db");
+}
 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}'.`);
@@ -699,9 +425,23 @@ function parseModelOption(raw, options) {
 		id: `${providerName}:${model}`,
 		name: label ?? model,
 		model,
+		...modelChoiceMetadata(providerName, model),
 		provider
 	};
 }
+function modelChoiceMetadata(providerName, modelId) {
+	const descriptor = BUILTIN_PROVIDERS[providerName];
+	if (!descriptor) return {};
+	const model = modelsForDescriptor(descriptor).find((candidate) => candidate.id === modelId);
+	return {
+		...model?.reasoning === true ? { reasoning: true } : {},
+		...model?.options?.length ? { options: model.options.map((option) => ({
+			id: option.id,
+			label: option.label,
+			...option.description ? { description: option.description } : {}
+		})) } : {}
+	};
+}
 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`);