@bunny-agent/runner-cli 0.10.0-release.6 → 0.10.1-beta.2

package/dist/bundle.mjs

@@ -6,12 +6,12 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { config as config3 } from "dotenv";
 import { parseArgs } from "node:util";
 
 // ../../packages/server-acp/dist/acp-agent.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // ../../node_modules/.pnpm/@agentclientprotocol+sdk@1.2.1_zod@4.6.7/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 var AGENT_METHODS = {
@@ -5132,7 +5132,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve5) {
+function isRecursive(inst, stack, resolve6) {
   const cached3 = recursive.get(inst);
   if (cached3 !== void 0)
     return cached3 ? PROVEN : NONE;
@@ -5142,7 +5142,7 @@ function isRecursive(inst, stack, resolve5) {
   let result = NONE;
   const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve5);
+      const answer = isRecursive(child, stack, resolve6);
       if (answer > result)
         result = answer;
     }
@@ -5153,7 +5153,7 @@ function isRecursive(inst, stack, resolve5) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve6) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -5217,7 +5217,7 @@ function isRecursive(inst, stack, resolve5) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve6 ? inst._zod.innerType : void 0);
       merge3(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -21764,12 +21764,12 @@ var Connection = class {
     const id = this.nextRequestId++;
     let cancel = () => {
     };
-    const responsePromise = new Promise((resolve5, reject) => {
+    const responsePromise = new Promise((resolve6, reject) => {
       const pendingResponse = {
         resolve: (response) => {
           try {
             const value = mapResponse ? mapResponse(response) : response;
-            resolve5(value);
+            resolve6(value);
           } catch (error109) {
             reject(error109);
           }
@@ -21847,8 +21847,8 @@ var Connection = class {
   initialize(stream, handlers) {
     this.stream = stream;
     this.staticHandlers = handlers;
-    this.closedPromise = new Promise((resolve5) => {
-      this.abortController.signal.addEventListener("abort", () => resolve5());
+    this.closedPromise = new Promise((resolve6) => {
+      this.abortController.signal.addEventListener("abort", () => resolve6());
     });
     void this.receive();
   }
@@ -22636,8 +22636,8 @@ var AsyncQueue = class {
     if (this.failed) {
       return Promise.reject(this.failure);
     }
-    return new Promise((resolve5, reject) => {
-      this.waiters.push({ resolve: resolve5, reject });
+    return new Promise((resolve6, reject) => {
+      this.waiters.push({ resolve: resolve6, reject });
     });
   }
 };
@@ -23929,6 +23929,12 @@ var AISDKStreamConverter = class {
         if (message.type === "stream_event") {
           const streamEvent = message;
           const event = streamEvent.event;
+          const parentToolCallId = message.parent_tool_use_id;
+          if (!parentToolCallId && event.type === "message_start") {
+            yield this.emit({ type: "start-step", id: event.message.id });
+          } else if (!parentToolCallId && event.type === "message_stop") {
+            yield this.emit({ type: "finish-step" });
+          }
           if (event.type === "message_start" && !this.hasEmittedStart) {
             this.hasEmittedStart = true;
             yield this.emit({ type: "start", messageId: event.message.id });
@@ -23959,7 +23965,8 @@ var AISDKStreamConverter = class {
               toolName: tool.name,
               input: tool.input,
               dynamic: true,
-              providerExecuted: true
+              providerExecuted: true,
+              parentToolCallId: message.parent_tool_use_id
             });
           }
         }
@@ -23973,7 +23980,8 @@ var AISDKStreamConverter = class {
                 toolCallId: part.tool_use_id,
                 output: message.tool_use_result || part.content,
                 dynamic: true,
-                providerExecuted: true
+                providerExecuted: true,
+                parentToolCallId: message.parent_tool_use_id
               });
             }
           }
@@ -38037,6 +38045,21 @@ function createCanUseToolCallback(claudeOptions) {
         updatedInput: input2
       };
     }
+    if (claudeOptions.toolInteraction) {
+      const decision = await claudeOptions.toolInteraction({
+        toolCallId: toolUseID,
+        toolName,
+        input: input2,
+        signal: options.signal,
+        ...toolName === "AskUserQuestion" ? {
+          timeoutMs: claudeOptions.askUserQuestionTimeoutMs ?? DEFAULT_ASK_USER_QUESTION_TIMEOUT_MS
+        } : {}
+      });
+      return decision.behavior === "allow" ? {
+        behavior: "allow",
+        updatedInput: decision.updatedInput ?? input2
+      } : decision;
+    }
     const cwd = claudeOptions.cwd || process.cwd();
     try {
       const fs3 = await import("node:fs");
@@ -38086,7 +38109,7 @@ function createCanUseToolCallback(claudeOptions) {
           }
         } catch {
         }
-        await new Promise((resolve5) => setTimeout(resolve5, 500));
+        await new Promise((resolve6) => setTimeout(resolve6, 500));
       }
       try {
         fs3.unlinkSync(approvalFile);
@@ -38279,7 +38302,7 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
         id: textId,
         delta: word + " "
       });
-      await new Promise((resolve5) => setTimeout(resolve5, 20));
+      await new Promise((resolve6) => setTimeout(resolve6, 20));
     }
     yield formatDataStream({ type: "text-end", id: textId });
     yield formatDataStream({
@@ -38709,6 +38732,9 @@ ${inputToCodex}`;
           continue;
         }
         yield* ensureStart();
+        if (event.type === "turn.started") {
+          yield sseData({ type: "start-step" });
+        }
         if ((event.type === "item.started" || event.type === "item.updated" || event.type === "item.completed") && event.item.type === "agent_message") {
           const item = event.item;
           if (textTracker.markStarted(item.id)) {
@@ -38786,6 +38812,7 @@ ${inputToCodex}`;
           });
         }
         if (event.type === "turn.completed") {
+          yield sseData({ type: "finish-step" });
           yield sseData({
             type: "finish",
             finishReason: "stop",
@@ -38804,6 +38831,7 @@ ${inputToCodex}`;
           finished = true;
         }
         if (event.type === "turn.failed") {
+          yield sseData({ type: "finish-step" });
           yield sseData({ type: "error", errorText: event.error.message });
           yield sseData({ type: "finish", finishReason: "error" });
           yield `data: [DONE]
@@ -38845,6 +38873,7 @@ ${inputToCodex}`;
 }
 
 // ../../packages/runner-copilot/dist/copilot-runner.js
+import { randomUUID } from "node:crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join6 } from "node:path";
 import { approveAll, CopilotClient } from "@github/copilot-sdk";
@@ -38889,8 +38918,8 @@ var AsyncEventQueue = class {
           throw this.error;
         if (this.ended)
           return { value: void 0, done: true };
-        return new Promise((resolve5, reject) => {
-          this.waiters.push({ resolve: resolve5, reject });
+        return new Promise((resolve6, reject) => {
+          this.waiters.push({ resolve: resolve6, reject });
         });
       }
     };
@@ -38961,7 +38990,7 @@ function createFilePermissionHandler(cwd) {
           }
         } catch {
         }
-        await new Promise((resolve5) => setTimeout(resolve5, 500));
+        await new Promise((resolve6) => setTimeout(resolve6, 500));
       }
       return { kind: "reject", feedback: "Approval timed out." };
     } finally {
@@ -39009,7 +39038,46 @@ function createCopilotRunner(options) {
           enableConfigDiscovery: true,
           availableTools: options.allowedTools,
           systemMessage: options.systemPrompt ? { mode: "append", content: options.systemPrompt } : void 0,
-          onPermissionRequest: options.yolo ? approveAll : createFilePermissionHandler(cwd)
+          onPermissionRequest: options.yolo ? approveAll : options.toolInteraction ? async (request) => {
+            const decision = await options.toolInteraction({
+              toolCallId: request.toolCallId ?? randomUUID(),
+              toolName: permissionToolName(request),
+              input: request,
+              signal: options.abortController?.signal
+            });
+            return decision.behavior === "allow" ? { kind: "approved" } : { kind: "reject", feedback: decision.message };
+          } : createFilePermissionHandler(cwd),
+          ...options.toolInteraction ? {
+            onUserInputRequest: async (request) => {
+              const decision = await options.toolInteraction({
+                toolCallId: randomUUID(),
+                toolName: "ask_user_question",
+                input: {
+                  questions: [
+                    {
+                      question: request.question,
+                      allowFreeform: request.allowFreeform,
+                      ...request.choices ? {
+                        options: request.choices.map((label) => ({
+                          label
+                        }))
+                      } : {}
+                    }
+                  ]
+                },
+                signal: options.abortController?.signal
+              });
+              if (decision.behavior === "deny")
+                throw new Error(decision.message);
+              const answer = decision.updatedInput?.answers?.[request.question];
+              if (typeof answer !== "string")
+                throw new Error("The client did not supply an answer.");
+              return {
+                answer,
+                wasFreeform: !request.choices?.includes(answer)
+              };
+            }
+          } : {}
         };
         session = options.resume ? await client2.resumeSession(options.resume, sessionConfig) : await client2.createSession(sessionConfig);
         activeSession = session;
@@ -39042,6 +39110,14 @@ function createCopilotRunner(options) {
         const turn = session.sendAndWait(userInput).then(() => events.close()).catch((error109) => events.fail(error109));
         try {
           for await (const event of events) {
+            if (!event.agentId && event.type === "assistant.turn_start") {
+              yield sseData2({ type: "start-step", id: event.data.turnId });
+              continue;
+            }
+            if (!event.agentId && event.type === "assistant.turn_end") {
+              yield sseData2({ type: "finish-step" });
+              continue;
+            }
             if (event.type === "assistant.message_delta") {
               const { messageId, deltaContent } = event.data;
               if (!openText.has(messageId)) {
@@ -39264,8 +39340,8 @@ var AsyncQueue2 = class {
         if (this.ended) {
           return { value: void 0, done: true };
         }
-        return new Promise((resolve5, reject) => {
-          this.waiters.push({ resolve: resolve5, reject });
+        return new Promise((resolve6, reject) => {
+          this.waiters.push({ resolve: resolve6, reject });
         });
       }
     };
@@ -39293,9 +39369,10 @@ function usageMetadata(usage) {
   return {
     input_tokens: usage.inputTokens,
     output_tokens: usage.outputTokens,
-    cache_read_input_tokens: usage.cachedReadTokens ?? 0,
-    cache_creation_input_tokens: usage.cachedWriteTokens ?? 0,
-    reasoning_tokens: usage.thoughtTokens ?? 0
+    total_tokens: usage.totalTokens,
+    ...typeof usage.cachedReadTokens === "number" ? { cache_read_input_tokens: usage.cachedReadTokens } : {},
+    ...typeof usage.cachedWriteTokens === "number" ? { cache_creation_input_tokens: usage.cachedWriteTokens } : {},
+    ...typeof usage.thoughtTokens === "number" ? { reasoning_tokens: usage.thoughtTokens } : {}
   };
 }
 async function waitForFileApproval(cwd, request) {
@@ -39323,7 +39400,7 @@ async function waitForFileApproval(cwd, request) {
           return false;
       } catch {
       }
-      await new Promise((resolve5) => setTimeout(resolve5, 500));
+      await new Promise((resolve6) => setTimeout(resolve6, 500));
     }
     return false;
   } finally {
@@ -39388,6 +39465,7 @@ function createAcpProcessRunner(options) {
         startedText.clear();
       };
       const handleUpdate = (update) => {
+        output2.push(sseData3({ type: "data-acp-session-update", data: update }));
         if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
           const id = update.messageId ?? "acp-message";
           if (!startedText.has(id)) {
@@ -39456,13 +39534,34 @@ function createAcpProcessRunner(options) {
           finishReason: aborted3 ? "error" : finishReason(stopReason),
           messageMetadata: {
             sessionId,
+            acpStopReason: stopReason,
             usage: usageMetadata(usage)
           }
         }));
         output2.push("data: [DONE]\n\n");
         output2.close();
       };
-      const app = client({ name: "bunny-agent" }).onRequest(methods.client.session.requestPermission, ({ params }) => resolvePermission(cwd, options.yolo ?? false, params)).onNotification(methods.client.session.update, ({ params }) => {
+      const app = client({ name: "bunny-agent" }).onRequest(methods.client.session.requestPermission, async ({ params }) => {
+        if (!options.toolInteraction || options.yolo) {
+          return resolvePermission(cwd, options.yolo ?? false, params);
+        }
+        const decision = await options.toolInteraction({
+          toolCallId: params.toolCall.toolCallId,
+          toolName: params.toolCall.title ?? "tool",
+          input: params.toolCall.rawInput,
+          permission: {
+            toolCall: params.toolCall,
+            options: params.options,
+            ...params._meta ? { _meta: params._meta } : {}
+          },
+          signal: options.abortController?.signal
+        });
+        const wanted = decision.behavior === "allow" ? "allow_once" : "reject_once";
+        const selected = params.options.find((option) => decision.optionId ? option.optionId === decision.optionId && (decision.behavior === "allow" ? ["allow_once", "allow_always"].includes(option.kind) : ["reject_once", "reject_always"].includes(option.kind)) : option.kind === wanted);
+        return {
+          outcome: selected ? { outcome: "selected", optionId: selected.optionId } : { outcome: "cancelled" }
+        };
+      }).onNotification(methods.client.session.update, ({ params }) => {
         if (acceptingLoadedUpdates && params.sessionId === loadedSessionId) {
           handleUpdate(params.update);
         }
@@ -39564,7 +39663,8 @@ function createGeminiRunner(options = {}) {
     abortController: options.abortController,
     systemPrompt: options.systemPrompt,
     resume: options.resume,
-    yolo: options.yolo
+    yolo: options.yolo,
+    toolInteraction: options.toolInteraction
   });
 }
 
@@ -39582,7 +39682,8 @@ function createOpenCodeRunner(options = {}) {
     abortController: options.abortController,
     systemPrompt: options.systemPrompt,
     resume: options.resume,
-    yolo: options.yolo
+    yolo: options.yolo,
+    toolInteraction: options.toolInteraction
   });
 }
 
@@ -41045,7 +41146,7 @@ function buildImageEditTool(cwd, imageModelId, baseUrl, apiKey) {
     parameters: editImageSchema,
     async execute(_toolCallId, params, signal, _onUpdate) {
       const { readFileSync: readFileSync8, existsSync: existsSync12 } = await import("node:fs");
-      const { resolve: resolve5, basename: basename3 } = await import("node:path");
+      const { resolve: resolve6, basename: basename3 } = await import("node:path");
       const p = params;
       const imagePath = p.image;
       const prompt = p.prompt;
@@ -41056,7 +41157,7 @@ function buildImageEditTool(cwd, imageModelId, baseUrl, apiKey) {
       const imageSize = p.imageSize;
       const rawFilename = p.filename;
       const safePrompt = buildPolicySafeEditPrompt(prompt);
-      const resolvedImage = resolve5(cwd, imagePath);
+      const resolvedImage = resolve6(cwd, imagePath);
       if (!existsSync12(resolvedImage)) {
         return {
           content: [
@@ -41100,7 +41201,7 @@ function buildImageEditTool(cwd, imageModelId, baseUrl, apiKey) {
           }
         ];
         if (maskPath) {
-          const resolvedMask = resolve5(cwd, maskPath);
+          const resolvedMask = resolve6(cwd, maskPath);
           if (existsSync12(resolvedMask)) {
             files.push({
               name: "mask",
@@ -41759,6 +41860,7 @@ var PiAISDKStreamConverter = class {
     this.emittedSources = /* @__PURE__ */ new Set();
     this.lastEndedContentIndex = -1;
     this.textInputEnded = false;
+    this.stepNumber = 0;
     this.registry = options.sourceRegistry ?? new SourceRegistry();
   }
   /** Ingest only against an active text part in its already selected mode. */
@@ -41781,6 +41883,10 @@ var PiAISDKStreamConverter = class {
     if (event.type === "message_start") {
       const msg = event.message;
       if (msg?.role === "assistant") {
+        chunks.push(sseData4({
+          type: "start-step",
+          id: `${this.messageId}:step:${++this.stepNumber}`
+        }));
         chunks.push(...this.endTextStreamIfOpen());
         this.currentContentIndex = void 0;
         this.lastEndedContentIndex = -1;
@@ -41788,6 +41894,12 @@ var PiAISDKStreamConverter = class {
       return chunks;
     }
     if (event.type === "message_end") {
+      if (event.message.role === "assistant") {
+        chunks.push(sseData4({
+          type: "finish-step",
+          id: `${this.messageId}:step:${this.stepNumber}`
+        }));
+      }
       if (this.options.searchContractVersion === 1 && event.message.role === "assistant") {
         chunks.push(...this.endTextStreamIfOpen(aborted3 || ["length", "aborted", "error"].includes(event.message.stopReason)));
       }
@@ -44663,6 +44775,25 @@ function approvalFilePath(cwd, toolCallId) {
   return path2.join(cwd, ".bunny-agent", "approvals", approvalFileName(toolCallId));
 }
 async function waitForApproval(options) {
+  if (options.toolInteraction) {
+    const decision = await options.toolInteraction({
+      toolCallId: options.toolCallId,
+      toolName: options.toolName,
+      input: options.input,
+      signal: options.signal,
+      timeoutMs: options.timeoutMs
+    });
+    if (decision.behavior === "deny")
+      return decision;
+    const updatedInput = decision.updatedInput ?? {};
+    return {
+      behavior: "allow",
+      updatedInput: {
+        questions: updatedInput.questions ?? options.input?.questions,
+        answers: updatedInput.answers ?? {}
+      }
+    };
+  }
   const { cwd, toolCallId, toolName, input: input2, signal, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, timeoutMs } = options;
   const approvalFile = approvalFilePath(cwd, toolCallId);
   const cleanup = () => {
@@ -44730,18 +44861,18 @@ async function waitForApproval(options) {
   }
 }
 function sleepWithAbort(ms, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     if (signal?.aborted) {
-      resolve5();
+      resolve6();
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve6();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve5();
+      resolve6();
     };
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -44813,7 +44944,8 @@ function buildAskUserQuestionTool(options) {
         input: params,
         signal: signal ?? options.fallbackSignal,
         pollIntervalMs: options.pollIntervalMs,
-        timeoutMs: options.timeoutMs ?? DEFAULT_ASK_USER_QUESTION_TIMEOUT_MS2
+        timeoutMs: options.timeoutMs ?? DEFAULT_ASK_USER_QUESTION_TIMEOUT_MS2,
+        toolInteraction: options.toolInteraction
       });
       if (decision.behavior === "deny") {
         throw new Error(decision.message);
@@ -44846,7 +44978,8 @@ function createToolApprovalExtension(options) {
           input: event.input,
           signal: ctx.signal ?? options.fallbackSignal,
           pollIntervalMs: options.pollIntervalMs,
-          timeoutMs: options.timeoutMs
+          timeoutMs: options.timeoutMs,
+          toolInteraction: options.toolInteraction
         });
         if (decision.behavior === "deny") {
           return {
@@ -45878,10 +46011,11 @@ function createPiRunner(options = {}) {
         const allowedTools = normalizeAllowedTools(options.allowedTools);
         const toolRefDefinitions = options.toolRefs && options.toolRefs.length > 0 ? buildToolDefinitionsFromRefs(options.toolRefs) : [];
         const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
-        const bypassApproval = Boolean(options.yolo) || isRoot;
+        const bypassApproval = Boolean(options.yolo) || isRoot && !options.toolInteraction;
         const approvalGate = {
           cwd,
-          fallbackSignal: options.abortController?.signal
+          fallbackSignal: options.abortController?.signal,
+          toolInteraction: options.toolInteraction
         };
         const askUserQuestionEnabled = allowedTools === void 0 || allowedTools.includes(ASK_USER_QUESTION_TOOL_NAME);
         const previousModel = sessionManager.buildSessionContext?.().model;
@@ -46007,8 +46141,8 @@ function createPiRunner(options = {}) {
               break;
             }
             if (!promptSettled && !aborted3 && eventQueue.length === 0) {
-              await new Promise((resolve5) => {
-                wakeConsumer = resolve5;
+              await new Promise((resolve6) => {
+                wakeConsumer = resolve6;
               });
             }
           }
@@ -46168,7 +46302,8 @@ function createRunner(options) {
     yolo: options.yolo,
     env,
     abortController,
-    askUserQuestionTimeoutMs: options.askUserQuestionTimeoutMs
+    askUserQuestionTimeoutMs: options.askUserQuestionTimeoutMs,
+    toolInteraction: options.toolInteraction
   };
   const input2 = options.input ? parseAgentTurnInputV1(options.input) : createLegacyAgentTurnInput(options.userInput ?? "");
   const rawStream = dispatchRunner(options.runner, base, cwd, options, input2);
@@ -46232,7 +46367,8 @@ function dispatchRunner(runner, base, cwd, options, input2) {
         abortController: base.abortController,
         systemPrompt: base.systemPrompt,
         resume: base.resume,
-        yolo: base.yolo
+        yolo: base.yolo,
+        toolInteraction: base.toolInteraction
       }).run(compiled.text);
     case "pi": {
       return createPiRunner({
@@ -46260,7 +46396,8 @@ function dispatchRunner(runner, base, cwd, options, input2) {
         abortController: base.abortController,
         systemPrompt: base.systemPrompt,
         resume: base.resume,
-        yolo: base.yolo
+        yolo: base.yolo,
+        toolInteraction: base.toolInteraction
       }).run(compiled.text);
     case "copilot": {
       const reasoningEfforts = ["low", "medium", "high", "xhigh"];
@@ -46274,6 +46411,7 @@ function dispatchRunner(runner, base, cwd, options, input2) {
         resume: base.resume,
         yolo: base.yolo,
         cwd,
+        toolInteraction: base.toolInteraction,
         env: base.env,
         abortController: base.abortController,
         ...options.effort && reasoningEfforts.includes(options.effort) ? {
@@ -46356,21 +46494,403 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 
+// ../../packages/server-acp/dist/tool-display.js
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "node:path";
+var recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+function toolKind(name) {
+  const key = name.toLowerCase().replace(/[\s_-]/g, "");
+  if (/^(read|readfile|list|ls|find|glob)/.test(key))
+    return "read";
+  if (/^(grep|search|websearch|ripgrep)/.test(key))
+    return "search";
+  if (/^(write|edit|multiedit|applypatch|replace|notebookedit)/.test(key))
+    return "edit";
+  if (/^(delete|remove|unlink)/.test(key))
+    return "delete";
+  if (/^(move|rename)/.test(key))
+    return "move";
+  if (/^(bash|shell|execute|exec|terminal|runcommand)/.test(key))
+    return "execute";
+  if (/^(fetch|webfetch|browse)/.test(key))
+    return "fetch";
+  if (/^(todo|plan|updateplan|task|agent)/.test(key))
+    return "think";
+  return "other";
+}
+function toolDisplay(name, input2, cwd) {
+  const value = recordOf(input2) ?? {};
+  const kind = toolKind(name);
+  const path3 = [value.file_path, value.path, value.filePath].find((candidate) => typeof candidate === "string" && candidate.length > 0);
+  const location = path3 && (isAbsolute2(path3) ? path3 : cwd ? resolve3(cwd, path3) : void 0);
+  const detail = path3 ?? [
+    value.command,
+    value.query,
+    value.pattern,
+    value.url,
+    value.description
+  ].find((candidate) => typeof candidate === "string" && candidate.length > 0);
+  const title = detail ? `${name}: ${detail.slice(0, 160)}` : name;
+  const oldText = value.old_string ?? value.oldText;
+  const newText = value.new_string ?? value.newText ?? value.content;
+  const content = kind === "edit" && path3 && typeof newText === "string" ? [
+    {
+      type: "diff",
+      path: location ?? path3,
+      ...typeof oldText === "string" ? { oldText } : {},
+      newText
+    }
+  ] : void 0;
+  return {
+    title,
+    kind,
+    ...location ? { locations: [{ path: location }] } : {},
+    ...content ? { content } : {}
+  };
+}
+function contentBlock(value) {
+  const item = recordOf(value);
+  if (!item)
+    return void 0;
+  if (item.type === "text" && typeof item.text === "string")
+    return item;
+  if ((item.type === "image" || item.type === "audio") && typeof item.data === "string" && typeof item.mimeType === "string")
+    return item;
+  if (item.type === "resource_link" && typeof item.uri === "string" && typeof item.name === "string") {
+    return item;
+  }
+  if (item.type === "resource" && recordOf(item.resource))
+    return item;
+  return void 0;
+}
+function toolContents(output2) {
+  const value = recordOf(output2);
+  const candidates = Array.isArray(output2) ? output2 : Array.isArray(value?.content) ? value.content : [];
+  const contents = candidates.flatMap((candidate) => {
+    const item = recordOf(candidate);
+    if (!item)
+      return [];
+    if (item.type === "diff" && typeof item.path === "string" && typeof item.newText === "string") {
+      return [item];
+    }
+    if (item.type === "terminal" && typeof item.terminalId === "string") {
+      return [item];
+    }
+    if (item.type === "content" && contentBlock(item.content))
+      return [item];
+    const block = contentBlock(item);
+    return block ? [{ type: "content", content: block }] : [];
+  });
+  if (contents.length > 0)
+    return contents;
+  const text = typeof output2 === "string" ? output2 : JSON.stringify(output2 ?? null);
+  return [{ type: "content", content: { type: "text", text } }];
+}
+function planEntries(input2) {
+  const value = recordOf(input2);
+  const entries = value?.todos ?? value?.plan;
+  if (!Array.isArray(entries))
+    return void 0;
+  return entries.flatMap((entry) => {
+    const item = recordOf(entry);
+    if (!item)
+      return [];
+    const description = item.content ?? item.step ?? item.subject;
+    if (typeof description !== "string")
+      return [];
+    const status = item.status === "completed" ? "completed" : item.status === "in_progress" ? "in_progress" : "pending";
+    return [
+      {
+        content: status === "in_progress" && typeof item.activeForm === "string" ? item.activeForm : description,
+        status,
+        priority: item.priority === "high" || item.priority === "low" ? item.priority : "medium"
+      }
+    ];
+  });
+}
+
+// ../../packages/server-acp/dist/interaction-bridge.js
+var BUNNY_INTERACTION_RESPOND_METHOD = "_bunny-agent/interaction/respond";
+var INTERACTIVE_RUNNERS = [
+  "claude",
+  "pi",
+  "gemini",
+  "opencode",
+  "copilot"
+];
+function createAcpToolInteraction(input2) {
+  return async (request) => {
+    if (request.signal?.aborted)
+      return { behavior: "deny", message: "The run was cancelled." };
+    const isQuestion = /^(ask_user_question|AskUserQuestion)$/.test(request.toolName);
+    const questions = isQuestion ? parseQuestions(request.input) : void 0;
+    if (isQuestion && !input2.supportsForm) {
+      return {
+        behavior: "deny",
+        message: "The connected ACP client does not support structured questions."
+      };
+    }
+    const form = questions ? buildQuestionForm(questions) : void 0;
+    const options = request.permission?.options ?? [
+      { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+      { optionId: "reject-once", name: "Reject", kind: "reject_once" }
+    ];
+    const interaction = input2.registry.create(input2.sessionId, (reply) => {
+      if (!["accept", "decline", "cancel"].includes(reply.action))
+        throw new Error("Invalid interaction action.");
+      if (form && reply.action === "accept")
+        form.answers(reply.content ?? {});
+      if (!form && reply.action !== "cancel" && !options.some((option) => option.optionId === reply.optionId)) {
+        throw new Error("A permission reply must select a reported permission option.");
+      }
+    });
+    const controller = new AbortController();
+    const cancel = () => {
+      void input2.registry.respond(input2.sessionId, interaction.id, { action: "cancel" }).catch(() => void 0);
+      controller.abort();
+    };
+    request.signal?.addEventListener("abort", cancel, { once: true });
+    if (request.signal?.aborted)
+      cancel();
+    const timer = request.timeoutMs === void 0 ? void 0 : setTimeout(cancel, Math.max(0, request.timeoutMs));
+    timer?.unref?.();
+    const meta5 = {
+      "bunny-agent": {
+        interactionId: interaction.id,
+        toolCallId: request.toolCallId
+      }
+    };
+    const remoteReply = form ? input2.client.request("elicitation/create", {
+      sessionId: input2.sessionId,
+      toolCallId: request.toolCallId,
+      mode: "form",
+      message: "The agent needs your answer to continue.",
+      requestedSchema: form.schema,
+      _meta: { ...meta5, "bunny-agent/questions": questions }
+    }, { cancellationSignal: controller.signal }).then((reply) => ({
+      action: reply.action,
+      ...reply.action === "accept" && reply.content ? { content: reply.content } : {}
+    })) : permissionRequest(input2, request, options, meta5, controller.signal);
+    void remoteReply.then((reply) => input2.registry.respond(input2.sessionId, interaction.id, reply)).catch(() => input2.registry.respond(input2.sessionId, interaction.id, { action: "cancel" }).catch(() => void 0));
+    try {
+      const reply = await interaction.promise;
+      if (form) {
+        return reply.action === "accept" ? {
+          behavior: "allow",
+          updatedInput: {
+            questions,
+            answers: form.answers(reply.content ?? {})
+          }
+        } : {
+          behavior: "deny",
+          message: reply.action === "decline" ? "The user declined to answer." : "The question was cancelled or expired."
+        };
+      }
+      const selected = options.find((option) => option.optionId === reply.optionId);
+      return selected && ["allow_once", "allow_always"].includes(selected.kind) && reply.action === "accept" ? {
+        behavior: "allow",
+        updatedInput: recordOf(request.input),
+        optionId: selected.optionId
+      } : {
+        behavior: "deny",
+        message: "The user did not authorize this tool.",
+        ...selected ? { optionId: selected.optionId } : {}
+      };
+    } finally {
+      input2.registry.acknowledge(interaction.id);
+      if (timer)
+        clearTimeout(timer);
+      request.signal?.removeEventListener("abort", cancel);
+      controller.abort();
+    }
+  };
+}
+async function permissionRequest(input2, request, options, meta5, signal) {
+  const reply = await input2.client.request("session/request_permission", {
+    sessionId: input2.sessionId,
+    toolCall: request.permission?.toolCall ?? {
+      toolCallId: request.toolCallId,
+      ...toolDisplay(request.toolName, request.input, input2.cwd),
+      status: "pending",
+      rawInput: request.input
+    },
+    options,
+    _meta: { ...request.permission?._meta, ...meta5 }
+  }, { cancellationSignal: signal });
+  if (reply.outcome.outcome !== "selected")
+    return { action: "cancel" };
+  const optionId = reply.outcome.optionId;
+  return {
+    // ACP's selected outcome confirms a choice, including a rejection. Tool
+    // disposition is derived from the selected option's kind by the gate.
+    action: "accept",
+    optionId
+  };
+}
+function parseQuestions(input2) {
+  const raw = recordOf(input2)?.questions;
+  if (!Array.isArray(raw) || raw.length === 0 || raw.length > 8)
+    throw new Error("A survey must contain 1 to 8 questions.");
+  return raw.map((item) => {
+    const question = recordOf(item);
+    if (typeof question?.question !== "string" || !question.question.trim())
+      throw new Error("A survey question must have text.");
+    const options = Array.isArray(question.options) ? question.options.map((option) => {
+      const value = recordOf(option);
+      if (typeof value?.label !== "string" || !value.label)
+        throw new Error("Question options must have labels.");
+      return {
+        label: value.label,
+        ...typeof value.description === "string" ? { description: value.description } : {}
+      };
+    }) : void 0;
+    return {
+      question: question.question,
+      ...typeof question.header === "string" ? { header: question.header } : {},
+      multiSelect: question.multiSelect === true,
+      ...question.allowFreeform === false ? { allowFreeform: false } : {},
+      ...options ? { options } : {}
+    };
+  });
+}
+function buildQuestionForm(questions) {
+  const properties = {};
+  questions.forEach((question, index) => {
+    const key = `question_${index}`;
+    const title = question.header ? `${question.header}: ${question.question}` : question.question;
+    const choices = question.options?.map((option) => option.label);
+    const selectable = choices && question.allowFreeform !== false ? [...choices, "Other"] : choices;
+    properties[key] = choices?.length ? question.multiSelect ? {
+      type: "array",
+      title,
+      items: { type: "string", enum: selectable },
+      minItems: 1
+    } : { type: "string", title, enum: selectable } : { type: "string", title, minLength: 1 };
+    if (choices?.length && question.allowFreeform !== false)
+      properties[`${key}_other`] = {
+        type: "string",
+        title: `Other answer: ${question.question}`
+      };
+  });
+  return {
+    schema: {
+      type: "object",
+      properties,
+      required: questions.map((_, index) => `question_${index}`)
+    },
+    answers: (content) => Object.fromEntries(questions.map((question, index) => {
+      const key = `question_${index}`;
+      const supplied = content[key];
+      const choices = question.options?.map((option) => option.label);
+      const values = question.multiSelect && choices?.length ? Array.isArray(supplied) && supplied.every((item) => typeof item === "string") ? supplied : [] : typeof supplied === "string" && supplied.trim() ? [supplied] : [];
+      if (values.length === 0 || choices?.length && values.some((item) => !choices.includes(item) && !(item === "Other" && question.allowFreeform !== false))) {
+        throw new Error(`Invalid answer for ${question.question}`);
+      }
+      const answer = values.map((value) => {
+        if (value !== "Other" || !choices?.length)
+          return value;
+        const other = content[`${key}_other`];
+        if (typeof other !== "string" || !other.trim())
+          throw new Error(`A custom answer is required for ${question.question}`);
+        return other;
+      }).join(", ");
+      return [question.question, answer];
+    }))
+  };
+}
+
+// ../../packages/server-acp/dist/interaction-registry.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+var AcpInteractionRegistry = class {
+  pending = /* @__PURE__ */ new Map();
+  create(sessionId, validate2) {
+    const id = randomUUID2();
+    let resolve6;
+    let acknowledge;
+    const promise3 = new Promise((done) => {
+      resolve6 = done;
+    });
+    const accepted = new Promise((done) => {
+      acknowledge = done;
+    });
+    this.pending.set(id, {
+      sessionId,
+      promise: promise3,
+      resolve: resolve6,
+      accepted,
+      acknowledge,
+      validate: validate2
+    });
+    return { id, promise: promise3 };
+  }
+  async respond(sessionId, id, reply) {
+    const pending = this.pending.get(id);
+    if (!pending || pending.sessionId !== sessionId)
+      throw new Error("Interaction is unknown or expired.");
+    pending.validate?.(reply);
+    if (pending.reply && canonical(pending.reply) !== canonical(reply)) {
+      throw new Error("Interaction was already resolved with a different decision.");
+    }
+    if (!pending.reply) {
+      pending.reply = reply;
+      pending.resolve(reply);
+    }
+    await pending.accepted;
+    return { ok: true };
+  }
+  acknowledge(id) {
+    this.pending.get(id)?.acknowledge();
+    if (this.pending.size > 1e3) {
+      for (const [key, pending] of this.pending) {
+        if (pending.reply && key !== id) {
+          this.pending.delete(key);
+          break;
+        }
+      }
+    }
+  }
+};
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+
+// ../../packages/server-acp/dist/lifecycle.js
+var BUNNY_ACP_EVENT_METHOD = "_bunny-agent/session_event";
+
 // ../../packages/server-acp/dist/session-update-serializer.js
-var asText = (value) => typeof value === "string" ? value : JSON.stringify(value ?? null);
 var AcpSessionUpdateSerializer = class {
+  options;
   startedTools = /* @__PURE__ */ new Set();
+  terminalTools = /* @__PURE__ */ new Set();
   toolTitles = /* @__PURE__ */ new Map();
+  toolInputs = /* @__PURE__ */ new Map();
+  completeToolInputs = /* @__PURE__ */ new Map();
+  taskPlan = /* @__PURE__ */ new Map();
   stopReasonValue = "end_turn";
   errorTextValue;
   sessionIdValue;
   inputTokensValue = 0;
   outputTokensValue = 0;
-  /** Stop reason for the prompt turn; valid once `serialize()` completes. */
+  usageReported = false;
+  extraUsage = {};
+  nativePassthrough = false;
+  stepNumber = 0;
+  activeStepId;
+  messageId;
+  turnId;
+  now;
+  constructor(options = {}) {
+    this.options = options;
+    this.turnId = options.turnId ?? "turn";
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  }
   get stopReason() {
-    return this.stopReasonValue;
+    return this.options.signal?.aborted ? "cancelled" : this.stopReasonValue;
   }
-  /** Error text emitted by the runner, if the turn failed. */
   get errorText() {
     return this.errorTextValue;
   }
@@ -46378,161 +46898,461 @@ var AcpSessionUpdateSerializer = class {
     return this.sessionIdValue;
   }
   get usage() {
-    const totalTokens = this.inputTokensValue + this.outputTokensValue;
-    if (totalTokens === 0)
+    if (!this.usageReported)
       return void 0;
     return {
+      ...this.extraUsage,
       inputTokens: this.inputTokensValue,
       outputTokens: this.outputTokensValue,
-      totalTokens
+      totalTokens: this.extraUsage.totalTokens ?? this.inputTokensValue + this.outputTokensValue
     };
   }
+  /** Compatibility API for consumers interested only in standard ACP updates. */
   async *serialize(chunks) {
-    for await (const chunk of chunks) {
-      yield* this.convert(chunk);
+    for await (const event of this.serializeEvents(chunks)) {
+      if (event.type === "update")
+        yield event.update;
+    }
+  }
+  async *serializeEvents(chunks) {
+    yield this.lifecycle("turn_started");
+    try {
+      for await (const chunk of chunks)
+        yield* this.convert(chunk);
+    } catch (error109) {
+      this.errorTextValue = error109 instanceof Error ? error109.message : String(error109);
+      this.stopReasonValue = "refusal";
+      throw error109;
+    } finally {
+      for (const id of this.startedTools) {
+        if (this.terminalTools.has(id))
+          continue;
+        this.terminalTools.add(id);
+        const message = this.stopReason === "cancelled" ? "The tool was interrupted when the turn was cancelled." : "The turn ended before this tool returned.";
+        yield this.update({
+          sessionUpdate: "tool_call_update",
+          toolCallId: id,
+          status: "failed",
+          rawOutput: message,
+          content: [
+            { type: "content", content: { type: "text", text: message } }
+          ],
+          _meta: { "bunny-agent/interrupted": true }
+        });
+      }
+      if (this.activeStepId) {
+        yield this.lifecycle("step_finished", { stepId: this.activeStepId });
+        this.activeStepId = void 0;
+      }
+      yield this.lifecycle("turn_finished", {
+        stopReason: this.stopReason,
+        ...this.usage ? {
+          usage: Object.fromEntries(Object.entries(this.usage).filter(([, value]) => typeof value === "number"))
+        } : {}
+      });
     }
   }
+  lifecycle(type, fields = {}) {
+    return {
+      type: "lifecycle",
+      event: {
+        version: 1,
+        type,
+        turnId: this.turnId,
+        at: this.now(),
+        ...fields
+      }
+    };
+  }
+  update(update) {
+    return { type: "update", update };
+  }
+  metadata(chunk) {
+    const value = chunk;
+    const original = recordOf(value._meta);
+    const providerMetadata = recordOf(value.providerMetadata);
+    const parentToolCallId = value.parentToolCallId ?? value.parent_tool_use_id;
+    if (!original && !providerMetadata && typeof parentToolCallId !== "string")
+      return void 0;
+    return {
+      ...original,
+      ...providerMetadata ? { "bunny-agent/providerMetadata": providerMetadata } : {},
+      ...typeof parentToolCallId === "string" ? { "bunny-agent/parentToolCallId": parentToolCallId } : {}
+    };
+  }
   *convert(chunk) {
+    const value = chunk;
+    const meta5 = this.metadata(chunk);
+    if (chunk.type === "data-acp-session-update") {
+      const original = recordOf(value.data);
+      if (typeof original?.sessionUpdate === "string") {
+        this.nativePassthrough = true;
+        if ((original.sessionUpdate === "tool_call" || original.sessionUpdate === "tool_call_update") && typeof original.toolCallId === "string") {
+          this.startedTools.add(original.toolCallId);
+          if (original.status === "completed" || original.status === "failed")
+            this.terminalTools.add(original.toolCallId);
+        }
+        yield this.update(original);
+      }
+      return;
+    }
+    if (this.nativePassthrough && ![
+      "finish",
+      "message-metadata",
+      "error",
+      "step-finish",
+      "finish-step"
+    ].includes(chunk.type))
+      return;
     switch (chunk.type) {
-      case "text-delta": {
-        const { id, delta } = chunk;
-        yield {
-          sessionUpdate: "agent_message_chunk",
-          messageId: id,
-          content: { type: "text", text: delta }
-        };
+      case "text-start":
+        if (typeof value.id === "string")
+          this.messageId = value.id;
+        return;
+      case "text-delta":
+      case "reasoning":
+      case "reasoning-delta": {
+        const text = chunk.type === "reasoning" ? value.text : value.delta;
+        if (typeof text !== "string")
+          return;
+        if (chunk.type === "text-delta" && typeof value.id === "string")
+          this.messageId = value.id;
+        yield this.update({
+          sessionUpdate: chunk.type === "text-delta" ? "agent_message_chunk" : "agent_thought_chunk",
+          ...typeof value.id === "string" ? { messageId: value.id } : {},
+          content: { type: "text", text },
+          ...meta5 ? { _meta: meta5 } : {}
+        });
         return;
       }
-      case "reasoning": {
-        const { text } = chunk;
-        yield {
-          sessionUpdate: "agent_thought_chunk",
-          content: { type: "text", text }
-        };
+      case "text-end": {
+        if (!meta5)
+          return;
+        yield this.update({
+          sessionUpdate: "agent_message_chunk",
+          messageId: value.id,
+          content: { type: "text", text: "" },
+          _meta: meta5
+        });
         return;
       }
       case "tool-input-start": {
-        const { toolCallId, toolName } = chunk;
-        yield* this.openToolCall(toolCallId, toolName);
+        if (typeof value.toolCallId !== "string")
+          return;
+        yield* this.openToolCall(value.toolCallId, typeof value.toolName === "string" ? value.toolName : void 0, meta5);
+        return;
+      }
+      case "tool-input-delta": {
+        if (typeof value.toolCallId !== "string" || typeof value.inputTextDelta !== "string")
+          return;
+        const inputText = (this.toolInputs.get(value.toolCallId) ?? "") + value.inputTextDelta;
+        this.toolInputs.set(value.toolCallId, inputText);
+        yield* this.openToolCall(value.toolCallId, this.toolTitles.get(value.toolCallId));
+        yield this.update({
+          sessionUpdate: "tool_call_update",
+          toolCallId: value.toolCallId,
+          _meta: { ...meta5, "bunny-agent/inputText": inputText }
+        });
         return;
       }
       case "tool-input-available": {
-        const { toolCallId, toolName, input: input2 } = chunk;
-        yield* this.openToolCall(toolCallId, toolName);
-        yield {
+        if (typeof value.toolCallId !== "string")
+          return;
+        const name = typeof value.toolName === "string" ? value.toolName : this.toolTitles.get(value.toolCallId) ?? "tool";
+        this.completeToolInputs.set(value.toolCallId, value.input);
+        yield* this.openToolCall(value.toolCallId, name, meta5);
+        yield this.update({
           sessionUpdate: "tool_call_update",
-          toolCallId,
+          toolCallId: value.toolCallId,
+          ...toolDisplay(name, value.input, this.options.cwd),
           status: "in_progress",
-          rawInput: input2
-        };
+          rawInput: value.input,
+          ...meta5 ? { _meta: meta5 } : {}
+        });
+        const entries = planEntries(value.input);
+        if (entries && /todo|plan/i.test(name))
+          yield this.update({ sessionUpdate: "plan", entries });
         return;
       }
-      case "tool-output-available": {
-        const { toolCallId, output: output2, isError } = chunk;
-        yield* this.openToolCall(toolCallId, this.toolTitles.get(toolCallId));
-        yield {
+      case "tool-output-available":
+      case "tool-output-error":
+      case "tool-input-error":
+      case "tool-output-denied": {
+        if (typeof value.toolCallId !== "string")
+          return;
+        yield* this.openToolCall(value.toolCallId, this.toolTitles.get(value.toolCallId));
+        const failed = chunk.type !== "tool-output-available" || value.isError === true;
+        const output2 = chunk.type === "tool-output-denied" ? "Tool execution was denied." : chunk.type === "tool-output-available" ? value.output : value.errorText;
+        this.terminalTools.add(value.toolCallId);
+        yield this.update({
           sessionUpdate: "tool_call_update",
-          toolCallId,
-          status: isError ? "failed" : "completed",
+          toolCallId: value.toolCallId,
+          status: failed ? "failed" : "completed",
           rawOutput: output2,
-          content: [
-            {
-              type: "content",
-              content: { type: "text", text: asText(output2) }
+          content: toolContents(output2),
+          ...meta5 ? { _meta: meta5 } : {}
+        });
+        if (!failed) {
+          const entries = this.updateTaskPlan(value.toolCallId, output2);
+          if (entries)
+            yield this.update({ sessionUpdate: "plan", entries });
+        }
+        return;
+      }
+      case "file":
+      case "source-url":
+      case "source-document": {
+        const uri = value.url ?? value.uri;
+        const name = value.filename ?? value.title ?? value.sourceId ?? "Resource";
+        const mimeType = value.mediaType ?? value.mimeType;
+        let content;
+        if (typeof uri === "string") {
+          const inline = /^data:([^;,]+);base64,(.*)$/s.exec(uri);
+          content = inline ? inline[1]?.startsWith("image/") ? { type: "image", mimeType: inline[1], data: inline[2] ?? "" } : inline[1]?.startsWith("audio/") ? { type: "audio", mimeType: inline[1], data: inline[2] ?? "" } : {
+            type: "resource",
+            resource: {
+              uri: String(name),
+              mimeType: inline[1],
+              blob: inline[2] ?? ""
             }
-          ]
-        };
+          } : {
+            type: "resource_link",
+            uri,
+            name: String(name),
+            ...typeof mimeType === "string" ? { mimeType } : {}
+          };
+        } else if (chunk.type === "source-document") {
+          content = {
+            type: "resource_link",
+            uri: `bunny-source:${encodeURIComponent(String(value.sourceId ?? name))}`,
+            name: String(name),
+            ...typeof mimeType === "string" ? { mimeType } : {}
+          };
+        }
+        if (content)
+          yield this.update({
+            sessionUpdate: "agent_message_chunk",
+            content,
+            ...typeof value.id === "string" ? { messageId: value.id } : this.messageId ? { messageId: this.messageId } : {},
+            _meta: {
+              ...meta5,
+              ...value.sourceId ? { "bunny-agent/sourceId": value.sourceId } : {}
+            }
+          });
+        if (chunk.type === "file" && typeof uri === "string" && !uri.startsWith("data:")) {
+          yield this.lifecycle("resource_update", {
+            resource: {
+              id: String(value.id ?? uri),
+              uri,
+              name: String(name),
+              ...typeof mimeType === "string" ? { mimeType } : {}
+            }
+          });
+        }
         return;
       }
-      case "tool-output-error": {
-        const { toolCallId, errorText } = chunk;
-        yield* this.openToolCall(toolCallId, this.toolTitles.get(toolCallId));
-        yield {
-          sessionUpdate: "tool_call_update",
-          toolCallId,
-          status: "failed",
-          rawOutput: errorText,
-          content: [
-            { type: "content", content: { type: "text", text: errorText } }
-          ]
-        };
+      case "start-step":
+      case "step-start": {
+        if (this.activeStepId)
+          yield this.lifecycle("step_finished", { stepId: this.activeStepId });
+        this.activeStepId = typeof value.stepId === "string" ? value.stepId : typeof value.id === "string" ? value.id : `${this.turnId}:step:${++this.stepNumber}`;
+        yield this.lifecycle("step_started", { stepId: this.activeStepId });
         return;
       }
-      case "error": {
-        const { errorText } = chunk;
-        this.errorTextValue = errorText;
-        this.stopReasonValue = "refusal";
+      case "finish-step":
+      case "step-finish": {
+        const usage = recordOf(value.usage);
+        if (usage) {
+          this.usageReported = true;
+          this.inputTokensValue += typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
+          this.outputTokensValue += typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
+        }
+        if (this.activeStepId)
+          yield this.lifecycle("step_finished", { stepId: this.activeStepId });
+        this.activeStepId = void 0;
         return;
       }
+      case "error":
+        this.errorTextValue = typeof value.errorText === "string" ? value.errorText : "Runner failed.";
+        this.stopReasonValue = "refusal";
+        return;
       case "finish": {
-        const { finishReason: finishReason2, messageMetadata } = chunk;
-        this.captureMetadata(messageMetadata);
+        this.captureMetadata(value.messageMetadata);
         if (this.errorTextValue === void 0) {
-          this.stopReasonValue = mapFinishReason2(finishReason2);
+          const metadata = recordOf(value.messageMetadata);
+          this.stopReasonValue = isStopReason(metadata?.acpStopReason) ? metadata.acpStopReason : mapFinishReason2(value.finishReason);
         }
         return;
       }
-      case "step-finish": {
-        const usage = chunk.usage;
-        this.inputTokensValue += usage?.inputTokens ?? 0;
-        this.outputTokensValue += usage?.outputTokens ?? 0;
-        return;
-      }
-      case "message-metadata": {
-        this.captureMetadata(chunk.messageMetadata);
+      case "message-metadata":
+        this.captureMetadata(value.messageMetadata);
+        yield this.update({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "" },
+          _meta: { "bunny-agent/messageMetadata": value.messageMetadata }
+        });
         return;
+      default: {
+        const data = recordOf(value.data);
+        if (chunk.type === "data-artifact" && data) {
+          const uri = data.uri ?? data.url ?? data.path;
+          if (typeof uri === "string") {
+            yield this.lifecycle("resource_update", {
+              resource: {
+                id: String(data.id ?? data.artifactId ?? uri),
+                uri,
+                name: String(data.name ?? data.title ?? data.artifactId ?? "Artifact"),
+                ...typeof data.mimeType === "string" ? { mimeType: data.mimeType } : {},
+                _meta: data
+              }
+            });
+          }
+        } else if ((chunk.type === "data-job" || chunk.type === "data-agent-job") && data && typeof data.id === "string" && typeof data.status === "string") {
+          yield this.lifecycle("job_update", {
+            job: {
+              id: data.id,
+              title: typeof data.title === "string" ? data.title : "Background task",
+              status: data.status,
+              ...typeof data.message === "string" ? { message: data.message } : {}
+            }
+          });
+        }
+        const block = contentBlock(value.content);
+        if (block)
+          yield this.update({
+            sessionUpdate: "agent_message_chunk",
+            content: block,
+            ...meta5 ? { _meta: meta5 } : {}
+          });
+        else if (chunk.type.startsWith("data-") || chunk.type === "compaction") {
+          yield this.update({
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: "" },
+            _meta: { "bunny-agent/runnerData": value }
+          });
+        }
       }
-      // text-start/text-end have no ACP equivalent (agent_message_chunk carries
-      // messageId), and tool-input-delta has no incremental-input counterpart.
-      default:
-        return;
     }
   }
   captureMetadata(metadata) {
-    if (!metadata || typeof metadata !== "object")
+    const value = recordOf(metadata);
+    if (!value)
       return;
-    const value = metadata;
     const sessionId = value.sessionId ?? value.session_id ?? value.sessionFile;
-    if (typeof sessionId === "string" && sessionId.length > 0) {
+    if (typeof sessionId === "string" && sessionId.length > 0)
       this.sessionIdValue = sessionId;
-    }
-    const usage = value.usage;
-    if (!usage || typeof usage !== "object")
+    const usage = recordOf(value.usage);
+    if (!usage)
       return;
-    const usageValue = usage;
-    if (typeof usageValue.inputTokens === "number") {
-      this.inputTokensValue = Math.max(this.inputTokensValue, usageValue.inputTokens);
-    }
-    if (typeof usageValue.outputTokens === "number") {
-      this.outputTokensValue = Math.max(this.outputTokensValue, usageValue.outputTokens);
-    }
-  }
-  *openToolCall(toolCallId, toolName) {
-    if (this.startedTools.has(toolCallId))
+    const input2 = usage.inputTokens ?? usage.input_tokens;
+    const output2 = usage.outputTokens ?? usage.output_tokens;
+    if (typeof input2 === "number") {
+      this.inputTokensValue = Math.max(this.inputTokensValue, input2);
+      this.usageReported = true;
+    }
+    if (typeof output2 === "number") {
+      this.outputTokensValue = Math.max(this.outputTokensValue, output2);
+      this.usageReported = true;
+    }
+    for (const [key, alias] of [
+      ["cachedReadTokens", "cache_read_input_tokens"],
+      ["cachedWriteTokens", "cache_creation_input_tokens"],
+      ["thoughtTokens", "reasoning_tokens"],
+      ["totalTokens", "total_tokens"]
+    ]) {
+      const count = usage[key] ?? usage[alias];
+      if (typeof count === "number")
+        this.extraUsage[key] = count;
+    }
+  }
+  *openToolCall(id, name, meta5) {
+    if (name)
+      this.toolTitles.set(id, name);
+    if (this.startedTools.has(id))
       return;
-    this.startedTools.add(toolCallId);
-    const title = toolName ?? "tool";
-    this.toolTitles.set(toolCallId, title);
-    yield {
+    this.startedTools.add(id);
+    const title = name ?? "tool";
+    this.toolTitles.set(id, title);
+    yield this.update({
       sessionUpdate: "tool_call",
-      toolCallId,
+      toolCallId: id,
       title,
-      status: "pending"
+      kind: toolKind(title),
+      status: "pending",
+      _meta: { ...meta5, "bunny-agent/toolName": title }
+    });
+  }
+  updateTaskPlan(id, output2) {
+    const name = this.toolTitles.get(id)?.toLowerCase().replace(/[\s_-]/g, "");
+    if (!["taskcreate", "taskupdate", "tasklist"].includes(name ?? ""))
+      return void 0;
+    const input2 = recordOf(this.completeToolInputs.get(id)) ?? {};
+    let result = recordOf(output2);
+    if (!result && typeof output2 === "string") {
+      try {
+        result = recordOf(JSON.parse(output2));
+      } catch {
+        const created = /^Task #(\S+) created successfully: (.+)$/m.exec(output2);
+        if (created)
+          result = { task: { id: created[1], subject: created[2] } };
+      }
+    }
+    const makeEntry = (task) => {
+      const content = task.subject ?? task.content;
+      if (typeof content !== "string")
+        return void 0;
+      return {
+        content,
+        priority: "medium",
+        status: task.status === "completed" ? "completed" : task.status === "in_progress" ? "in_progress" : "pending"
+      };
     };
+    if (name === "tasklist" && Array.isArray(result?.tasks)) {
+      this.taskPlan.clear();
+      for (const task of result.tasks) {
+        const value = recordOf(task);
+        const entry = value && makeEntry(value);
+        if (value && typeof value.id === "string" && entry)
+          this.taskPlan.set(value.id, entry);
+      }
+    } else if (name === "taskcreate") {
+      const task = recordOf(result?.task);
+      const entry = makeEntry({ ...input2, ...task });
+      if (typeof task?.id !== "string" || !entry)
+        return void 0;
+      this.taskPlan.set(task.id, entry);
+    } else if (name === "taskupdate" && typeof input2.taskId === "string") {
+      if (input2.status === "deleted")
+        this.taskPlan.delete(input2.taskId);
+      else {
+        const previous = this.taskPlan.get(input2.taskId);
+        const entry = makeEntry({ ...previous, ...input2 });
+        if (!entry)
+          return void 0;
+        this.taskPlan.set(input2.taskId, entry);
+      }
+    } else
+      return void 0;
+    return [...this.taskPlan.values()];
   }
 };
-function mapFinishReason2(finishReason2) {
-  switch (finishReason2) {
-    case "length":
-      return "max_tokens";
-    case "error":
-      return "refusal";
-    case "abort":
-    case "cancelled":
-      return "cancelled";
-    default:
-      return "end_turn";
-  }
+function isStopReason(value) {
+  return typeof value === "string" && [
+    "end_turn",
+    "max_tokens",
+    "max_turn_requests",
+    "refusal",
+    "cancelled"
+  ].includes(value);
+}
+function mapFinishReason2(reason) {
+  if (reason === "length")
+    return "max_tokens";
+  if (reason === "error")
+    return "refusal";
+  if (reason === "abort" || reason === "cancelled")
+    return "cancelled";
+  return "end_turn";
 }
 
 // ../../packages/server-acp/dist/acp-agent.js
@@ -46584,17 +47404,44 @@ var mergeEnv = (...sources) => {
 var promptToText = (prompt) => prompt.map((block) => block.type === "text" ? block.text : "").filter((text) => text.length > 0).join("\n");
 function createBunnyAgentAcpApp(options = {}) {
   const sessions = /* @__PURE__ */ new Map();
-  return agent({ name: "bunny-agent" }).onRequest(methods.agent.initialize, () => ({
-    protocolVersion: PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false, promptCapabilities: {} },
-    agentInfo: { name: "bunny-agent", version: "0.1.0" }
-  })).onRequest(methods.agent.session.new, ({ params }) => {
-    const sessionId = randomUUID();
+  const interactions = options.interactionRegistry ?? new AcpInteractionRegistry();
+  let capabilities = {};
+  return agent({ name: "bunny-agent" }).onRequest(methods.agent.initialize, ({ params }) => {
+    capabilities = params.clientCapabilities ?? {};
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: false,
+        promptCapabilities: {},
+        _meta: {
+          [BUNNY_META_KEY]: {
+            eventStream: 1,
+            permissionRequests: 1,
+            elicitation: 1,
+            interactionRespond: 1,
+            interactiveRunners: INTERACTIVE_RUNNERS
+          }
+        }
+      },
+      agentInfo: { name: "bunny-agent", version: "0.1.0" }
+    };
+  }).onRequest(methods.agent.session.new, ({ params }) => {
+    const sessionId = randomUUID3();
     sessions.set(sessionId, {
       cwd: params.cwd ?? options.defaultCwd ?? process.cwd(),
       ...readBunnyMeta(params._meta)
     });
-    return { sessionId };
+    const runner = readBunnyMeta(params._meta).runner ?? options.defaultRunner ?? "claude";
+    return {
+      sessionId,
+      _meta: {
+        [BUNNY_META_KEY]: {
+          runner,
+          permissionRequests: INTERACTIVE_RUNNERS.includes(runner) ? 1 : 0,
+          elicitation: ["claude", "pi", "copilot"].includes(runner) ? 1 : 0
+        }
+      }
+    };
   }).onRequest(methods.agent.session.prompt, async ({ params, client: client2, signal }) => {
     const session = sessions.get(params.sessionId);
     if (!session) {
@@ -46608,12 +47455,20 @@ function createBunnyAgentAcpApp(options = {}) {
       abort.abort();
     else
       signal.addEventListener("abort", onTransportAbort, { once: true });
-    const serializer = new AcpSessionUpdateSerializer();
+    const turnId = randomUUID3();
+    const serializer = new AcpSessionUpdateSerializer({
+      turnId,
+      cwd: session.cwd,
+      signal: abort.signal
+    });
+    const runner = turn.runner ?? session.runner ?? options.defaultRunner ?? "claude";
+    const extension = recordOf(recordOf(capabilities._meta)?.[BUNNY_META_KEY]);
+    const eventStream = extension?.eventStream === 1;
     try {
       let chunks;
       try {
         chunks = parseRunnerStream(createRunner({
-          runner: turn.runner ?? session.runner ?? options.defaultRunner ?? "claude",
+          runner,
           model: turn.model ?? session.model ?? options.defaultModel ?? DEFAULT_MODEL,
           ...turn.input ? { input: turn.input } : { userInput: promptToText(params.prompt) },
           systemPrompt: turn.systemPrompt ?? session.systemPrompt,
@@ -46629,6 +47484,15 @@ function createBunnyAgentAcpApp(options = {}) {
           mcpConfig: turn.mcpConfig ?? session.mcpConfig,
           effort: turn.effort ?? session.effort,
           askUserQuestionTimeoutMs: turn.askUserQuestionTimeoutMs ?? session.askUserQuestionTimeoutMs,
+          ...INTERACTIVE_RUNNERS.includes(runner) ? {
+            toolInteraction: createAcpToolInteraction({
+              sessionId: params.sessionId,
+              client: client2,
+              registry: interactions,
+              supportsForm: capabilities.elicitation?.form != null,
+              cwd: session.cwd
+            })
+          } : {},
           abortController: abort,
           // Caller owns session/resume; don't touch cwd/.bunny-agent.
           autoInject: false
@@ -46636,11 +47500,18 @@ function createBunnyAgentAcpApp(options = {}) {
       } catch (error109) {
         throw RequestError.invalidParams(void 0, error109 instanceof Error ? error109.message : String(error109));
       }
-      for await (const update of serializer.serialize(chunks)) {
-        await client2.notify(methods.client.session.update, {
-          sessionId: params.sessionId,
-          update
-        });
+      for await (const event of serializer.serializeEvents(chunks)) {
+        if (event.type === "update") {
+          await client2.notify(methods.client.session.update, {
+            sessionId: params.sessionId,
+            update: event.update
+          });
+        } else if (eventStream) {
+          await client2.notify(BUNNY_ACP_EVENT_METHOD, {
+            sessionId: params.sessionId,
+            event: event.event
+          });
+        }
       }
     } finally {
       signal.removeEventListener("abort", onTransportAbort);
@@ -46648,13 +47519,27 @@ function createBunnyAgentAcpApp(options = {}) {
     }
     const runnerMeta = {
       ...serializer.sessionId ? { sessionId: serializer.sessionId } : {},
-      ...serializer.errorText ? { errorText: serializer.errorText } : {}
+      ...serializer.errorText && !abort.signal.aborted ? { errorText: serializer.errorText } : {}
     };
     return {
       stopReason: serializer.stopReason,
       ...serializer.usage ? { usage: serializer.usage } : {},
       ...Object.keys(runnerMeta).length > 0 ? { _meta: { [BUNNY_META_KEY]: runnerMeta } } : {}
     };
+  }).onRequest(BUNNY_INTERACTION_RESPOND_METHOD, { parse: (value) => recordOf(value) ?? {} }, async ({ params }) => {
+    const value = recordOf(params);
+    if (typeof value?.sessionId !== "string" || typeof value.requestId !== "string" || !["accept", "decline", "cancel"].includes(String(value.action))) {
+      throw RequestError.invalidParams(void 0, "Invalid interaction response.");
+    }
+    try {
+      return await interactions.respond(value.sessionId, value.requestId, {
+        action: value.action,
+        ...recordOf(value.content) ? { content: value.content } : {},
+        ...typeof value.optionId === "string" ? { optionId: value.optionId } : {}
+      });
+    } catch (error109) {
+      throw RequestError.invalidParams(void 0, error109 instanceof Error ? error109.message : String(error109));
+    }
   }).onNotification(methods.agent.session.cancel, ({ params }) => {
     sessions.get(params.sessionId)?.abort?.abort();
   });
@@ -46704,17 +47589,17 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename2, dirname as dirname5, join as join15, resolve as resolve3 } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join15, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getPackageRoot() {
   const thisDir = dirname5(fileURLToPath2(import.meta.url));
-  return resolve3(thisDir, "..");
+  return resolve4(thisDir, "..");
 }
 function getShippedDockerfile() {
   const packageRoot = getPackageRoot();
   const candidates = [
     join15(packageRoot, "Dockerfile"),
-    resolve3(
+    resolve4(
       packageRoot,
       "..",
       "..",
@@ -46722,7 +47607,7 @@ function getShippedDockerfile() {
       "bunny-agent-claude",
       "Dockerfile"
     ),
-    resolve3(process.cwd(), "docker", "bunny-agent-claude", "Dockerfile")
+    resolve4(process.cwd(), "docker", "bunny-agent-claude", "Dockerfile")
   ];
   for (const p of candidates) {
     if (existsSync11(p)) return p;
@@ -46745,7 +47630,7 @@ function ensureDocker() {
   }
 }
 function resolveTemplatePath(template) {
-  const abs = resolve3(process.cwd(), template);
+  const abs = resolve4(process.cwd(), template);
   if (!existsSync11(abs)) {
     console.error(`\u274C Template directory not found: ${abs}`);
     process.exit(1);
@@ -46897,9 +47782,9 @@ async function runAgent(options) {
 }
 
 // src/cli.ts
-config3({ path: resolve4(process.cwd(), ".env"), quiet: true });
-config3({ path: resolve4(process.cwd(), "../.env"), quiet: true });
-config3({ path: resolve4(process.cwd(), "../../.env"), quiet: true });
+config3({ path: resolve5(process.cwd(), ".env"), quiet: true });
+config3({ path: resolve5(process.cwd(), "../.env"), quiet: true });
+config3({ path: resolve5(process.cwd(), "../../.env"), quiet: true });
 function getSubcommand() {
   for (let i = 2; i < process.argv.length; i++) {
     const a = process.argv[i];