zidane 5.12.10 → 5.13.1

package/dist/acp-CEE6C0m_.js

@@ -0,0 +1,1313 @@
+import { d as createAgent } from "./tools-CfS7rjuh.js";
+import { r as createProcessContext } from "./contexts-DHi8LPCp.js";
+import { o as toolResultToText } from "./types-DxHDaqN7.js";
+import { o as readStateKey, r as hashContent, s as resolveReadStateMap } from "./read-state-DH2IuQHX.js";
+import { l as errorMessage } from "./errors-BpPfMo_4.js";
+import { t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
+import { i as basic_default } from "./presets-5IGiSsxm.js";
+import { r as loadSession, t as createSession } from "./session-B69BQSn1.js";
+import { resolve } from "node:path";
+import { Buffer } from "node:buffer";
+//#region src/acp/json-rpc.ts
+function createJsonRpcConnection(options) {
+	let nextId = 1;
+	let closed = false;
+	let buffer = Buffer.alloc(0);
+	const pending = /* @__PURE__ */ new Map();
+	const writeMessage = (message) => {
+		if (closed) return;
+		const json = JSON.stringify({
+			...message,
+			jsonrpc: "2.0"
+		});
+		if (options.framing === "content-length") {
+			const bytes = Buffer.byteLength(json);
+			options.output.write(`Content-Length: ${bytes}\r\n\r\n${json}`);
+			return;
+		}
+		options.output.write(`${json}\n`);
+	};
+	const handleParsed = async (message) => {
+		if (!isObject$1(message)) {
+			writeMessage(errorResponse(null, -32600, "Invalid JSON-RPC message."));
+			return;
+		}
+		const msg = message;
+		if ("id" in msg && ("result" in msg || "error" in msg)) {
+			const request = pending.get(msg.id);
+			if (!request) return;
+			pending.delete(msg.id);
+			if ("error" in msg && msg.error) request.reject(new JsonRpcRemoteError(msg.error.message, msg.error.code, msg.error.data));
+			else request.resolve(msg.result);
+			return;
+		}
+		if (typeof msg.method !== "string") {
+			writeMessage(errorResponse(("id" in msg ? msg.id : null) ?? null, -32600, "Missing JSON-RPC method."));
+			return;
+		}
+		if ("id" in msg) {
+			try {
+				const response = await options.onRequest(msg);
+				if (response) writeMessage(response);
+			} catch (err) {
+				writeMessage(errorResponse(msg.id, -32603, err instanceof Error ? err.message : String(err)));
+			}
+			return;
+		}
+		try {
+			await options.onNotification?.(msg);
+		} catch (err) {
+			options.onError?.(err instanceof Error ? err : new Error(String(err)));
+		}
+	};
+	const onData = (chunk) => {
+		buffer = Buffer.concat([buffer, typeof chunk === "string" ? Buffer.from(chunk) : chunk]);
+		for (;;) {
+			let parsed;
+			try {
+				parsed = readNextMessage(buffer);
+			} catch (err) {
+				buffer = Buffer.alloc(0);
+				writeMessage(errorResponse(null, -32700, err instanceof Error ? err.message : String(err)));
+				break;
+			}
+			if (!parsed) break;
+			buffer = parsed.rest;
+			handleParsed(parsed.message);
+		}
+	};
+	const onError = (err) => {
+		options.onError?.(err);
+	};
+	return {
+		start() {
+			options.input.on("data", onData);
+			options.input.on("error", onError);
+		},
+		close() {
+			closed = true;
+			options.input.off("data", onData);
+			options.input.off("error", onError);
+			for (const request of pending.values()) request.reject(/* @__PURE__ */ new Error("JSON-RPC connection closed."));
+			pending.clear();
+		},
+		sendNotification(method, params) {
+			writeMessage({
+				jsonrpc: "2.0",
+				method,
+				...params !== void 0 ? { params } : {}
+			});
+		},
+		sendRequest(method, params) {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("JSON-RPC connection is closed."));
+			const id = nextId++;
+			writeMessage({
+				jsonrpc: "2.0",
+				id,
+				method,
+				...params !== void 0 ? { params } : {}
+			});
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					resolve,
+					reject
+				});
+			});
+		}
+	};
+}
+var JsonRpcRemoteError = class extends Error {
+	code;
+	data;
+	constructor(message, code, data) {
+		super(message);
+		this.code = code;
+		this.data = data;
+		this.name = "JsonRpcRemoteError";
+	}
+};
+function successResponse(id, result = {}) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function errorResponse(id, code, message, data) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code,
+			message,
+			...data !== void 0 ? { data } : {}
+		}
+	};
+}
+function readNextMessage(input) {
+	if (input.length === 0) return null;
+	const headerEnd = input.indexOf("\r\n\r\n");
+	if (headerEnd >= 0) {
+		const header = input.subarray(0, headerEnd).toString("utf8");
+		const match = /^Content-Length:\s*(\d+)/im.exec(header);
+		if (!match) return readLineMessage(input);
+		const length = Number(match[1]);
+		const bodyStart = headerEnd + 4;
+		const bodyEnd = bodyStart + length;
+		if (input.length < bodyEnd) return null;
+		const body = input.subarray(bodyStart, bodyEnd).toString("utf8");
+		return {
+			message: JSON.parse(body),
+			rest: input.subarray(bodyEnd)
+		};
+	}
+	if (/^Content-Length:/i.test(input.subarray(0, Math.min(input.length, 32)).toString("utf8"))) return null;
+	return readLineMessage(input);
+}
+function readLineMessage(input) {
+	let rest = input;
+	for (;;) {
+		const lineEnd = rest.indexOf("\n");
+		if (lineEnd < 0) return null;
+		const line = rest.subarray(0, lineEnd).toString("utf8").trim();
+		rest = rest.subarray(lineEnd + 1);
+		if (line.length === 0) continue;
+		return {
+			message: JSON.parse(line),
+			rest
+		};
+	}
+}
+function isObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/acp/mapping.ts
+function acpMcpServersToZidane(servers) {
+	if (!servers) return [];
+	return servers.map((server) => {
+		if (server.type === "http") return {
+			name: server.name,
+			transport: "streamable-http",
+			url: server.url,
+			headers: headersToRecord(server.headers)
+		};
+		if (server.type === "sse") return {
+			name: server.name,
+			transport: "sse",
+			url: server.url,
+			headers: headersToRecord(server.headers)
+		};
+		const stdio = server;
+		return {
+			name: server.name,
+			transport: "stdio",
+			command: stdio.command,
+			args: stdio.args ?? [],
+			env: envToRecord(stdio.env)
+		};
+	});
+}
+function promptCapabilitiesForProvider(capabilities) {
+	return {
+		image: capabilities?.vision === true,
+		audio: capabilities?.audio === true,
+		embeddedContext: true
+	};
+}
+function mcpCapabilities() {
+	return {
+		http: true,
+		sse: true
+	};
+}
+function defaultModes(modes) {
+	return modes && modes.length > 0 ? [...modes] : [{
+		id: "build",
+		name: "Build",
+		description: "Full tool access for implementation work."
+	}, {
+		id: "plan",
+		name: "Plan",
+		description: "Planning-oriented mode; hosts may narrow tools separately."
+	}];
+}
+function makeModeState(modes, currentModeId) {
+	return {
+		currentModeId,
+		availableModes: [...modes]
+	};
+}
+function newSessionResponse(sessionId, modes, currentModeId, configOptions) {
+	return {
+		sessionId,
+		modes: makeModeState(modes, currentModeId),
+		...configOptions && configOptions.length > 0 ? { configOptions } : {}
+	};
+}
+function acpPromptToPromptParts(prompt) {
+	const parts = [];
+	const warnings = [];
+	for (const block of prompt) switch (block.type) {
+		case "text":
+			parts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "image":
+			if (block.data) parts.push({
+				type: "image",
+				mediaType: block.mimeType || "image/png",
+				data: block.data
+			});
+			else {
+				warnings.push(`Image resource linked instead of embedded: ${block.uri ?? "unknown URI"}`);
+				parts.push({
+					type: "text",
+					text: `[image resource: ${block.uri ?? "unavailable"}]`
+				});
+			}
+			break;
+		case "audio":
+			if (block.data) parts.push({
+				type: "audio",
+				mediaType: block.mimeType || "audio/mpeg",
+				data: block.data
+			});
+			else {
+				warnings.push("Audio block omitted because it did not include embedded data.");
+				parts.push({
+					type: "text",
+					text: "[audio resource omitted: no embedded data]"
+				});
+			}
+			break;
+		case "resource_link":
+			parts.push({
+				type: "text",
+				text: renderResourceLink(block)
+			});
+			break;
+		case "resource":
+			parts.push(resourceToPromptPart(block));
+			break;
+		default:
+			warnings.push("Unknown ACP content block converted to text.");
+			parts.push({
+				type: "text",
+				text: JSON.stringify(block)
+			});
+			break;
+	}
+	return {
+		prompt: parts,
+		warnings
+	};
+}
+function sessionBlocksToAcp(blocks) {
+	const out = [];
+	for (const block of blocks) if (block.type === "text" || block.type === "thinking") out.push({
+		type: "text",
+		text: block.text
+	});
+	else if (block.type === "image") out.push(imageBlockToAcp(block.mediaType, "data" in block ? block.data : void 0, "ref" in block ? block.ref : void 0, block.name));
+	else if (block.type === "audio") {
+		if (block.data) out.push({
+			type: "audio",
+			mimeType: block.mediaType,
+			data: block.data
+		});
+	} else if (block.type === "document") out.push(documentBlockToAcp(block.mediaType, "data" in block ? block.data : void 0, "ref" in block ? block.ref : void 0, block.encoding, block.name));
+	return out;
+}
+function toolResultToAcpContent(content) {
+	if (typeof content === "string") return [{
+		type: "content",
+		content: {
+			type: "text",
+			text: content
+		}
+	}];
+	return content.map((block) => {
+		if (block.type === "text") return {
+			type: "content",
+			content: {
+				type: "text",
+				text: block.text
+			}
+		};
+		if (block.type === "image") return {
+			type: "content",
+			content: imageBlockToAcp(block.mediaType, "data" in block ? block.data : void 0, "ref" in block ? block.ref : void 0, "name" in block ? block.name : void 0)
+		};
+		if (block.type === "audio" && block.data) return {
+			type: "content",
+			content: {
+				type: "audio",
+				mimeType: block.mediaType,
+				data: block.data
+			}
+		};
+		if (block.type === "document") return {
+			type: "content",
+			content: documentBlockToAcp(block.mediaType, "data" in block ? block.data : void 0, "ref" in block ? block.ref : void 0, block.encoding, "name" in block ? block.name : void 0)
+		};
+		return {
+			type: "content",
+			content: {
+				type: "text",
+				text: toolResultToText([block])
+			}
+		};
+	});
+}
+/**
+* Build a spec-valid ACP image block. `ImageContent` requires `data` +
+* `mimeType`; when we only have a reference (`ref`/uri) we fall back to a
+* `resource_link` (which requires `name` + `uri`) so we never emit an image
+* block missing its required `data`.
+*/
+function imageBlockToAcp(mimeType, data, ref, name) {
+	if (data) return {
+		type: "image",
+		mimeType,
+		data,
+		...ref ? { uri: ref } : {}
+	};
+	return {
+		type: "resource_link",
+		uri: ref ?? acpSyntheticUri("image", name),
+		name: name ?? "image",
+		mimeType
+	};
+}
+/**
+* Build a spec-valid embedded `resource` (or a `resource_link` fallback for
+* reference-only documents). `EmbeddedResource.resource` requires a `uri`
+* plus either `text` (text payload) or `blob` (base64), so a synthetic URI is
+* minted when the source block has none.
+*/
+function documentBlockToAcp(mimeType, data, ref, encoding, name) {
+	const uri = ref ?? acpSyntheticUri("document", name);
+	if (typeof data !== "string") return {
+		type: "resource_link",
+		uri,
+		name: name ?? "document",
+		mimeType
+	};
+	return {
+		type: "resource",
+		resource: encoding === "text" ? {
+			uri,
+			text: data,
+			mimeType
+		} : {
+			uri,
+			blob: data,
+			mimeType
+		}
+	};
+}
+function acpSyntheticUri(kind, name) {
+	return `acp:///${kind}/${(name ?? kind).replace(/[^\w.-]+/g, "_")}`;
+}
+function toolKindForName(name) {
+	if (name === "read_file" || name === "list_files") return "read";
+	if (name === "write_file" || name === "edit" || name === "multi_edit") return "edit";
+	if (name === "grep" || name === "glob" || name === "tool_search") return "search";
+	if (name === "shell" || name === "wait_task" || name === "shell_kill") return "execute";
+	if (name === "web_search" || name === "fetch_url") return "fetch";
+	if (name === "present_plan" || name === "ask_user") return "think";
+	return "other";
+}
+function stopReasonFromRun(input) {
+	if (input.aborted) return "cancelled";
+	if (input.maxTurnsReached) return "max_turn_requests";
+	switch (lastFinishReason$1(input.turnUsage)) {
+		case "length": return "max_tokens";
+		case "content-filter":
+		case "error": return "refusal";
+		default: return "end_turn";
+	}
+}
+function usageCost(cost) {
+	if (typeof cost !== "number" || !Number.isFinite(cost)) return null;
+	return {
+		amount: cost,
+		currency: "USD"
+	};
+}
+function resolveAcpPath(cwd, path) {
+	return path.startsWith("/") ? path : resolve(cwd, path);
+}
+function lastFinishReason$1(turnUsage) {
+	for (let i = (turnUsage?.length ?? 0) - 1; i >= 0; i--) {
+		const reason = turnUsage?.[i]?.finishReason;
+		if (reason) return reason;
+	}
+}
+function headersToRecord(headers) {
+	const out = {};
+	for (const header of headers ?? []) out[header.name] = header.value;
+	return out;
+}
+function envToRecord(env) {
+	const out = {};
+	for (const item of env ?? []) out[item.name] = item.value;
+	return out;
+}
+function renderResourceLink(block) {
+	const label = block.title ?? block.name ?? block.uri;
+	return block.mimeType ? `[resource: ${label}](${block.uri}) (${block.mimeType})` : `[resource: ${label}](${block.uri})`;
+}
+function resourceToPromptPart(block) {
+	const resource = block.resource;
+	const mediaType = resource.mimeType ?? "text/plain";
+	const name = nameFromUri(resource.uri);
+	if ("text" in resource && typeof resource.text === "string") return {
+		type: "document",
+		mediaType,
+		data: resource.text,
+		encoding: "text",
+		...name ? { name } : {}
+	};
+	if ("blob" in resource && typeof resource.blob === "string") return {
+		type: "document",
+		mediaType,
+		data: resource.blob,
+		encoding: "base64",
+		...name ? { name } : {}
+	};
+	return {
+		type: "text",
+		text: `[resource omitted: ${resource.uri}]`
+	};
+}
+function nameFromUri(uri) {
+	if (!uri) return void 0;
+	const segment = uri.replace(/[/\\]+$/, "").split(/[/\\]/).pop();
+	return segment && segment.length > 0 ? segment : void 0;
+}
+//#endregion
+//#region src/acp/client-tools.ts
+function wrapToolsForAcpClient(tools, options) {
+	if (!tools) return void 0;
+	const wrapped = { ...tools };
+	const readFileEntry = findToolEntry(tools, "read_file");
+	const writeFileEntry = findToolEntry(tools, "write_file");
+	const shellEntry = findToolEntry(tools, "shell");
+	if (options.useClientFileSystem !== false && options.capabilities.fs?.readTextFile && readFileEntry) wrapped[readFileEntry.key] = wrapReadFile(readFileEntry.tool, options);
+	if (options.useClientFileSystem !== false && options.capabilities.fs?.writeTextFile && writeFileEntry) wrapped[writeFileEntry.key] = wrapWriteFile(writeFileEntry.tool, options);
+	if (options.useClientTerminal !== false && options.capabilities.terminal && shellEntry) wrapped[shellEntry.key] = wrapShell(shellEntry.tool, options);
+	return wrapped;
+}
+function findToolEntry(tools, canonicalName) {
+	for (const [key, tool] of Object.entries(tools)) if (key === canonicalName || tool.spec.name === canonicalName) return {
+		key,
+		tool
+	};
+	return null;
+}
+function wrapReadFile(base, options) {
+	return {
+		...base,
+		async execute(input, ctx) {
+			const path = typeof input.path === "string" ? input.path : "";
+			if (!path) return "Read error: missing path.";
+			const absPath = resolveAcpPath(ctx.handle.cwd, path);
+			const line = lineOrDefault(input.offset);
+			const limit = positiveNumberOrNull(input.limit);
+			const response = await options.client.sendRequest("fs/read_text_file", {
+				sessionId: options.sessionId,
+				path: absPath,
+				line,
+				...limit !== null ? { limit } : {}
+			});
+			const content = typeof response.content === "string" ? response.content : "";
+			seedReadState(ctx, absPath, content, line ?? 1, limit ?? Number.POSITIVE_INFINITY);
+			if (input.lineNumbers === false) return content;
+			return withLineNumbers(content, line ?? 1);
+		}
+	};
+}
+function wrapWriteFile(base, options) {
+	return {
+		...base,
+		async execute(input, ctx) {
+			const path = typeof input.path === "string" ? input.path : "";
+			const content = typeof input.content === "string" ? input.content : "";
+			if (!path) return "Write error: missing path.";
+			const absPath = resolveAcpPath(ctx.handle.cwd, path);
+			await options.client.sendRequest("fs/write_text_file", {
+				sessionId: options.sessionId,
+				path: absPath,
+				content
+			});
+			seedReadState(ctx, absPath, content, 0, Number.POSITIVE_INFINITY);
+			ctx.reportOutcome?.("updated");
+			return `Wrote ${absPath} (${Buffer.byteLength(content)} bytes).`;
+		}
+	};
+}
+function wrapShell(base, options) {
+	return {
+		...base,
+		spec: withoutShellBackgroundInput(base.spec),
+		async execute(input, ctx) {
+			const command = typeof input.command === "string" ? input.command : "";
+			if (!command) return "shell error: missing command.";
+			if (input.run_in_background === true) return "shell error: background mode is not supported through ACP terminal callbacks. Run the command in the foreground.";
+			const request = {
+				sessionId: options.sessionId,
+				command,
+				cwd: ctx.handle.cwd,
+				outputByteLimit: typeof input.maxOutputBytes === "number" ? input.maxOutputBytes : null
+			};
+			const created = await options.client.sendRequest("terminal/create", request);
+			const terminalId = typeof created.terminalId === "string" ? created.terminalId : "";
+			if (!terminalId) return "shell error: ACP client did not return a terminal id.";
+			try {
+				const exit = await options.client.sendRequest("terminal/wait_for_exit", {
+					sessionId: options.sessionId,
+					terminalId
+				});
+				return formatTerminalOutput(await options.client.sendRequest("terminal/output", {
+					sessionId: options.sessionId,
+					terminalId
+				}), exit);
+			} finally {
+				await options.client.sendRequest("terminal/release", {
+					sessionId: options.sessionId,
+					terminalId
+				}).catch(() => void 0);
+			}
+		}
+	};
+}
+function formatTerminalOutput(output, exit) {
+	const body = output.output || "(no output)";
+	const code = exit.exitCode ?? output.exitStatus?.exitCode;
+	const signal = exit.signal ?? output.exitStatus?.signal;
+	const suffix = signal ? `\n(signal ${signal})` : typeof code === "number" ? `\n(exit ${code})` : "";
+	return `${body}${output.truncated ? "\n(output truncated by ACP client)" : ""}${suffix}`;
+}
+function withoutShellBackgroundInput(spec) {
+	const properties = isRecord(spec.inputSchema.properties) ? spec.inputSchema.properties : void 0;
+	if (!properties || !Object.hasOwn(properties, "run_in_background")) return spec;
+	const { run_in_background: _runInBackground, ...nextProperties } = properties;
+	const required = Array.isArray(spec.inputSchema.required) ? spec.inputSchema.required.filter((name) => name !== "run_in_background") : spec.inputSchema.required;
+	return {
+		...spec,
+		description: spec.description.split("\n").filter((line) => !line.includes("run_in_background") && !line.includes("<task-notification>") && !line.includes("background task")).join("\n"),
+		inputSchema: {
+			...spec.inputSchema,
+			properties: nextProperties,
+			...required ? { required } : {}
+		}
+	};
+}
+function withLineNumbers(content, start) {
+	return content.split("\n").map((line, index) => `${start + index}\t${line}`).join("\n");
+}
+function lineOrDefault(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.trunc(value) : 1;
+}
+function positiveNumberOrNull(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : null;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function seedReadState(ctx, path, content, offset, limit) {
+	const readState = resolveReadStateMap(ctx);
+	if (!readState) return;
+	readState.set(readStateKey(ctx.handle.cwd, path), {
+		contentHash: hashContent(content),
+		offset,
+		limit,
+		maxBytes: Number.POSITIVE_INFINITY,
+		mtimeMs: Date.now()
+	});
+}
+//#endregion
+//#region src/acp/server.ts
+const ACP_AGENT_VERSION = "1";
+const DEFAULT_PERMISSION_OPTIONS = [
+	{
+		optionId: "allow_once",
+		name: "Allow once",
+		kind: "allow_once"
+	},
+	{
+		optionId: "allow_always",
+		name: "Always allow",
+		kind: "allow_always"
+	},
+	{
+		optionId: "reject_once",
+		name: "Reject once",
+		kind: "reject_once"
+	},
+	{
+		optionId: "reject_always",
+		name: "Always reject",
+		kind: "reject_always"
+	}
+];
+function createAcpServer(options) {
+	return new AcpServerImpl(options);
+}
+var AcpServerImpl = class {
+	options;
+	peer = null;
+	clientCapabilities = {};
+	sessions = /* @__PURE__ */ new Map();
+	modes;
+	defaultModeId;
+	defaultConfigOptions;
+	constructor(options) {
+		this.options = options;
+		this.modes = defaultModes(options.modes);
+		this.defaultModeId = options.defaultModeId ?? this.modes[0]?.id ?? "build";
+		this.defaultConfigOptions = options.configOptions ?? [];
+	}
+	setPeer(peer) {
+		this.peer = peer;
+	}
+	async handleMessage(message) {
+		if (!isObject(message) || typeof message.method !== "string") return errorResponse(normalizeId("id" in message ? message.id : null), -32600, "Invalid JSON-RPC request.");
+		if (!("id" in message)) {
+			await this.handleNotification(message.method, message.params);
+			return null;
+		}
+		const request = message;
+		try {
+			const result = await this.handleRequest(request.method, request.params);
+			return successResponse(request.id, result);
+		} catch (err) {
+			const rpcError = toRpcError(err);
+			return errorResponse(request.id, rpcError.code, rpcError.message, rpcError.data);
+		}
+	}
+	async handleRequest(method, params) {
+		switch (method) {
+			case "initialize": return this.initialize(asObject(params));
+			case "authenticate": return this.authenticate(asObject(params));
+			case "logout": return this.logout();
+			case "session/new": return this.newSession(asObject(params));
+			case "session/load": return this.loadExistingSession(asObject(params));
+			case "session/resume": return this.resumeSession(asObject(params));
+			case "session/list": return this.listSessions(asObject(params));
+			case "session/delete": return this.deleteSession(asObject(params));
+			case "session/close": return this.closeSession(asObject(params));
+			case "session/prompt": return this.prompt(asObject(params));
+			case "session/set_mode": return this.setMode(asObject(params));
+			case "session/set_config_option": return this.setConfigOption(asObject(params));
+			default: throw new AcpProtocolError(-32601, `Unknown ACP method: ${method}`);
+		}
+	}
+	async notify(method, params) {
+		await this.peer?.sendNotification(method, params);
+	}
+	async close() {
+		const sessions = [...this.sessions.values()];
+		this.sessions.clear();
+		await Promise.allSettled(sessions.map(async (runtime) => {
+			runtime.abortController?.abort(/* @__PURE__ */ new Error("ACP server closing."));
+			await runtime.agent.destroy();
+		}));
+	}
+	async handleNotification(method, params) {
+		switch (method) {
+			case "session/cancel":
+				this.cancel(asObject(params));
+				break;
+			default: break;
+		}
+	}
+	initialize(params) {
+		this.clientCapabilities = params.clientCapabilities ?? {};
+		const provider = this.resolveProvider();
+		return {
+			protocolVersion: params.protocolVersion === 1 ? params.protocolVersion : 1,
+			agentCapabilities: {
+				loadSession: true,
+				promptCapabilities: promptCapabilitiesForProvider(provider.meta.capabilities),
+				mcpCapabilities: mcpCapabilities(),
+				sessionCapabilities: {
+					list: {},
+					delete: {},
+					resume: {},
+					close: {},
+					additionalDirectories: {}
+				},
+				auth: { ...this.options.logout ? { logout: {} } : {} }
+			},
+			agentInfo: this.options.agentInfo ?? {
+				name: "zidane",
+				title: "Zidane ACP",
+				version: ACP_AGENT_VERSION
+			},
+			authMethods: this.options.authMethods ?? []
+		};
+	}
+	async authenticate(params) {
+		if (!this.options.authenticate) return {};
+		return await this.options.authenticate(params);
+	}
+	async logout() {
+		if (!this.options.logout) return {};
+		return await this.options.logout();
+	}
+	async newSession(params) {
+		const runtime = await this.createRuntime(params);
+		this.deferAvailableCommands(runtime.sessionId);
+		return newSessionResponse(runtime.sessionId, this.modes, runtime.modeId, runtime.configOptions);
+	}
+	async loadExistingSession(params) {
+		const runtime = await this.createRuntime(params, params.sessionId, true);
+		await this.replayHistory(runtime);
+		this.deferAvailableCommands(runtime.sessionId);
+		return this.sessionStateResponse(runtime);
+	}
+	async resumeSession(params) {
+		const runtime = await this.createRuntime({
+			cwd: params.cwd,
+			additionalDirectories: params.additionalDirectories,
+			mcpServers: params.mcpServers ?? []
+		}, params.sessionId, true);
+		this.deferAvailableCommands(runtime.sessionId);
+		return this.sessionStateResponse(runtime);
+	}
+	sessionStateResponse(runtime) {
+		return {
+			modes: makeModeState(this.modes, runtime.modeId),
+			...runtime.configOptions.length > 0 ? { configOptions: runtime.configOptions } : {}
+		};
+	}
+	deferAvailableCommands(sessionId) {
+		if (!this.options.commands || this.options.commands.length === 0) return;
+		setTimeout(() => {
+			this.sessionUpdate(sessionId, {
+				sessionUpdate: "available_commands_update",
+				availableCommands: this.options.commands
+			});
+		}, 0);
+	}
+	async replayHistory(runtime) {
+		for (const turn of runtime.session.turns) {
+			const blocks = sessionBlocksToAcp(turn.content);
+			if (blocks.length === 0) continue;
+			const sessionUpdate = turn.role === "assistant" ? "agent_message_chunk" : "user_message_chunk";
+			for (const content of blocks) await this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate,
+				content
+			});
+		}
+	}
+	async listSessions(params) {
+		const store = this.options.store;
+		if (!store) return {
+			sessions: [...this.sessions.values()].filter((runtime) => !params.cwd || runtime.cwd === params.cwd).map((runtime) => sessionInfo(runtime)),
+			nextCursor: null
+		};
+		const ids = await store.list({
+			limit: 100,
+			...params.cwd ? { projectRoot: params.cwd } : {}
+		});
+		const sessions = [];
+		for (const id of ids) {
+			const loaded = await store.load(id);
+			if (!loaded) continue;
+			const cwd = loaded.projectRoot ?? params.cwd ?? this.sessions.get(loaded.id)?.cwd;
+			if (!cwd) continue;
+			sessions.push({
+				sessionId: loaded.id,
+				cwd,
+				title: typeof loaded.metadata.title === "string" ? loaded.metadata.title : null,
+				updatedAt: new Date(loaded.updatedAt).toISOString()
+			});
+		}
+		return {
+			sessions,
+			nextCursor: null
+		};
+	}
+	async deleteSession(params) {
+		const runtime = this.sessions.get(params.sessionId);
+		if (runtime) {
+			runtime.abortController?.abort(/* @__PURE__ */ new Error("ACP session deleted."));
+			await runtime.agent.destroy();
+			this.sessions.delete(params.sessionId);
+		}
+		await this.options.store?.delete(params.sessionId);
+		return {};
+	}
+	async closeSession(params) {
+		const runtime = this.requireSession(params.sessionId);
+		runtime.abortController?.abort(/* @__PURE__ */ new Error("ACP session closed."));
+		await runtime.agent.destroy();
+		this.sessions.delete(params.sessionId);
+		return {};
+	}
+	async prompt(params) {
+		const runtime = this.requireSession(params.sessionId);
+		if (runtime.inFlight) throw new AcpProtocolError(-32600, `Session ${params.sessionId} already has an in-flight prompt.`);
+		const mapped = acpPromptToPromptParts(params.prompt);
+		const abortController = new AbortController();
+		runtime.abortController = abortController;
+		const run = async () => {
+			let stats;
+			let aborted = false;
+			try {
+				for (const warning of mapped.warnings) await this.sessionUpdate(runtime.sessionId, {
+					sessionUpdate: "agent_thought_chunk",
+					content: {
+						type: "text",
+						text: warning
+					}
+				});
+				stats = await runtime.agent.run({
+					prompt: mapped.prompt,
+					...this.options.model ? { model: this.options.model } : {},
+					...this.options.system ? { system: this.options.system } : {},
+					signal: abortController.signal
+				});
+			} catch (err) {
+				aborted = abortController.signal.aborted;
+				if (!aborted) throw err;
+			} finally {
+				runtime.abortController = void 0;
+				runtime.inFlight = void 0;
+			}
+			return { stopReason: stopReasonFromRun({
+				aborted: aborted || abortController.signal.aborted,
+				turnUsage: stats?.turnUsage,
+				maxTurnsReached: stats ? reachedMaxTurns(stats, this.options.behavior) : false
+			}) };
+		};
+		const inFlight = run();
+		runtime.inFlight = inFlight;
+		return await inFlight;
+	}
+	cancel(params) {
+		const runtime = this.sessions.get(params.sessionId);
+		runtime?.abortController?.abort(/* @__PURE__ */ new Error("Cancelled by ACP client."));
+		runtime?.agent.abort();
+	}
+	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;
+		await this.sessionUpdate(params.sessionId, {
+			sessionUpdate: "current_mode_update",
+			currentModeId: params.modeId
+		});
+		return {};
+	}
+	async setConfigOption(params) {
+		const runtime = this.requireSession(params.sessionId);
+		const configOptions = this.applyConfigSelection(runtime, params.configId, params.value);
+		runtime.config.set(params.configId, params.value);
+		await this.sessionUpdate(params.sessionId, {
+			sessionUpdate: "config_option_update",
+			configOptions
+		});
+		return { configOptions };
+	}
+	/** Reflect a `select` choice back into the advertised option set's `currentValue`. */
+	applyConfigSelection(runtime, configId, value) {
+		const option = runtime.configOptions.find((candidate) => candidate.id === configId);
+		if (!option) throw new AcpProtocolError(-32602, `Unknown config option: ${configId}`);
+		if (!configOptionHasValue(option, value)) throw new AcpProtocolError(-32602, `Invalid value for config option ${configId}: ${value}`);
+		runtime.configOptions = runtime.configOptions.map((candidate) => candidate.id === configId ? {
+			...candidate,
+			currentValue: value
+		} : candidate);
+		return runtime.configOptions;
+	}
+	async createRuntime(params, requestedSessionId, mustExist = false) {
+		if (requestedSessionId) {
+			const existing = this.sessions.get(requestedSessionId);
+			if (existing) {
+				if (existing.cwd !== params.cwd) throw new AcpProtocolError(-32602, `Session ${requestedSessionId} belongs to cwd ${existing.cwd}, not ${params.cwd}.`);
+				const nextAdditionalDirectories = params.additionalDirectories ?? existing.additionalDirectories;
+				const nextMcpServers = params.mcpServers === void 0 ? existing.mcpServers : acpMcpServersToZidane(params.mcpServers);
+				if (!sameStringArray(existing.additionalDirectories, nextAdditionalDirectories)) throw new AcpProtocolError(-32602, `Session ${requestedSessionId} is already active with different additionalDirectories; close it before resuming with changed roots.`);
+				if (!sameJson(existing.mcpServers, nextMcpServers)) throw new AcpProtocolError(-32602, `Session ${requestedSessionId} is already active with different MCP servers; close it before resuming with changed MCP configuration.`);
+				return existing;
+			}
+		}
+		const mcpServers = acpMcpServersToZidane(params.mcpServers);
+		const session = await this.resolveSession(requestedSessionId, params.cwd, mustExist);
+		const execution = this.resolveExecution(params);
+		const provider = this.resolveProvider();
+		const sessionId = session.id;
+		const base = this.options.preset ?? basic_default;
+		const agentOptions = this.options.agentOptions ?? {};
+		const wrappedTools = wrapToolsForAcpClient(mergeTools(base.tools, agentOptions.tools, this.options.tools), {
+			client: this.requirePeer(),
+			sessionId,
+			capabilities: this.clientCapabilities,
+			useClientFileSystem: this.options.useClientFileSystem,
+			useClientTerminal: this.options.useClientTerminal
+		});
+		const behavior = {
+			...base.behavior,
+			...agentOptions.behavior,
+			...this.options.behavior
+		};
+		const agent = createAgent({
+			...base,
+			...agentOptions,
+			provider,
+			execution,
+			session,
+			tools: wrappedTools,
+			behavior,
+			mcpServers: mergeMcpServers(base.mcpServers, agentOptions.mcpServers, this.options.agentOptions?.mcpServers, mcpServers),
+			...this.options.system ? { system: this.options.system } : {}
+		});
+		const runtime = {
+			sessionId,
+			cwd: params.cwd,
+			additionalDirectories: params.additionalDirectories ?? [],
+			mcpServers,
+			session,
+			execution,
+			agent,
+			modeId: this.defaultModeId,
+			configOptions: cloneConfigOptions(this.defaultConfigOptions),
+			config: /* @__PURE__ */ new Map()
+		};
+		this.installHookAdapter(runtime);
+		this.sessions.set(sessionId, runtime);
+		session.setMeta("acp.cwd", params.cwd);
+		session.setMeta("acp.additionalDirectories", params.additionalDirectories ?? []);
+		if (session.store) await session.save().catch(() => void 0);
+		return runtime;
+	}
+	async resolveSession(sessionId, cwd, mustExist) {
+		const store = this.options.store;
+		if (sessionId && this.sessions.has(sessionId)) return this.sessions.get(sessionId).session;
+		if (sessionId && store) {
+			const existing = await loadSession(store, sessionId);
+			if (existing) return existing;
+			if (mustExist) throw new AcpProtocolError(-32002, `Unknown session: ${sessionId}`);
+			const created = await createSession({
+				id: sessionId,
+				store,
+				projectRoot: cwd,
+				metadata: { title: "ACP session" }
+			});
+			await created.save();
+			return created;
+		}
+		if (sessionId && mustExist) throw new AcpProtocolError(-32002, `Unknown session: ${sessionId}`);
+		const created = await createSession({
+			...sessionId ? { id: sessionId } : {},
+			...store ? { store } : {},
+			projectRoot: cwd,
+			metadata: { title: "ACP session" }
+		});
+		if (store) await created.save();
+		return created;
+	}
+	resolveExecution(params) {
+		if (typeof this.options.execution === "function") return this.options.execution(params);
+		return this.options.execution ?? createProcessContext({ cwd: params.cwd });
+	}
+	resolveProvider() {
+		return typeof this.options.provider === "function" ? this.options.provider() : this.options.provider;
+	}
+	installHookAdapter(runtime) {
+		const seenTools = /* @__PURE__ */ new Set();
+		runtime.agent.hooks.hook("stream:text", ({ delta, turnId }) => {
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "agent_message_chunk",
+				messageId: turnId,
+				content: {
+					type: "text",
+					text: delta
+				}
+			});
+		});
+		runtime.agent.hooks.hook("stream:thinking", ({ delta, turnId }) => {
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "agent_thought_chunk",
+				messageId: turnId,
+				content: {
+					type: "text",
+					text: delta
+				}
+			});
+		});
+		runtime.agent.hooks.hook("tool:gate", async (ctx) => {
+			if (!this.shouldRequestPermission(ctx.name, ctx.input)) return;
+			const key = permissionKey(ctx.name, ctx.input);
+			const cached = runtime.config.get(key);
+			if (cached === "allow") return;
+			if (cached === "reject") {
+				ctx.block = true;
+				ctx.reason = "Rejected by prior ACP permission decision.";
+				return;
+			}
+			const outcome = await this.requestPermission(runtime, {
+				toolCallId: ctx.callId,
+				title: ctx.name,
+				kind: toolKindForName(ctx.name),
+				status: "pending",
+				rawInput: ctx.input
+			});
+			if (outcome.outcome === "cancelled") {
+				ctx.block = true;
+				ctx.reason = "Cancelled by ACP client.";
+				return;
+			}
+			if (outcome.optionId === "allow_always") runtime.config.set(key, "allow");
+			if (outcome.optionId === "reject_always") runtime.config.set(key, "reject");
+			if (outcome.optionId.startsWith("reject")) {
+				ctx.block = true;
+				ctx.reason = "Rejected by ACP client.";
+			}
+		});
+		runtime.agent.hooks.hook("tool:dispatched", (ctx) => {
+			seenTools.add(ctx.callId);
+			const status = ctx.outcome === "gate-block" || ctx.outcome === "invalid-input" || ctx.outcome === "unknown" ? "failed" : "pending";
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "tool_call",
+				toolCallId: ctx.callId,
+				title: ctx.name,
+				kind: toolKindForName(ctx.name),
+				status,
+				rawInput: ctx.input,
+				...status === "failed" ? { rawOutput: ctx.reason ?? ctx.outcome } : {}
+			});
+		});
+		runtime.agent.hooks.hook("tool:before", (ctx) => {
+			if (!seenTools.has(ctx.callId)) {
+				this.sessionUpdate(runtime.sessionId, {
+					sessionUpdate: "tool_call",
+					toolCallId: ctx.callId,
+					title: ctx.name,
+					kind: toolKindForName(ctx.name),
+					status: "in_progress",
+					rawInput: ctx.input
+				});
+				return;
+			}
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "tool_call_update",
+				toolCallId: ctx.callId,
+				status: "in_progress"
+			});
+		});
+		runtime.agent.hooks.hook("tool:after", (ctx) => {
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "tool_call_update",
+				toolCallId: ctx.callId,
+				status: "completed",
+				content: toolResultToAcpContent(ctx.result),
+				rawOutput: ctx.result
+			});
+		});
+		runtime.agent.hooks.hook("tool:error", (ctx) => {
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "tool_call_update",
+				toolCallId: ctx.callId,
+				status: "failed",
+				rawOutput: errorMessage(ctx.error)
+			});
+		});
+		runtime.agent.hooks.hook("tool:cancelled", (ctx) => {
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "tool_call_update",
+				toolCallId: ctx.callId,
+				status: "failed",
+				rawOutput: ctx.reason ?? "cancelled"
+			});
+		});
+		runtime.agent.hooks.hook("turn:after", ({ usage, cumulativeUsage }) => {
+			const size = this.resolveContextWindow();
+			if (size === void 0) return;
+			const used = effectiveInputFromTurn(usage);
+			if (used <= 0) return;
+			const cost = usageCost(cumulativeUsage.cost);
+			this.sessionUpdate(runtime.sessionId, {
+				sessionUpdate: "usage_update",
+				used,
+				size,
+				...cost ? { cost } : {}
+			});
+		});
+	}
+	resolveContextWindow() {
+		if (typeof this.options.contextWindow === "number" && this.options.contextWindow > 0) return this.options.contextWindow;
+		const fromBehavior = this.options.behavior?.autoCompact;
+		if (fromBehavior && typeof fromBehavior === "object" && typeof fromBehavior.contextWindow === "number" && fromBehavior.contextWindow > 0) return fromBehavior.contextWindow;
+		const meta = this.resolveProvider().meta;
+		if (typeof meta.contextWindow === "number" && meta.contextWindow > 0) return meta.contextWindow;
+	}
+	shouldRequestPermission(name, input) {
+		const policy = this.options.permission;
+		if (policy?.enabled !== true || !this.peer) return false;
+		if (policy.toolMatcher) return policy.toolMatcher(name, input);
+		return name === "shell" || name === "write_file" || name === "edit" || name === "multi_edit";
+	}
+	async requestPermission(runtime, toolCall) {
+		const request = this.requirePeer().sendRequest("session/request_permission", {
+			sessionId: runtime.sessionId,
+			toolCall,
+			options: this.options.permission?.options ?? DEFAULT_PERMISSION_OPTIONS
+		});
+		const aborted = new Promise((resolve) => {
+			const signal = runtime.abortController?.signal;
+			if (!signal) return;
+			if (signal.aborted) {
+				resolve({ outcome: { outcome: "cancelled" } });
+				return;
+			}
+			signal.addEventListener("abort", () => resolve({ outcome: { outcome: "cancelled" } }), { once: true });
+		});
+		return (await Promise.race([request, aborted])).outcome ?? { outcome: "cancelled" };
+	}
+	async sessionUpdate(sessionId, update) {
+		await this.notify("session/update", {
+			sessionId,
+			update
+		});
+	}
+	requireSession(sessionId) {
+		const runtime = this.sessions.get(sessionId);
+		if (!runtime) throw new AcpProtocolError(-32002, `Unknown session: ${sessionId}`);
+		return runtime;
+	}
+	requirePeer() {
+		if (!this.peer) return {
+			sendNotification: () => void 0,
+			sendRequest: () => Promise.reject(new AcpProtocolError(-32601, "No ACP client peer is attached."))
+		};
+		return this.peer;
+	}
+};
+var AcpProtocolError = class extends Error {
+	code;
+	data;
+	constructor(code, message, data) {
+		super(message);
+		this.code = code;
+		this.data = data;
+		this.name = "AcpProtocolError";
+	}
+};
+function mergeTools(...sources) {
+	const out = {};
+	for (const source of sources) if (source) Object.assign(out, source);
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function mergeMcpServers(...sources) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const source of sources) for (const server of source ?? []) byName.set(server.name, server);
+	return [...byName.values()];
+}
+function cloneConfigOptions(options) {
+	return options.map((option) => ({
+		...option,
+		options: option.options.map((item) => "group" in item ? {
+			...item,
+			options: item.options.map((child) => ({ ...child }))
+		} : { ...item })
+	}));
+}
+function configOptionHasValue(option, value) {
+	for (const item of option.options) if ("group" in item) {
+		if (item.options.some((child) => child.value === value)) return true;
+	} else if (item.value === value) return true;
+	return false;
+}
+function sameStringArray(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameJson(left, right) {
+	return stableStringify(left) === stableStringify(right);
+}
+function asObject(value) {
+	if (!isObject(value)) throw new AcpProtocolError(-32602, "Expected object parameters.");
+	return value;
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeId(id) {
+	return typeof id === "string" || typeof id === "number" || id === null ? id : null;
+}
+function toRpcError(err) {
+	if (err instanceof AcpProtocolError) return {
+		code: err.code,
+		message: err.message,
+		...err.data !== void 0 ? { data: err.data } : {}
+	};
+	return {
+		code: -32603,
+		message: err instanceof Error ? err.message : String(err)
+	};
+}
+function sessionInfo(runtime) {
+	return {
+		sessionId: runtime.sessionId,
+		cwd: runtime.cwd,
+		additionalDirectories: runtime.additionalDirectories,
+		title: typeof runtime.session.metadata.title === "string" ? runtime.session.metadata.title : null,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function permissionKey(name, input) {
+	return `permission:${name}:${stableStringify(input)}`;
+}
+function stableStringify(value) {
+	if (!isObject(value)) return JSON.stringify(value);
+	const keys = Object.keys(value).sort();
+	const out = {};
+	for (const key of keys) out[key] = value[key];
+	return JSON.stringify(out);
+}
+function reachedMaxTurns(stats, behavior) {
+	const maxTurns = behavior?.maxTurns;
+	return typeof maxTurns === "number" && stats.turns >= maxTurns && lastFinishReason(stats.turnUsage) !== "length";
+}
+function lastFinishReason(turnUsage) {
+	for (let i = (turnUsage?.length ?? 0) - 1; i >= 0; i--) {
+		const reason = turnUsage?.[i]?.finishReason;
+		if (reason) return reason;
+	}
+}
+//#endregion
+//#region src/acp/index.ts
+function runAcpStdioServer(options) {
+	const server = createAcpServer(options);
+	const connection = createJsonRpcConnection({
+		input: options.input ?? process.stdin,
+		output: options.output ?? process.stdout,
+		framing: options.framing,
+		onError: options.onError,
+		onRequest: (message) => server.handleMessage(message),
+		onNotification: async (message) => {
+			await server.handleMessage(message);
+		}
+	});
+	server.setPeer(connection);
+	connection.start();
+	return {
+		server,
+		connection,
+		async close() {
+			connection.close();
+			await server.close();
+		}
+	};
+}
+//#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 };
+
+//# sourceMappingURL=acp-CEE6C0m_.js.map