droid-acp 0.1.0

package/dist/acp-agent-Ddz1S3Jm.mjs

@@ -0,0 +1,1629 @@
+import { spawn } from "node:child_process";
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { createInterface } from "node:readline";
+import { randomUUID } from "node:crypto";
+import { ReadableStream, WritableStream } from "node:stream/web";
+
+//#region src/utils.ts
+var Pushable = class {
+	queue = [];
+	resolvers = [];
+	done = false;
+	push(item) {
+		if (this.resolvers.length > 0) this.resolvers.shift()({
+			value: item,
+			done: false
+		});
+		else this.queue.push(item);
+	}
+	end() {
+		this.done = true;
+		while (this.resolvers.length > 0) this.resolvers.shift()({
+			value: void 0,
+			done: true
+		});
+	}
+	[Symbol.asyncIterator]() {
+		return { next: () => {
+			if (this.queue.length > 0) {
+				const value = this.queue.shift();
+				return Promise.resolve({
+					value,
+					done: false
+				});
+			}
+			if (this.done) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			return new Promise((resolve) => {
+				this.resolvers.push(resolve);
+			});
+		} };
+	}
+};
+function nodeToWebWritable(nodeStream) {
+	return new WritableStream({ write(chunk) {
+		return new Promise((resolve, reject) => {
+			nodeStream.write(Buffer.from(chunk), (err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	} });
+}
+function nodeToWebReadable(nodeStream) {
+	return new ReadableStream({ start(controller) {
+		nodeStream.on("data", (chunk) => {
+			controller.enqueue(new Uint8Array(chunk));
+		});
+		nodeStream.on("end", () => controller.close());
+		nodeStream.on("error", (err) => controller.error(err));
+	} });
+}
+/** Check if running on Windows */
+const isWindows = process.platform === "win32";
+/**
+* Find the droid executable path.
+* Uses DROID_EXECUTABLE env var if set, otherwise defaults to "droid".
+* On Windows, also checks for "droid.exe" if not explicitly set.
+*/
+function findDroidExecutable() {
+	if (process.env.DROID_EXECUTABLE) return process.env.DROID_EXECUTABLE;
+	return "droid";
+}
+
+//#endregion
+//#region src/droid-adapter.ts
+function createDroidAdapter(options) {
+	let process$1 = null;
+	let sessionId = null;
+	const machineId = randomUUID();
+	const logger = options.logger ?? console;
+	const notificationHandlers = [];
+	const rawEventHandlers = [];
+	const exitHandlers = [];
+	let requestHandler = null;
+	let initResolve = null;
+	let initReject = null;
+	let isStreamingAssistant = false;
+	let pendingIdle = false;
+	let pendingIdleTimer = null;
+	const send = (method, params) => {
+		if (!process$1?.stdin?.writable) return;
+		const msg = {
+			jsonrpc: "2.0",
+			factoryApiVersion: "1.0.0",
+			type: "request",
+			method,
+			params,
+			id: randomUUID()
+		};
+		process$1.stdin.write(JSON.stringify(msg) + "\n");
+		logger.log("Sent:", method);
+	};
+	const emit = async (n) => {
+		for (const h of notificationHandlers) await h(n);
+	};
+	let processingChain = Promise.resolve();
+	const queueLine = (line) => {
+		processingChain = processingChain.then(() => handleLine(line));
+	};
+	const handleLine = async (line) => {
+		try {
+			const msg = JSON.parse(line);
+			for (const h of rawEventHandlers) await h(msg);
+			if (msg.type === "response" && "result" in msg && msg.result && "sessionId" in msg.result && initResolve) {
+				const r = msg.result;
+				sessionId = r.sessionId;
+				initResolve({
+					sessionId: r.sessionId,
+					session: r.session,
+					settings: r.settings,
+					availableModels: r.availableModels || []
+				});
+				initResolve = null;
+				initReject = null;
+				return;
+			}
+			if (msg.type === "response" && "error" in msg && msg.error && initReject) {
+				initReject(new Error(msg.error.message));
+				initResolve = null;
+				initReject = null;
+				return;
+			}
+			if (msg.type === "notification" && msg.method === "droid.session_notification") {
+				const notification = msg.params?.notification;
+				if (!notification) return;
+				switch (notification.type) {
+					case "settings_updated": {
+						const settings = notification.settings;
+						if (settings) await emit({
+							type: "settings_updated",
+							settings: {
+								modelId: typeof settings.modelId === "string" ? settings.modelId : void 0,
+								reasoningEffort: typeof settings.reasoningEffort === "string" ? settings.reasoningEffort : void 0,
+								autonomyLevel: typeof settings.autonomyLevel === "string" ? settings.autonomyLevel : void 0,
+								specModeModelId: typeof settings.specModeModelId === "string" ? settings.specModeModelId : void 0,
+								specModeReasoningEffort: typeof settings.specModeReasoningEffort === "string" ? settings.specModeReasoningEffort : void 0
+							}
+						});
+						break;
+					}
+					case "droid_working_state_changed": {
+						const newState = notification.newState;
+						await emit({
+							type: "working_state",
+							state: newState
+						});
+						if (newState === "streaming_assistant_message") {
+							isStreamingAssistant = true;
+							pendingIdle = false;
+							if (pendingIdleTimer) {
+								clearTimeout(pendingIdleTimer);
+								pendingIdleTimer = null;
+							}
+						} else if (newState === "idle") if (isStreamingAssistant) {
+							pendingIdle = true;
+							if (pendingIdleTimer) clearTimeout(pendingIdleTimer);
+							pendingIdleTimer = setTimeout(() => {
+								if (!pendingIdle) return;
+								pendingIdle = false;
+								isStreamingAssistant = false;
+								pendingIdleTimer = null;
+								emit({ type: "complete" });
+							}, 250);
+						} else await emit({ type: "complete" });
+						break;
+					}
+					case "create_message": {
+						const message = notification.message;
+						if (message) {
+							const blocks = Array.isArray(message.content) ? message.content : [];
+							const textParts = blocks.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text);
+							if (textParts.length > 0) await emit({
+								type: "message",
+								role: message.role,
+								text: textParts.join(""),
+								id: message.id
+							});
+							const toolUses = blocks.filter((c) => c.type === "tool_use");
+							for (const toolUseContent of toolUses) {
+								const id = toolUseContent.id ?? toolUseContent.toolUseId ?? toolUseContent.tool_use_id ?? toolUseContent.tool_call_id ?? toolUseContent.callId ?? toolUseContent.call_id ?? randomUUID();
+								const name = toolUseContent.name ?? toolUseContent.toolName ?? toolUseContent.tool_name;
+								await emit({
+									type: "message",
+									role: message.role,
+									id: message.id,
+									toolUse: {
+										id,
+										name: name || "unknown",
+										input: toolUseContent.input
+									}
+								});
+							}
+							if (message.role === "assistant") {
+								isStreamingAssistant = false;
+								if (pendingIdleTimer) {
+									clearTimeout(pendingIdleTimer);
+									pendingIdleTimer = null;
+								}
+								if (pendingIdle) {
+									await emit({ type: "complete" });
+									pendingIdle = false;
+								}
+							}
+						}
+						break;
+					}
+					case "tool_result": {
+						const toolUseIdRaw = notification.toolUseId ?? notification.tool_use_id ?? notification.tool_call_id ?? notification.callId ?? notification.call_id ?? notification.id;
+						const toolUseId = typeof toolUseIdRaw === "string" ? toolUseIdRaw : null;
+						const rawContent = notification.content ?? notification.value;
+						const content = typeof rawContent === "string" ? rawContent : JSON.stringify(rawContent ?? "", null, 2);
+						const isErrorRaw = notification.isError ?? notification.is_error;
+						const isError = typeof isErrorRaw === "boolean" ? isErrorRaw : false;
+						if (!toolUseId) {
+							logger.error("Missing tool_use_id/toolUseId for tool_result notification");
+							break;
+						}
+						await emit({
+							type: "tool_result",
+							toolUseId,
+							content,
+							isError
+						});
+						break;
+					}
+					case "error":
+						isStreamingAssistant = false;
+						pendingIdle = false;
+						await emit({
+							type: "error",
+							message: typeof notification.message === "string" ? notification.message : JSON.stringify(notification.message ?? "Unknown error")
+						});
+						break;
+				}
+			}
+			if (msg.type === "request") {
+				const requestId = msg.id;
+				const method = msg.method;
+				const params = msg.params;
+				if (requestHandler && method === "droid.request_permission") try {
+					const response = {
+						jsonrpc: "2.0",
+						factoryApiVersion: "1.0.0",
+						type: "response",
+						id: requestId,
+						result: await requestHandler(method, params)
+					};
+					if (process$1?.stdin) process$1.stdin.write(JSON.stringify(response) + "\n");
+				} catch (error) {
+					const response = {
+						jsonrpc: "2.0",
+						factoryApiVersion: "1.0.0",
+						type: "response",
+						id: requestId,
+						error: {
+							code: -32603,
+							message: error instanceof Error ? error.message : "Internal error"
+						}
+					};
+					if (process$1?.stdin) process$1.stdin.write(JSON.stringify(response) + "\n");
+				}
+				else if (method === "droid.request_permission") {
+					const response = {
+						jsonrpc: "2.0",
+						factoryApiVersion: "1.0.0",
+						type: "response",
+						id: requestId,
+						result: { selectedOption: "proceed_once" }
+					};
+					if (process$1?.stdin) process$1.stdin.write(JSON.stringify(response) + "\n");
+					logger.log("Auto-approved permission request (fallback):", requestId);
+				}
+			}
+		} catch (err) {
+			logger.error("Parse error:", err.message);
+		}
+	};
+	return {
+		async start() {
+			const executable = findDroidExecutable();
+			const args = [
+				"exec",
+				"--input-format",
+				"stream-jsonrpc",
+				"--output-format",
+				"stream-jsonrpc",
+				"--cwd",
+				options.cwd
+			];
+			logger.log("Starting droid:", executable, args.join(" "));
+			process$1 = spawn(executable, args, {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				env: {
+					...globalThis.process.env,
+					FORCE_COLOR: "0"
+				},
+				shell: isWindows,
+				windowsHide: true
+			});
+			if (process$1.stdout) createInterface({ input: process$1.stdout }).on("line", queueLine);
+			if (process$1.stderr) createInterface({ input: process$1.stderr }).on("line", (l) => logger.error("[droid stderr]", l));
+			process$1.on("error", (err) => {
+				if (initReject) initReject(err);
+			});
+			process$1.on("exit", (code) => {
+				logger.log("Droid exit:", code);
+				process$1 = null;
+				exitHandlers.forEach((h) => h(code));
+			});
+			return new Promise((resolve, reject) => {
+				initResolve = resolve;
+				initReject = reject;
+				send("droid.initialize_session", {
+					machineId,
+					cwd: options.cwd
+				});
+				const initTimeout = parseInt(globalThis.process.env.DROID_INIT_TIMEOUT || "60000", 10);
+				setTimeout(() => {
+					if (initReject) {
+						initReject(/* @__PURE__ */ new Error("Droid init timeout"));
+						initResolve = null;
+						initReject = null;
+					}
+				}, initTimeout);
+			});
+		},
+		sendMessage(text) {
+			this.sendUserMessage({ text });
+		},
+		sendUserMessage(message) {
+			if (!sessionId) return;
+			const params = {
+				sessionId,
+				text: message.text
+			};
+			if (Array.isArray(message.images) && message.images.length > 0) params.images = message.images;
+			send("droid.add_user_message", params);
+		},
+		setMode(level) {
+			if (!sessionId) return;
+			send("droid.update_session_settings", {
+				sessionId,
+				autonomyLevel: level
+			});
+		},
+		setModel(modelId) {
+			if (!sessionId) return;
+			send("droid.update_session_settings", {
+				sessionId,
+				modelId
+			});
+		},
+		onNotification(handler) {
+			notificationHandlers.push(handler);
+		},
+		onRawEvent(handler) {
+			rawEventHandlers.push(handler);
+		},
+		onRequest(handler) {
+			requestHandler = handler;
+		},
+		onExit(handler) {
+			exitHandlers.push(handler);
+		},
+		async stop() {
+			if (process$1) {
+				process$1.stdin?.end();
+				process$1.kill("SIGTERM");
+				process$1 = null;
+			}
+		},
+		isRunning() {
+			return process$1 !== null && !process$1.killed;
+		},
+		getSessionId() {
+			return sessionId;
+		}
+	};
+}
+
+//#endregion
+//#region src/types.ts
+const ACP_MODES = [
+	"off",
+	"low",
+	"medium",
+	"high",
+	"spec"
+];
+
+//#endregion
+//#region src/acp-agent.ts
+const packageJson = {
+	name: "droid-acp",
+	version: "0.1.0"
+};
+function normalizeBase64DataUrl(data, fallbackMimeType) {
+	const trimmed = data.trim();
+	const match = trimmed.match(/^data:([^;,]+);base64,(.*)$/s);
+	if (match) return {
+		mimeType: match[1]?.trim() || fallbackMimeType,
+		base64: match[2]?.trim().replace(/\s+/g, "")
+	};
+	return {
+		mimeType: fallbackMimeType,
+		base64: trimmed.replace(/\s+/g, "")
+	};
+}
+function getAvailableCommands() {
+	return [
+		{
+			name: "help",
+			description: "Show available slash commands",
+			input: null
+		},
+		{
+			name: "model",
+			description: "Show or change the current model",
+			input: { hint: "[model_id]" }
+		},
+		{
+			name: "mode",
+			description: "Show or change the autonomy mode (off|low|medium|high|spec)",
+			input: { hint: "[mode]" }
+		},
+		{
+			name: "config",
+			description: "Show current session configuration",
+			input: null
+		},
+		{
+			name: "status",
+			description: "Show current session status",
+			input: null
+		}
+	];
+}
+const ACP_MODE_TO_DROID_AUTONOMY = {
+	off: "normal",
+	low: "auto-low",
+	medium: "auto-medium",
+	high: "auto-high",
+	spec: "spec"
+};
+function droidAutonomyToAcpModeId(value) {
+	switch (value) {
+		case "normal": return "off";
+		case "auto-low": return "low";
+		case "auto-medium": return "medium";
+		case "auto-high": return "high";
+		case "spec": return "spec";
+		case "suggest": return "low";
+		case "full": return "high";
+		default: return null;
+	}
+}
+var DroidAcpAgent = class {
+	sessions = /* @__PURE__ */ new Map();
+	client;
+	logger;
+	constructor(client, logger) {
+		this.client = client;
+		this.logger = logger ?? console;
+		this.logger.log("DroidAcpAgent initialized");
+	}
+	async initialize(_request) {
+		this.logger.log("initialize");
+		return {
+			protocolVersion: 1,
+			agentCapabilities: { promptCapabilities: {
+				image: true,
+				embeddedContext: true
+			} },
+			agentInfo: {
+				name: packageJson.name,
+				title: "Factory Droid",
+				version: packageJson.version
+			},
+			authMethods: [{
+				id: "factory-api-key",
+				name: "Factory API Key",
+				description: "Set FACTORY_API_KEY environment variable"
+			}]
+		};
+	}
+	async authenticate(request) {
+		this.logger.log("authenticate:", request.methodId);
+		if (request.methodId === "factory-api-key") {
+			if (!process.env.FACTORY_API_KEY) throw new Error("FACTORY_API_KEY environment variable is not set");
+			return {};
+		}
+		throw new Error(`Unknown auth method: ${request.methodId}`);
+	}
+	async newSession(request) {
+		const cwd = request.cwd || process.cwd();
+		this.logger.log("newSession:", cwd);
+		const droid = createDroidAdapter({
+			cwd,
+			logger: this.logger
+		});
+		const initResult = await droid.start();
+		const sessionId = initResult.sessionId;
+		const initialMode = typeof initResult.settings?.autonomyLevel === "string" ? droidAutonomyToAcpModeId(initResult.settings.autonomyLevel) ?? "off" : "off";
+		const session = {
+			id: sessionId,
+			droid,
+			droidSessionId: initResult.sessionId,
+			model: initResult.settings?.modelId || "unknown",
+			mode: initialMode,
+			cancelled: false,
+			promptResolve: null,
+			activeToolCallIds: /* @__PURE__ */ new Set(),
+			toolCallStatus: /* @__PURE__ */ new Map(),
+			toolNames: /* @__PURE__ */ new Map(),
+			availableModels: initResult.availableModels,
+			cwd,
+			specChoice: null,
+			specChoicePromptSignature: null,
+			specPlanDetailsSignature: null,
+			specPlanDetailsToolCallId: null
+		};
+		droid.onNotification((n) => this.handleNotification(session, n));
+		if (process.env.DROID_DEBUG) droid.onRawEvent(async (event) => {
+			await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `\n\`\`\`json\n${JSON.stringify(event, null, 2)}\n\`\`\`\n`
+					}
+				}
+			});
+		});
+		droid.onRequest(async (method, params) => {
+			if (method === "droid.request_permission") return this.handlePermission(session, params);
+			throw new Error("Method not supported");
+		});
+		droid.onExit((code) => {
+			this.logger.log("Droid exited, cleaning up session:", session.id, "code:", code);
+			if (session.promptResolve) {
+				session.promptResolve({ stopReason: "end_turn" });
+				session.promptResolve = null;
+			}
+			this.sessions.delete(session.id);
+		});
+		this.sessions.set(sessionId, session);
+		this.logger.log("Session created:", sessionId);
+		setTimeout(() => {
+			this.client.sessionUpdate({
+				sessionId,
+				update: {
+					sessionUpdate: "available_commands_update",
+					availableCommands: getAvailableCommands()
+				}
+			});
+		}, 0);
+		return {
+			sessionId,
+			models: {
+				availableModels: initResult.availableModels.map((m) => ({
+					modelId: m.id,
+					name: m.displayName
+				})),
+				currentModelId: initResult.settings?.modelId || "unknown"
+			},
+			modes: {
+				currentModeId: initialMode,
+				availableModes: [
+					{
+						id: "spec",
+						name: "Spec",
+						description: "Research and plan only - no code changes"
+					},
+					{
+						id: "off",
+						name: "Auto Off",
+						description: "Read-only mode - safe for reviewing planned changes without execution"
+					},
+					{
+						id: "low",
+						name: "Auto Low",
+						description: "Low-risk operations - file creation/modification, no system changes"
+					},
+					{
+						id: "medium",
+						name: "Auto Medium",
+						description: "Development operations - npm install, git commit, build commands"
+					},
+					{
+						id: "high",
+						name: "Auto High",
+						description: "Production operations - git push, deployments, database migrations"
+					}
+				]
+			}
+		};
+	}
+	async prompt(request) {
+		const session = this.sessions.get(request.sessionId);
+		if (!session) throw new Error(`Session not found: ${request.sessionId}`);
+		if (session.cancelled) throw new Error("Session cancelled");
+		if (session.promptResolve) throw new Error("Another prompt is already in progress");
+		this.logger.log("prompt:", request.sessionId);
+		const textParts = [];
+		const images = [];
+		for (const chunk of request.prompt) switch (chunk.type) {
+			case "text":
+				textParts.push(chunk.text);
+				break;
+			case "image": {
+				const mimeType = chunk.mimeType || "application/octet-stream";
+				if (chunk.data) {
+					const normalized = normalizeBase64DataUrl(chunk.data, mimeType);
+					images.push({
+						type: "base64",
+						data: normalized.base64,
+						mediaType: normalized.mimeType
+					});
+				} else if (chunk.uri) textParts.push(`(image: ${chunk.uri})`);
+				break;
+			}
+			case "resource":
+				if ("text" in chunk.resource) {
+					const contextText = `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>`;
+					textParts.push(contextText);
+				} else if ("blob" in chunk.resource) {
+					const mimeType = chunk.resource.mimeType || "application/octet-stream";
+					const uri = chunk.resource.uri;
+					if (mimeType.startsWith("image/")) {
+						const data = chunk.resource.blob;
+						if (typeof data === "string" && data.length > 0) {
+							const normalized = normalizeBase64DataUrl(data, mimeType);
+							images.push({
+								type: "base64",
+								data: normalized.base64,
+								mediaType: normalized.mimeType
+							});
+						}
+					} else {
+						const note = uri ? `\n<context ref="${uri}">\n(binary resource: ${mimeType})\n</context>` : `\n(binary resource: ${mimeType})`;
+						textParts.push(note);
+					}
+				}
+				break;
+			case "resource_link":
+				textParts.push(`@${chunk.uri}`);
+				break;
+			default: break;
+		}
+		let text = textParts.join("\n").trim();
+		if (text.length === 0 && images.length > 0) text = "Please see the attached image(s).";
+		if (text.startsWith("/")) {
+			if (await this.handleSlashCommand(session, text)) return { stopReason: "end_turn" };
+		}
+		return new Promise((resolve) => {
+			const timeoutId = setTimeout(() => {
+				if (session.promptResolve) {
+					session.promptResolve({ stopReason: "end_turn" });
+					session.promptResolve = null;
+				}
+			}, 300 * 1e3);
+			session.promptResolve = resolve;
+			session.droid.sendUserMessage({
+				text,
+				images: images.length > 0 ? images : void 0
+			});
+			const originalResolve = session.promptResolve;
+			session.promptResolve = (result) => {
+				clearTimeout(timeoutId);
+				originalResolve?.(result);
+			};
+		});
+	}
+	async cancel(request) {
+		const session = this.sessions.get(request.sessionId);
+		if (session) {
+			this.logger.log("cancel:", request.sessionId);
+			session.cancelled = true;
+			if (session.promptResolve) {
+				session.promptResolve({ stopReason: "cancelled" });
+				session.promptResolve = null;
+			}
+			await session.droid.stop();
+			this.sessions.delete(request.sessionId);
+		}
+	}
+	async unstable_setSessionModel(request) {
+		const session = this.sessions.get(request.sessionId);
+		if (session) {
+			this.logger.log("setSessionModel:", request.modelId);
+			session.model = request.modelId;
+			session.droid.setModel(request.modelId);
+		}
+	}
+	async setSessionMode(request) {
+		const session = this.sessions.get(request.sessionId);
+		if (session) {
+			this.logger.log("setSessionMode:", request.modeId);
+			const modeId = ACP_MODES.includes(request.modeId) ? request.modeId : null;
+			if (modeId) {
+				session.mode = modeId;
+				session.droid.setMode(ACP_MODE_TO_DROID_AUTONOMY[modeId]);
+			}
+		}
+		return {};
+	}
+	async handleSlashCommand(session, text) {
+		const match = text.match(/^\/(\S+)(?:\s+(.*))?$/);
+		if (!match) return false;
+		const [, command, args] = match;
+		const trimmedArgs = args?.trim() || "";
+		switch (command.toLowerCase()) {
+			case "help": {
+				const helpText = ["**Available Commands:**\n", ...getAvailableCommands().map((cmd) => {
+					const inputHint = cmd.input && "hint" in cmd.input ? ` ${cmd.input.hint}` : "";
+					return `- \`/${cmd.name}${inputHint}\` - ${cmd.description}`;
+				})].join("\n");
+				await this.sendAgentMessage(session, helpText);
+				return true;
+			}
+			case "model":
+				if (trimmedArgs) {
+					const modelId = trimmedArgs;
+					const model = session.availableModels.find((m) => m.id === modelId || m.displayName.toLowerCase() === modelId.toLowerCase());
+					if (model) {
+						session.model = model.id;
+						session.droid.setModel(model.id);
+						await this.sendAgentMessage(session, `Model changed to: **${model.displayName}**`);
+					} else {
+						const available = session.availableModels.map((m) => `- ${m.id} (${m.displayName})`);
+						await this.sendAgentMessage(session, `Model "${modelId}" not found.\n\n**Available models:**\n${available.join("\n")}`);
+					}
+				} else {
+					const available = session.availableModels.map((m) => {
+						const current = m.id === session.model ? " **(current)**" : "";
+						return `- ${m.id} (${m.displayName})${current}`;
+					});
+					await this.sendAgentMessage(session, `**Current model:** ${session.model}\n\n**Available models:**\n${available.join("\n")}`);
+				}
+				return true;
+			case "mode": {
+				const inputMode = trimmedArgs.toLowerCase();
+				if (trimmedArgs && ACP_MODES.includes(inputMode)) {
+					session.mode = inputMode;
+					session.droid.setMode(ACP_MODE_TO_DROID_AUTONOMY[inputMode]);
+					await this.sendAgentMessage(session, `Autonomy mode changed to: **${inputMode}**`);
+					await this.client.sessionUpdate({
+						sessionId: session.id,
+						update: {
+							sessionUpdate: "current_mode_update",
+							currentModeId: inputMode
+						}
+					});
+				} else {
+					const modeList = ACP_MODES.map((m) => {
+						return `- ${m}${m === session.mode ? " **(current)**" : ""}`;
+					}).join("\n");
+					await this.sendAgentMessage(session, `**Current mode:** ${session.mode}\n\n**Available modes:**\n${modeList}`);
+				}
+				return true;
+			}
+			case "config": {
+				const config = [
+					`**Session Configuration:**`,
+					`- Session ID: ${session.id}`,
+					`- Working Directory: ${session.cwd}`,
+					`- Model: ${session.model}`,
+					`- Mode: ${session.mode}`
+				].join("\n");
+				await this.sendAgentMessage(session, config);
+				return true;
+			}
+			case "status": {
+				const status = [
+					`**Session Status:**`,
+					`- Active Tool Calls: ${session.activeToolCallIds.size}`,
+					`- Droid Running: ${session.droid.isRunning()}`
+				].join("\n");
+				await this.sendAgentMessage(session, status);
+				return true;
+			}
+			default:
+				await this.sendAgentMessage(session, `Unknown command: \`/${command}\`. Type \`/help\` to see available commands.`);
+				return true;
+		}
+	}
+	async sendAgentMessage(session, text) {
+		await this.client.sessionUpdate({
+			sessionId: session.id,
+			update: {
+				sessionUpdate: "agent_message_chunk",
+				content: {
+					type: "text",
+					text
+				}
+			}
+		});
+	}
+	extractSpecTitleAndPlan(rawInput) {
+		if (!rawInput || typeof rawInput !== "object") return {
+			title: null,
+			plan: null
+		};
+		const obj = rawInput;
+		const title = typeof obj.title === "string" ? obj.title : typeof obj.specTitle === "string" ? obj.specTitle : typeof obj.name === "string" ? obj.name : null;
+		const candidates = [
+			obj.plan,
+			obj.planMarkdown,
+			obj.markdown,
+			obj.content,
+			obj.text
+		];
+		const toMarkdown = (value) => {
+			if (typeof value === "string") return value;
+			if (Array.isArray(value)) {
+				const joined = value.map((v) => typeof v === "string" ? v : JSON.stringify(v, null, 2)).join("\n").trim();
+				return joined.length > 0 ? joined : null;
+			}
+			if (value && typeof value === "object") {
+				const v = value;
+				if (typeof v.markdown === "string") return v.markdown;
+				if (typeof v.text === "string") return v.text;
+				const json = JSON.stringify(v, null, 2);
+				return json && json !== "{}" ? json : null;
+			}
+			return null;
+		};
+		for (const c of candidates) {
+			const plan = toMarkdown(c);
+			if (plan) return {
+				title,
+				plan
+			};
+		}
+		return {
+			title,
+			plan: null
+		};
+	}
+	planEntriesFromMarkdown(planMarkdown) {
+		const entries = [];
+		let inCodeFence = false;
+		for (const rawLine of planMarkdown.split("\n")) {
+			const line = rawLine.trim();
+			if (line.startsWith("```")) {
+				inCodeFence = !inCodeFence;
+				continue;
+			}
+			if (inCodeFence) continue;
+			if (!line) continue;
+			const checkbox = line.match(/^- \[([ xX~])\]\s+(.*)$/);
+			if (checkbox) {
+				const [, mark, content] = checkbox;
+				const status = mark === "x" || mark === "X" ? "completed" : mark === "~" ? "in_progress" : "pending";
+				entries.push({
+					content,
+					status,
+					priority: "medium"
+				});
+				continue;
+			}
+			const bullet = line.match(/^[-*]\s+(.*)$/);
+			if (bullet) {
+				entries.push({
+					content: bullet[1],
+					status: "pending",
+					priority: "medium"
+				});
+				continue;
+			}
+			const numbered = line.match(/^\d+\.\s+(.*)$/);
+			if (numbered) {
+				entries.push({
+					content: numbered[1],
+					status: "pending",
+					priority: "medium"
+				});
+				continue;
+			}
+		}
+		return entries.filter((e) => e.content.length > 0);
+	}
+	extractPlanChoices(planMarkdown) {
+		const explicitChoices = [];
+		const looseChoices = [];
+		const seenExplicit = /* @__PURE__ */ new Set();
+		const seenLoose = /* @__PURE__ */ new Set();
+		for (const rawLine of planMarkdown.split("\n")) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			const stripped = line.replace(/^>\s+/, "").replace(/^#+\s*/, "").replace(/^[-*]\s+/, "").trim().replace(/^[*_`]+/, "").trim();
+			const explicit = stripped.match(/^(?:Option|方案)\s*([A-Z])\s*[：:–—.)-]\s*(.+)$/i);
+			if (explicit) {
+				const id$1 = explicit[1].toUpperCase();
+				if (seenExplicit.has(id$1)) continue;
+				seenExplicit.add(id$1);
+				const title$1 = explicit[2].trim();
+				explicitChoices.push({
+					id: id$1,
+					title: title$1
+				});
+				continue;
+			}
+			const loose = stripped.match(/^([A-F])\s*[：:–—.)-]\s*(.+)$/);
+			if (!loose) continue;
+			const id = loose[1].toUpperCase();
+			if (seenLoose.has(id)) continue;
+			seenLoose.add(id);
+			const title = loose[2].trim();
+			looseChoices.push({
+				id,
+				title
+			});
+		}
+		if (explicitChoices.length > 0) return explicitChoices;
+		if (looseChoices.length >= 2) return looseChoices;
+		return [];
+	}
+	handlePermission(session, params) {
+		const toolUse = params.toolUses?.[0]?.toolUse;
+		if (!toolUse) return Promise.resolve({ selectedOption: "proceed_once" });
+		const toolCallId = toolUse.id;
+		const toolName = toolUse.name;
+		const rawInput = toolUse.input;
+		const spec = toolName === "ExitSpecMode" ? this.extractSpecTitleAndPlan(rawInput) : null;
+		const command = typeof rawInput?.command === "string" ? rawInput.command : toolName === "ExitSpecMode" && typeof spec?.title === "string" ? spec.title : JSON.stringify(rawInput);
+		const commandSummary = command.length > 200 ? command.slice(0, 200) + "…" : command;
+		const isReadOnlyTool = toolName === "Read" || toolName === "Grep" || toolName === "Glob" || toolName === "LS";
+		const riskLevelRaw = rawInput?.riskLevel;
+		const riskLevel = riskLevelRaw === "low" || riskLevelRaw === "medium" || riskLevelRaw === "high" ? riskLevelRaw : isReadOnlyTool ? "low" : "medium";
+		this.logger.log("Permission request for tool:", toolCallId, "risk:", riskLevel, "mode:", session.mode);
+		const toolCallTitle = toolName === "ExitSpecMode" ? spec?.title ? `Exit spec mode: ${spec.title}` : "Exit spec mode" : `Running ${toolName} (${riskLevel}): ${commandSummary}`;
+		const toolCallKind = toolName === "ExitSpecMode" ? "switch_mode" : void 0;
+		const toolCallContent = toolName === "ExitSpecMode" && spec?.plan ? [{
+			type: "content",
+			content: {
+				type: "text",
+				text: spec.plan
+			}
+		}] : void 0;
+		const alreadyTracked = session.activeToolCallIds.has(toolCallId);
+		session.activeToolCallIds.add(toolCallId);
+		session.toolNames.set(toolCallId, toolName);
+		session.toolCallStatus.set(toolCallId, "pending");
+		if (alreadyTracked) this.client.sessionUpdate({
+			sessionId: session.id,
+			update: {
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				title: toolCallTitle,
+				status: "pending",
+				kind: toolCallKind,
+				content: toolCallContent,
+				rawInput
+			}
+		});
+		else this.client.sessionUpdate({
+			sessionId: session.id,
+			update: {
+				sessionUpdate: "tool_call",
+				toolCallId,
+				title: toolCallTitle,
+				status: "pending",
+				kind: toolCallKind,
+				content: toolCallContent,
+				rawInput
+			}
+		});
+		return this.decidePermission(session, {
+			toolCallId,
+			toolName,
+			command: commandSummary,
+			riskLevel,
+			rawInput,
+			droidOptions: this.extractDroidPermissionOptions(params)
+		});
+	}
+	extractDroidPermissionOptions(params) {
+		const candidates = [];
+		const maybePush = (value) => {
+			if (Array.isArray(value)) candidates.push(value);
+		};
+		maybePush(params.options);
+		const toolUses = params.toolUses;
+		if (Array.isArray(toolUses)) for (const toolUse of toolUses) {
+			if (!toolUse || typeof toolUse !== "object") continue;
+			const tu = toolUse;
+			maybePush(tu.options);
+			const details = tu.details;
+			if (details && typeof details === "object") maybePush(details.options);
+		}
+		for (const candidate of candidates) {
+			const normalized = candidate.map((opt) => opt).map((opt) => ({
+				value: typeof opt.value === "string" ? opt.value : null,
+				label: typeof opt.label === "string" ? opt.label : null
+			})).filter((opt) => !!opt.value && !!opt.label).map((opt) => ({
+				value: opt.value,
+				label: opt.label
+			}));
+			if (normalized.length > 0) return normalized;
+		}
+		return null;
+	}
+	mapExitSpecModeSelection(optionId) {
+		switch (optionId) {
+			case "off": return {
+				nextMode: "off",
+				droidSelectedOption: "proceed_once"
+			};
+			case "low": return {
+				nextMode: "low",
+				droidSelectedOption: "proceed_auto_run_low"
+			};
+			case "medium": return {
+				nextMode: "medium",
+				droidSelectedOption: "proceed_auto_run_medium"
+			};
+			case "high": return {
+				nextMode: "high",
+				droidSelectedOption: "proceed_auto_run_high"
+			};
+			case "spec": return {
+				nextMode: "spec",
+				droidSelectedOption: "cancel"
+			};
+			default: break;
+		}
+		switch (optionId) {
+			case "proceed_once": return {
+				nextMode: "off",
+				droidSelectedOption: "proceed_once"
+			};
+			case "proceed_auto_run_low": return {
+				nextMode: "low",
+				droidSelectedOption: "proceed_auto_run_low"
+			};
+			case "proceed_auto_run_medium": return {
+				nextMode: "medium",
+				droidSelectedOption: "proceed_auto_run_medium"
+			};
+			case "proceed_auto_run_high": return {
+				nextMode: "high",
+				droidSelectedOption: "proceed_auto_run_high"
+			};
+			case "cancel": return {
+				nextMode: "spec",
+				droidSelectedOption: "cancel"
+			};
+			default: return {
+				nextMode: null,
+				droidSelectedOption: optionId
+			};
+		}
+	}
+	specApprovalOptions(droidOptions) {
+		const has = (value) => droidOptions?.some((o) => o.value === value) === true;
+		const options = [
+			{
+				modeId: "off",
+				droidValue: "proceed_once",
+				name: "Proceed (manual approvals)",
+				kind: "allow_once"
+			},
+			{
+				modeId: "low",
+				droidValue: "proceed_auto_run_low",
+				name: "Proceed (Auto Low)",
+				kind: "allow_once"
+			},
+			{
+				modeId: "medium",
+				droidValue: "proceed_auto_run_medium",
+				name: "Proceed (Auto Medium)",
+				kind: "allow_once"
+			},
+			{
+				modeId: "high",
+				droidValue: "proceed_auto_run_high",
+				name: "Proceed (Auto High)",
+				kind: "allow_once"
+			},
+			{
+				modeId: "spec",
+				droidValue: "cancel",
+				name: "No, keep iterating (stay in Spec)",
+				kind: "reject_once"
+			}
+		].filter((c) => !droidOptions || has(c.droidValue)).map((c) => ({
+			optionId: c.modeId,
+			name: c.name,
+			kind: c.kind
+		}));
+		if (options.length > 0) return options;
+		return droidOptions?.map((o) => ({
+			optionId: o.value,
+			name: o.label,
+			kind: "allow_once"
+		})) ?? [{
+			optionId: "off",
+			name: "Proceed (manual approvals)",
+			kind: "allow_once"
+		}, {
+			optionId: "spec",
+			name: "No, keep iterating (stay in Spec)",
+			kind: "reject_once"
+		}];
+	}
+	async decidePermission(session, params) {
+		if (session.cancelled) {
+			session.toolCallStatus.set(params.toolCallId, "completed");
+			session.activeToolCallIds.delete(params.toolCallId);
+			await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "tool_call_update",
+					toolCallId: params.toolCallId,
+					status: "completed"
+				}
+			});
+			return { selectedOption: "cancel" };
+		}
+		const permissionKindFromOptionValue = (value) => {
+			switch (value) {
+				case "proceed_once":
+				case "proceed_edit": return "allow_once";
+				case "proceed_auto_run_low":
+				case "proceed_auto_run_medium":
+				case "proceed_auto_run_high":
+				case "proceed_auto_run":
+				case "proceed_always": return "allow_always";
+				case "cancel": return "reject_once";
+				default: return "allow_once";
+			}
+		};
+		const toAcpPermissionOption = (opt) => {
+			const value = opt.value;
+			let name = opt.label;
+			switch (value) {
+				case "proceed_once":
+					name = "Allow once";
+					break;
+				case "proceed_always": {
+					const labelLower = opt.label.toLowerCase();
+					if (labelLower.includes("low")) {
+						name = "Allow & auto-run low risk commands";
+						break;
+					}
+					if (labelLower.includes("medium")) {
+						name = "Allow & auto-run medium risk commands";
+						break;
+					}
+					if (labelLower.includes("high")) {
+						name = "Allow & auto-run high risk commands";
+						break;
+					}
+					name = "Allow always";
+					break;
+				}
+				case "proceed_auto_run_low":
+					name = "Proceed & auto-run (low risk)";
+					break;
+				case "proceed_auto_run_medium":
+					name = "Proceed & auto-run (medium risk)";
+					break;
+				case "proceed_auto_run_high":
+					name = "Proceed & auto-run (high risk)";
+					break;
+				default: break;
+			}
+			return {
+				optionId: value,
+				name,
+				kind: permissionKindFromOptionValue(value)
+			};
+		};
+		const droidOptions = params.droidOptions?.length ? params.droidOptions : null;
+		const acpOptions = params.toolName === "ExitSpecMode" ? this.specApprovalOptions(droidOptions) : droidOptions ? droidOptions.map(toAcpPermissionOption) : [{
+			optionId: "proceed_once",
+			name: "Allow once",
+			kind: "allow_once"
+		}, {
+			optionId: "cancel",
+			name: "Reject",
+			kind: "reject_once"
+		}];
+		const spec = this.extractSpecTitleAndPlan(params.rawInput);
+		const planTitle = spec.title;
+		const planMarkdown = spec.plan;
+		if (params.toolName === "ExitSpecMode" && planMarkdown) {
+			const signature = `${planTitle ?? ""}\n${planMarkdown}`;
+			if (session.specChoicePromptSignature !== signature) {
+				session.specChoicePromptSignature = signature;
+				session.specChoice = null;
+			}
+			if (session.specPlanDetailsSignature !== signature) {
+				session.specPlanDetailsSignature = signature;
+				session.specPlanDetailsToolCallId = `${params.toolCallId}:plan_details`;
+				await this.client.sessionUpdate({
+					sessionId: session.id,
+					update: {
+						sessionUpdate: "tool_call",
+						toolCallId: session.specPlanDetailsToolCallId,
+						title: planTitle ? `Plan details: ${planTitle}` : "Plan details",
+						kind: "think",
+						status: "completed",
+						content: [{
+							type: "content",
+							content: {
+								type: "text",
+								text: planMarkdown
+							}
+						}]
+					}
+				});
+			}
+			if (session.specChoice === null) {
+				const choices = this.extractPlanChoices(planMarkdown);
+				if (choices.length > 0) {
+					const detailsHint = session.specPlanDetailsToolCallId ? `Expand **${session.specPlanDetailsToolCallId}** to view the full plan details.` : "Expand the Plan details tool call to view the full plan details.";
+					const choicePrompt = [
+						planTitle ? `**${planTitle}**` : "**Choose an implementation option**",
+						"",
+						detailsHint,
+						"Choose one to continue iterating in spec mode.",
+						...choices.map((c) => `- Option ${c.id}: ${c.title}`)
+					].filter((p) => p.length > 0).join("\n");
+					const response = await this.client.requestPermission({
+						sessionId: session.id,
+						toolCall: {
+							toolCallId: `${params.toolCallId}:choose_plan`,
+							title: planTitle ? `Choose plan: ${planTitle}` : "Choose plan option",
+							status: "pending",
+							kind: "think",
+							rawInput: { choices },
+							content: [{
+								type: "content",
+								content: {
+									type: "text",
+									text: choicePrompt
+								}
+							}]
+						},
+						options: [...choices.map((c) => ({
+							optionId: `choose_plan:${c.id}`,
+							name: `Choose Option ${c.id}`,
+							kind: "allow_once"
+						})), {
+							optionId: "choose_plan:skip",
+							name: "Skip",
+							kind: "reject_once"
+						}]
+					});
+					const match = (response.outcome.outcome === "selected" ? response.outcome.optionId : "choose_plan:skip").match(/^choose_plan:([A-Z])$/);
+					if (match) {
+						const choiceId = match[1];
+						session.specChoice = choiceId;
+						await this.client.sessionUpdate({
+							sessionId: session.id,
+							update: {
+								sessionUpdate: "tool_call_update",
+								toolCallId: `${params.toolCallId}:choose_plan`,
+								status: "completed"
+							}
+						});
+						session.toolCallStatus.set(params.toolCallId, "completed");
+						session.activeToolCallIds.delete(params.toolCallId);
+						await this.client.sessionUpdate({
+							sessionId: session.id,
+							update: {
+								sessionUpdate: "tool_call_update",
+								toolCallId: params.toolCallId,
+								status: "completed",
+								content: [{
+									type: "content",
+									content: {
+										type: "text",
+										text: `Continuing in spec mode with Option ${choiceId}.`
+									}
+								}]
+							}
+						});
+						await this.sendAgentMessage(session, `Selected **Option ${choiceId}**. Continuing in spec mode.`);
+						setTimeout(() => {
+							session.droid.sendMessage(`我选择方案 ${choiceId}。请基于该方案继续完善计划/关键改动点，并在准备好执行时再提示退出 spec。`);
+						}, 0);
+						return { selectedOption: "cancel" };
+					}
+					session.specChoice = "skip";
+				}
+			}
+		}
+		if (params.toolName === "ExitSpecMode" && planMarkdown) {
+			const entries = this.planEntriesFromMarkdown(planMarkdown);
+			if (entries.length > 0) await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "plan",
+					entries
+				}
+			});
+			else if (planMarkdown.trim().length > 0) await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "plan",
+					entries: [{
+						content: planMarkdown.trim(),
+						status: "pending",
+						priority: "medium"
+					}]
+				}
+			});
+		}
+		let autoDecision = null;
+		if (params.toolName === "ExitSpecMode") {
+			autoDecision = null;
+			this.logger.log("Prompting (ExitSpecMode)");
+		} else if (session.mode === "high") {
+			autoDecision = "proceed_always";
+			this.logger.log("Auto-approved (high mode)");
+		} else if (session.mode === "medium") {
+			autoDecision = params.riskLevel === "high" ? null : "proceed_once";
+			this.logger.log(autoDecision ? "Auto-approved (medium mode, low/med risk)" : "Prompting (medium mode)");
+		} else if (session.mode === "low") {
+			autoDecision = params.riskLevel === "low" ? "proceed_once" : null;
+			this.logger.log(autoDecision ? "Auto-approved (low mode, low risk)" : "Prompting (low mode)");
+		} else if (session.mode === "spec") if (params.riskLevel === "low") {
+			autoDecision = "proceed_once";
+			this.logger.log("Auto-approved (spec mode, low risk)");
+		} else {
+			autoDecision = "cancel";
+			this.logger.log("Auto-rejected (spec mode, medium/high risk)");
+		}
+		else {
+			autoDecision = null;
+			this.logger.log("Prompting (off mode)");
+		}
+		if (autoDecision) {
+			const selectedOption$1 = droidOptions?.some((o) => o.value === autoDecision) === true ? autoDecision : autoDecision === "cancel" ? "cancel" : droidOptions ? droidOptions?.find((o) => permissionKindFromOptionValue(o.value) === "allow_once")?.value ?? droidOptions?.find((o) => o.value !== "cancel")?.value ?? "proceed_once" : autoDecision;
+			const isExitSpecMode$1 = params.toolName === "ExitSpecMode";
+			const status$1 = selectedOption$1 === "cancel" || isExitSpecMode$1 ? "completed" : "in_progress";
+			session.toolCallStatus.set(params.toolCallId, status$1);
+			if (status$1 === "completed") session.activeToolCallIds.delete(params.toolCallId);
+			await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "tool_call_update",
+					toolCallId: params.toolCallId,
+					status: status$1,
+					content: selectedOption$1 === "cancel" ? [{
+						type: "content",
+						content: {
+							type: "text",
+							text: `Permission denied for \`${params.toolName}\` (${params.riskLevel}).`
+						}
+					}] : void 0
+				}
+			});
+			return { selectedOption: selectedOption$1 };
+		}
+		let permission;
+		try {
+			const title = params.toolName === "ExitSpecMode" ? planTitle ? `Exit spec mode: ${planTitle}` : "Exit spec mode" : `Running ${params.toolName} (${params.riskLevel}): ${params.command}`;
+			permission = await this.client.requestPermission({
+				sessionId: session.id,
+				toolCall: {
+					toolCallId: params.toolCallId,
+					title,
+					rawInput: params.rawInput
+				},
+				options: acpOptions
+			});
+		} catch (error) {
+			this.logger.error("requestPermission failed:", error);
+			session.toolCallStatus.set(params.toolCallId, "completed");
+			session.activeToolCallIds.delete(params.toolCallId);
+			await this.client.sessionUpdate({
+				sessionId: session.id,
+				update: {
+					sessionUpdate: "tool_call_update",
+					toolCallId: params.toolCallId,
+					status: "completed",
+					content: [{
+						type: "content",
+						content: {
+							type: "text",
+							text: `Permission request failed for \`${params.toolName}\`. Cancelling the operation.`
+						}
+					}]
+				}
+			});
+			return { selectedOption: "cancel" };
+		}
+		let selectedOption = "cancel";
+		if (permission.outcome.outcome === "selected") selectedOption = permission.outcome.optionId;
+		else selectedOption = "cancel";
+		if (params.toolName === "ExitSpecMode") {
+			const mapped = this.mapExitSpecModeSelection(selectedOption);
+			selectedOption = mapped.droidSelectedOption;
+			if (mapped.nextMode) {
+				session.mode = mapped.nextMode;
+				await this.client.sessionUpdate({
+					sessionId: session.id,
+					update: {
+						sessionUpdate: "current_mode_update",
+						currentModeId: mapped.nextMode
+					}
+				});
+			}
+		}
+		const isExitSpecMode = params.toolName === "ExitSpecMode";
+		const status = selectedOption === "cancel" || isExitSpecMode ? "completed" : "in_progress";
+		session.toolCallStatus.set(params.toolCallId, status);
+		if (status === "completed") session.activeToolCallIds.delete(params.toolCallId);
+		if (isExitSpecMode) await this.client.sessionUpdate({
+			sessionId: session.id,
+			update: {
+				sessionUpdate: "tool_call_update",
+				toolCallId: params.toolCallId,
+				status,
+				content: selectedOption === "cancel" ? [{
+					type: "content",
+					content: {
+						type: "text",
+						text: "Staying in Spec mode."
+					}
+				}] : void 0
+			}
+		});
+		else if (selectedOption !== "cancel") await this.client.sessionUpdate({
+			sessionId: session.id,
+			update: {
+				sessionUpdate: "tool_call_update",
+				toolCallId: params.toolCallId,
+				status
+			}
+		});
+		return { selectedOption };
+	}
+	async handleNotification(session, n) {
+		this.logger.log("notification:", n.type);
+		switch (n.type) {
+			case "settings_updated": {
+				const autonomyLevel = typeof n.settings.autonomyLevel === "string" ? droidAutonomyToAcpModeId(n.settings.autonomyLevel) : null;
+				if (autonomyLevel && autonomyLevel !== session.mode) {
+					session.mode = autonomyLevel;
+					await this.client.sessionUpdate({
+						sessionId: session.id,
+						update: {
+							sessionUpdate: "current_mode_update",
+							currentModeId: autonomyLevel
+						}
+					});
+				}
+				if (typeof n.settings.modelId === "string") session.model = n.settings.modelId;
+				break;
+			}
+			case "message":
+				if (n.role === "assistant") {
+					if (n.toolUse) {
+						if (n.toolUse.name === "TodoWrite") {
+							const todos = n.toolUse.input?.todos;
+							if (Array.isArray(todos)) {
+								const toStatus = (status) => {
+									switch (status) {
+										case "pending":
+										case "in_progress":
+										case "completed": return status;
+										default: return "pending";
+									}
+								};
+								const entries = todos.map((t) => {
+									const todo = t;
+									return {
+										content: typeof todo.content === "string" ? todo.content : "",
+										status: toStatus(todo.status),
+										priority: "medium"
+									};
+								}).filter((e) => e.content.length > 0);
+								await this.client.sessionUpdate({
+									sessionId: session.id,
+									update: {
+										sessionUpdate: "plan",
+										entries
+									}
+								});
+							}
+							break;
+						}
+						const toolCallId = n.toolUse.id;
+						const isExitSpecMode = n.toolUse.name === "ExitSpecMode";
+						const existingStatus = session.toolCallStatus.get(toolCallId);
+						if (existingStatus !== "completed" && existingStatus !== "failed") if (!session.activeToolCallIds.has(toolCallId)) {
+							session.activeToolCallIds.add(toolCallId);
+							session.toolNames.set(toolCallId, n.toolUse.name);
+							const initialStatus = isExitSpecMode ? "pending" : "in_progress";
+							session.toolCallStatus.set(toolCallId, initialStatus);
+							const spec = isExitSpecMode ? this.extractSpecTitleAndPlan(n.toolUse.input) : null;
+							await this.client.sessionUpdate({
+								sessionId: session.id,
+								update: {
+									sessionUpdate: "tool_call",
+									toolCallId,
+									title: isExitSpecMode ? spec?.title ? `Exit spec mode: ${spec.title}` : "Exit spec mode" : `Running ${n.toolUse.name}`,
+									kind: isExitSpecMode ? "switch_mode" : void 0,
+									status: initialStatus,
+									rawInput: n.toolUse.input,
+									content: isExitSpecMode && spec?.plan ? [{
+										type: "content",
+										content: {
+											type: "text",
+											text: spec.plan
+										}
+									}] : void 0
+								}
+							});
+						} else {
+							const status = session.toolCallStatus.get(toolCallId);
+							if (status !== "completed" && status !== "failed" && status !== "pending") {
+								session.toolCallStatus.set(toolCallId, "in_progress");
+								await this.client.sessionUpdate({
+									sessionId: session.id,
+									update: {
+										sessionUpdate: "tool_call_update",
+										toolCallId,
+										status: "in_progress"
+									}
+								});
+							}
+						}
+					}
+					if (n.text) await this.client.sessionUpdate({
+						sessionId: session.id,
+						update: {
+							sessionUpdate: "agent_message_chunk",
+							content: {
+								type: "text",
+								text: n.text
+							}
+						}
+					});
+				}
+				break;
+			case "tool_result":
+				if (!session.activeToolCallIds.has(n.toolUseId)) {
+					session.activeToolCallIds.add(n.toolUseId);
+					const name = session.toolNames.get(n.toolUseId) ?? "Tool";
+					await this.client.sessionUpdate({
+						sessionId: session.id,
+						update: {
+							sessionUpdate: "tool_call",
+							toolCallId: n.toolUseId,
+							title: `Running ${name}`,
+							status: "in_progress"
+						}
+					});
+				}
+				const finalStatus = n.isError ? "failed" : "completed";
+				await this.client.sessionUpdate({
+					sessionId: session.id,
+					update: {
+						sessionUpdate: "tool_call_update",
+						toolCallId: n.toolUseId,
+						content: [{
+							type: "content",
+							content: {
+								type: "text",
+								text: n.content
+							}
+						}],
+						rawOutput: n.content,
+						status: finalStatus
+					}
+				});
+				session.toolCallStatus.set(n.toolUseId, finalStatus);
+				session.activeToolCallIds.delete(n.toolUseId);
+				break;
+			case "error":
+				await this.client.sessionUpdate({
+					sessionId: session.id,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Error: ${n.message}`
+						}
+					}
+				});
+				if (session.promptResolve) {
+					session.promptResolve({ stopReason: "end_turn" });
+					session.promptResolve = null;
+				}
+				break;
+			case "complete":
+				if (session.promptResolve) {
+					session.promptResolve({ stopReason: "end_turn" });
+					session.promptResolve = null;
+				}
+				break;
+		}
+	}
+	async cleanup() {
+		for (const [, session] of this.sessions) await session.droid.stop();
+		this.sessions.clear();
+	}
+};
+function runAcp() {
+	new AgentSideConnection((client) => new DroidAcpAgent(client), ndJsonStream(nodeToWebWritable(process.stdout), nodeToWebReadable(process.stdin)));
+}
+
+//#endregion
+export { Pushable as a, createDroidAdapter as i, runAcp as n, findDroidExecutable as o, ACP_MODES as r, isWindows as s, DroidAcpAgent as t };
+//# sourceMappingURL=acp-agent-Ddz1S3Jm.mjs.map