@bunny-agent/runner-cli 0.9.28

package/dist/bundle.mjs

@@ -0,0 +1,2710 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { resolve as resolve3 } from "node:path";
+import { config } from "dotenv";
+import { parseArgs } from "node:util";
+
+// src/build-image.ts
+import { execSync } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function getPackageRoot() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(thisDir, "..");
+}
+function getShippedDockerfile() {
+  const packageRoot = getPackageRoot();
+  const candidates = [
+    join(packageRoot, "Dockerfile"),
+    resolve(
+      packageRoot,
+      "..",
+      "..",
+      "docker",
+      "bunny-agent-claude",
+      "Dockerfile"
+    )
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  console.error(
+    `\u274C Dockerfile not found. Searched:
+${candidates.map((c) => `   ${c}`).join("\n")}`
+  );
+  process.exit(1);
+}
+function run(cmd, cwd) {
+  execSync(cmd, { stdio: "inherit", cwd });
+}
+function ensureDocker() {
+  try {
+    execSync("docker info", { stdio: "ignore" });
+  } catch {
+    console.error("\u274C Docker is not running. Please start Docker first.");
+    process.exit(1);
+  }
+}
+function resolveTemplatePath(template) {
+  const abs = resolve(process.cwd(), template);
+  if (!existsSync(abs)) {
+    console.error(`\u274C Template directory not found: ${abs}`);
+    process.exit(1);
+  }
+  return abs;
+}
+function copyDirSync(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function buildImage(opts) {
+  const templatePath = opts.template ? resolveTemplatePath(opts.template) : null;
+  const templateName = templatePath ? basename(templatePath) : null;
+  const localImage = opts.image ?? `${opts.name}:${opts.tag}`;
+  console.log("\u{1F4E6} BunnyAgent Docker Image Builder");
+  console.log("========================");
+  console.log(`  Image: ${localImage}`);
+  console.log(`  Platform: ${opts.platform}`);
+  console.log(`  Template: ${templateName ?? "(none)"}`);
+  console.log(`  Push: ${opts.push}`);
+  console.log("");
+  ensureDocker();
+  const buildContext = join(process.cwd(), ".docker-staging");
+  mkdirSync(buildContext, { recursive: true });
+  let dockerfile = readFileSync(getShippedDockerfile(), "utf8");
+  if (templatePath && templateName) {
+    const destDir = join(buildContext, "templates", templateName);
+    mkdirSync(destDir, { recursive: true });
+    const claudeMd = join(templatePath, "CLAUDE.md");
+    if (existsSync(claudeMd))
+      copyFileSync(claudeMd, join(destDir, "CLAUDE.md"));
+    const claudeDir = join(templatePath, ".claude");
+    if (existsSync(claudeDir)) copyDirSync(claudeDir, join(destDir, ".claude"));
+    let copyLines = "\n# Template files\nRUN mkdir -p /opt/bunny-agent/templates";
+    if (existsSync(join(destDir, "CLAUDE.md"))) {
+      copyLines += `
+COPY templates/${templateName}/CLAUDE.md /opt/bunny-agent/templates/CLAUDE.md`;
+    }
+    if (existsSync(join(destDir, ".claude"))) {
+      copyLines += `
+COPY templates/${templateName}/.claude /opt/bunny-agent/templates/.claude`;
+    }
+    dockerfile = dockerfile.replace(/^CMD /m, `${copyLines}
+
+CMD `);
+    console.log("\u{1F9E9} Injected template files into Dockerfile");
+  }
+  writeFileSync(join(buildContext, "Dockerfile"), dockerfile);
+  console.log("\u{1F433} Building Docker image...");
+  run(
+    `docker build --platform=${opts.platform} -t ${localImage} -f ${join(buildContext, "Dockerfile")} ${buildContext}`
+  );
+  console.log(`
+\u2705 Image built: ${localImage}`);
+  if (!opts.push) return;
+  if (!localImage.includes("/")) {
+    console.error(
+      "\u274C --push requires --name to include namespace (e.g. vikadata/bunny-agent-seo)"
+    );
+    process.exit(1);
+  }
+  console.log("\u{1F680} Pushing image...");
+  run(`docker push ${localImage}`);
+  console.log(`
+\u2705 Image pushed: ${localImage}`);
+  const latestImage = `${opts.name}:latest`;
+  if (localImage !== latestImage) {
+    console.log("\u{1F3F7}\uFE0F Tagging and pushing latest...");
+    run(`docker tag ${localImage} ${latestImage}`);
+    run(`docker push ${latestImage}`);
+    console.log(`\u2705 Image pushed: ${latestImage}`);
+  }
+}
+
+// ../../packages/runner-harness/dist/agent-context.js
+var BUNNY_AGENT_SYSTEM_PROMPT = [
+  "You are Bunny Agent \u2014 an AI agent built to protect humans and push humanity forward.",
+  "",
+  "Your mission: work autonomously, accurately, and efficiently to complete tasks.",
+  "Be targeted and precise in your exploration and investigations.",
+  "",
+  "## Core Values",
+  "Protect human. Push humanity forward.",
+  "",
+  "## Tool-Use Rules",
+  "You MUST use your tools to take action \u2014 do not describe what you would do without actually doing it.",
+  "When you say you will perform an action, you MUST immediately make the corresponding tool call.",
+  "",
+  "NEVER answer these from memory or mental computation \u2014 ALWAYS use a tool:",
+  "- Arithmetic, math, calculations \u2192 use bash (python3 -c '...') for ALL computation",
+  "- Hashes, encodings, checksums \u2192 use bash (e.g. sha256sum, base64, python3)",
+  "- Current facts, counts, prices, dates \u2192 use web_search or web_fetch; never guess",
+  "- File contents \u2192 use bash or read_file",
+  "",
+  "Keep working until the task is fully complete and verified.",
+  "If a source returns empty or partial results, retry with a different query or strategy.",
+  "",
+  "## Research Methodology",
+  "1. Search for the specific source document (official website, Wikipedia, academic paper)",
+  "2. Verify you are looking at the correct version/date/edition if specified",
+  "3. Extract the exact data requested \u2014 do not summarize or paraphrase",
+  "4. Use Python (bash tool) for all arithmetic, counting, and unit conversions",
+  "5. Cross-check your answer against the question requirements before outputting",
+  "",
+  "## Operational Rules",
+  "- Always construct absolute file paths for file system operations",
+  "- Prefer parallel tool calls for independent lookups",
+  "- Verify file contents and structure before making assumptions",
+  "- Use flags like -y, --yes to prevent CLI tools from hanging on prompts",
+  "- If missing context is retrievable by tools, use the tool \u2014 ask only when not retrievable",
+  "",
+  "## Output Format",
+  "Provide the answer ONLY \u2014 no preamble, no 'The answer is', no explanation unless explicitly asked.",
+  "If the answer is a number, give only the number. If it's a name, give the exact name as it appears in the source."
+].join("\n");
+
+// ../../packages/runner-harness/dist/prompt.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+var PROMPT_FILES = ["CLAUDE.md", "AGENTS.md"];
+function loadSystemPrompt(cwd) {
+  let dir = cwd;
+  for (let i = 0; i < 5; i++) {
+    for (const name of PROMPT_FILES) {
+      const p = join2(dir, name);
+      if (existsSync2(p)) {
+        try {
+          return readFileSync2(p, "utf8").trim() || void 0;
+        } catch {
+        }
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return void 0;
+}
+
+// ../../packages/runner-claude/dist/ai-sdk-stream.js
+import { appendFileSync, existsSync as existsSync3, unlinkSync } from "node:fs";
+import { join as join3 } from "node:path";
+function trace(data, reset = false) {
+  if (process.env.DEBUG !== "true")
+    return;
+  try {
+    const file = join3(process.cwd(), "claude-message-stream-debug.json");
+    if (reset && existsSync3(file))
+      unlinkSync(file);
+    const entry = {
+      _t: (/* @__PURE__ */ new Date()).toISOString(),
+      ...typeof data === "object" && data !== null ? data : { value: data }
+    };
+    appendFileSync(file, JSON.stringify(entry, null, 2) + ",\n");
+  } catch {
+  }
+}
+var UNKNOWN_TOOL_NAME = "unknown-tool";
+function formatDataStream(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function isAbortError(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.name === "string" && e.name === "AbortError")
+      return true;
+    if (typeof e.code === "string" && e.code.toUpperCase() === "ABORT_ERR")
+      return true;
+  }
+  return false;
+}
+function convertUsageToAISDK(usage) {
+  const inputTokens = usage.input_tokens ?? 0;
+  const outputTokens = usage.output_tokens ?? 0;
+  const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? 0;
+  const usageAny = usage;
+  const textTokens = typeof usageAny.text_tokens === "number" ? usageAny.text_tokens : void 0;
+  const reasoningTokens = typeof usageAny.reasoning_tokens === "number" ? usageAny.reasoning_tokens : void 0;
+  return {
+    inputTokens: {
+      total: inputTokens + cacheWrite + cacheRead,
+      noCache: inputTokens,
+      cacheRead,
+      cacheWrite
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: textTokens,
+      reasoning: reasoningTokens
+    },
+    raw: usage
+  };
+}
+function mapFinishReason(subtype, isError) {
+  if (isError)
+    return "error";
+  switch (subtype) {
+    case "success":
+      return "stop";
+    case "error_max_turns":
+      return "length";
+    case "error_during_execution":
+    case "error_max_structured_output_retries":
+      return "error";
+    case void 0:
+      return "stop";
+    default:
+      return "other";
+  }
+}
+function extractToolUses(content) {
+  if (!Array.isArray(content))
+    return [];
+  return content.filter((item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_use").map((item) => ({
+    id: item.id || generateId(),
+    name: item.name || UNKNOWN_TOOL_NAME,
+    input: item.input
+  }));
+}
+var AISDKStreamConverter = class {
+  systemMessage;
+  hasEmittedStart = false;
+  sessionId;
+  /** True after we emitted an error from a result message (e.g. API 400). Avoids emitting a second generic "exited with code 1" that would hide the real error. */
+  errorEmitted = false;
+  partIdMap = /* @__PURE__ */ new Map();
+  /**
+   * Get the current session ID from the stream
+   */
+  get currentSessionId() {
+    if (!this.sessionId) {
+      throw new Error("Session ID is not set");
+    }
+    return this.sessionId;
+  }
+  /**
+   * Helper to emit SSE data
+   */
+  emit(data) {
+    return formatDataStream(data);
+  }
+  setPartId(index, partId) {
+    const partIdKey = `${this.currentSessionId}-${index}`;
+    this.partIdMap.set(partIdKey, partId);
+  }
+  getPartId(index) {
+    const partIdKey = `${this.currentSessionId}-${index}`;
+    if (this.partIdMap.has(partIdKey)) {
+      return this.partIdMap.get(partIdKey) ?? "";
+    }
+    throw new Error("Part ID not found");
+  }
+  /** Returns part ID for index or undefined if not tracked (e.g. content_block_stop without a prior start). */
+  tryGetPartId(index) {
+    if (!this.sessionId)
+      return void 0;
+    const partIdKey = `${this.sessionId}-${index}`;
+    return this.partIdMap.get(partIdKey);
+  }
+  /**
+   * Helper to emit tool call
+   */
+  *emitToolCall(message) {
+    const event = message.event;
+    if (event.type === "content_block_start" && event.content_block.type === "tool_use") {
+      const toolCallId = event.content_block.id;
+      this.setPartId(event.index, toolCallId);
+      yield this.emit({
+        type: "tool-input-start",
+        toolCallId,
+        toolName: event.content_block.name,
+        dynamic: true,
+        providerExecuted: true
+      });
+    }
+    if (event.type === "content_block_delta" && event.delta?.type === "input_json_delta") {
+      yield this.emit({
+        type: "tool-input-delta",
+        toolCallId: this.getPartId(event.index),
+        inputTextDelta: event.delta.partial_json
+      });
+    }
+  }
+  *emitTextBlockEvent(event) {
+    if (event.type === "content_block_start" && event.content_block.type === "text") {
+      const partId = `text_${generateId()}`;
+      this.setPartId(event.index, partId);
+      yield this.emit({
+        type: "text-start",
+        id: partId
+      });
+    }
+    if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+      yield this.emit({
+        type: "text-delta",
+        id: this.getPartId(event.index),
+        delta: event.delta.text
+      });
+    }
+    if (event.type === "content_block_start" && event.content_block.type === "thinking") {
+      const partId = `reasoning_${generateId()}`;
+      this.setPartId(event.index, partId);
+    }
+    if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+      if (event.delta.thinking) {
+        yield this.emit({ type: "reasoning", text: event.delta.thinking });
+      }
+    }
+    if (event.type === "content_block_stop") {
+      const partId = this.tryGetPartId(event.index);
+      if (partId?.startsWith("text_")) {
+        yield this.emit({ type: "text-end", id: partId });
+      }
+    }
+  }
+  /**
+   * Stream SDK messages and convert to AI SDK UI Data Stream format
+   */
+  async *stream(messageIterator) {
+    try {
+      for await (const message of messageIterator) {
+        if (message.type === "system" && message.subtype === "init") {
+          trace(null, true);
+          this.systemMessage = message;
+          this.sessionId = this.systemMessage.session_id;
+        }
+        trace(message);
+        if (message.type === "stream_event") {
+          const streamEvent = message;
+          const event = streamEvent.event;
+          if (event.type === "message_start" && !this.hasEmittedStart) {
+            this.hasEmittedStart = true;
+            yield this.emit({ type: "start", messageId: event.message.id });
+            yield this.emit({
+              type: "message-metadata",
+              messageMetadata: {
+                tools: this.systemMessage?.tools,
+                model: this.systemMessage?.model,
+                sessionId: this.systemMessage?.session_id,
+                agents: this.systemMessage?.agents,
+                skills: this.systemMessage?.skills
+              }
+            });
+          }
+          yield* this.emitTextBlockEvent(event);
+          yield* this.emitToolCall(streamEvent);
+        }
+        if (message.type === "assistant") {
+          const assistantMsg = message;
+          const content = assistantMsg.message?.content;
+          if (!content)
+            continue;
+          const tools = extractToolUses(content);
+          for (const tool of tools) {
+            yield this.emit({
+              type: "tool-input-available",
+              toolCallId: tool.id,
+              toolName: tool.name,
+              input: tool.input,
+              dynamic: true,
+              providerExecuted: true
+            });
+          }
+        }
+        if (message.type === "user") {
+          const userMsg = message;
+          const content = userMsg.message?.content;
+          for (const part of content) {
+            if (typeof part !== "string" && part.type === "tool_result") {
+              yield this.emit({
+                type: "tool-output-available",
+                toolCallId: part.tool_use_id,
+                output: message.tool_use_result || part.content,
+                dynamic: true,
+                providerExecuted: true
+              });
+            }
+          }
+        }
+        if (message.type === "result") {
+          const resultMsg = message;
+          if (resultMsg.is_error) {
+            this.errorEmitted = true;
+            const errorText = resultMsg.result || "Unknown error";
+            yield this.emit({
+              type: "error",
+              errorText
+            });
+          }
+          yield this.emit({
+            type: "finish",
+            finishReason: mapFinishReason(resultMsg.subtype, resultMsg.is_error),
+            messageMetadata: {
+              usage: convertUsageToAISDK(resultMsg.usage ?? {}),
+              sessionId: this.sessionId
+            }
+          });
+        }
+      }
+    } catch (error) {
+      if (process.env.DEBUG === "true") {
+        const errPayload = {
+          error: error instanceof Error ? error.message : String(error)
+        };
+        if (error instanceof Error) {
+          if (error.stack)
+            errPayload.stack = error.stack;
+          if (error.cause !== void 0) {
+            errPayload.cause = error.cause instanceof Error ? {
+              message: error.cause.message,
+              stack: error.cause.stack
+            } : String(error.cause);
+          }
+        }
+        trace(errPayload);
+      } else {
+        trace({ error: String(error) });
+      }
+      if (isAbortError(error)) {
+        console.error("[AISDKStream] Operation aborted");
+      } else {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error("[AISDKStream] Error:", errorMessage);
+        if (process.env.DEBUG === "true") {
+          if (error instanceof Error && error.stack) {
+            console.error("[AISDKStream] Stack:", error.stack);
+          }
+          if (error instanceof Error && error.cause) {
+            console.error("[AISDKStream] Cause:", error.cause);
+          }
+        }
+        if ((errorMessage.includes("exited with code") || errorMessage.includes("process exited")) && this.errorEmitted) {
+          console.error("[AISDKStream] (Skipping duplicate error \u2014 already sent API/result error above. Check the first error in the stream.)");
+        } else if (errorMessage.includes("exited with code") || errorMessage.includes("process exited")) {
+          console.error("[AISDKStream] Hint: Verify ANTHROPIC_API_KEY, --model (proxy must support it), and network.");
+        }
+        if (!this.errorEmitted) {
+          yield this.emit({ type: "error", errorText: errorMessage });
+          yield this.emit({
+            type: "finish",
+            finishReason: mapFinishReason("error_during_execution", true),
+            messageMetadata: {
+              usage: convertUsageToAISDK({}),
+              sessionId: this.sessionId
+            }
+          });
+        }
+      }
+    } finally {
+      yield `data: [DONE]
+
+`;
+    }
+  }
+};
+function streamSDKMessagesToAISDKUI(messageIterator) {
+  return new AISDKStreamConverter().stream(messageIterator);
+}
+
+// ../../packages/runner-claude/dist/claude-runner.js
+function createCanUseToolCallback(claudeOptions) {
+  return async (toolName, input, options) => {
+    const { toolUseID } = options;
+    if (claudeOptions.yolo && toolName !== "AskUserQuestion") {
+      return {
+        behavior: "allow",
+        updatedInput: input
+      };
+    }
+    const cwd = claudeOptions.cwd || process.cwd();
+    try {
+      const fs2 = await import("node:fs");
+      const path2 = await import("node:path");
+      const approvalDir = path2.join(cwd, ".bunny-agent", "approvals");
+      const approvalFile = path2.join(approvalDir, `${toolUseID}.json`);
+      fs2.mkdirSync(approvalDir, { recursive: true });
+      if (!fs2.existsSync(approvalFile)) {
+        fs2.writeFileSync(approvalFile, JSON.stringify({
+          status: "pending",
+          toolName,
+          input,
+          questions: toolName === "AskUserQuestion" ? input?.questions : void 0,
+          answers: {}
+        }));
+      }
+      const timeout = Date.now() + 6e4;
+      let lastApproval = null;
+      while (Date.now() < timeout) {
+        try {
+          const data = fs2.readFileSync(approvalFile, "utf-8");
+          const approval = JSON.parse(data);
+          lastApproval = approval;
+          if (approval.status === "completed") {
+            try {
+              fs2.unlinkSync(approvalFile);
+            } catch {
+            }
+            return {
+              behavior: "allow",
+              updatedInput: {
+                questions: approval.questions,
+                answers: approval.answers
+              }
+            };
+          }
+        } catch {
+        }
+        await new Promise((resolve4) => setTimeout(resolve4, 500));
+      }
+      try {
+        fs2.unlinkSync(approvalFile);
+      } catch {
+      }
+      if (lastApproval && Object.keys(lastApproval.answers).length > 0) {
+        return {
+          behavior: "allow",
+          updatedInput: {
+            questions: lastApproval.questions,
+            answers: lastApproval.answers
+          }
+        };
+      }
+      return {
+        behavior: "deny",
+        message: "Timeout waiting for user input"
+      };
+    } catch (error) {
+      console.error("Failed to handle approval flow:", error);
+      return {
+        behavior: "deny",
+        message: "Failed to handle approval flow"
+      };
+    }
+  };
+}
+var OPTIONAL_MODULES = {
+  "claude-agent-sdk": "@anthropic-ai/claude-agent-sdk"
+};
+function hasClaudeAuth() {
+  if (process.env.ANTHROPIC_API_KEY)
+    return true;
+  if (process.env.AWS_BEARER_TOKEN_BEDROCK)
+    return true;
+  if (process.env.ANTHROPIC_AUTH_TOKEN)
+    return true;
+  if (process.env.LITELLM_MASTER_KEY)
+    return true;
+  if (process.env.CLAUDE_CODE_USE_BEDROCK === "1" && process.env.ANTHROPIC_BEDROCK_BASE_URL) {
+    return true;
+  }
+  return false;
+}
+function createClaudeRunner(options) {
+  return {
+    async *run(userInput) {
+      if (!hasClaudeAuth()) {
+        console.error("[BunnyAgent] Warning: No Claude auth configured. Using mock response.\nTo use the real Claude Agent SDK, set one of:\n  ANTHROPIC_API_KEY, AWS_BEARER_TOKEN_BEDROCK, ANTHROPIC_AUTH_TOKEN, or LITELLM_MASTER_KEY\n  Or for Bedrock proxy: CLAUDE_CODE_USE_BEDROCK=1 and ANTHROPIC_BEDROCK_BASE_URL (and ANTHROPIC_AUTH_TOKEN or LITELLM_MASTER_KEY)\nThen install the SDK: npm install @anthropic-ai/claude-agent-sdk");
+        yield* runMockAgent(options, userInput, options.abortController?.signal);
+        return;
+      }
+      const sdk = await loadClaudeAgentSDK();
+      if (sdk) {
+        yield* runWithClaudeAgentSDK(sdk, options, userInput);
+      } else {
+        console.error("[BunnyAgent] Warning: @anthropic-ai/claude-agent-sdk not installed. Using mock response.\nInstall the SDK: npm install @anthropic-ai/claude-agent-sdk");
+        yield* runMockAgent(options, userInput, options.abortController?.signal);
+      }
+    }
+  };
+}
+async function loadClaudeAgentSDK() {
+  try {
+    const modulePath = OPTIONAL_MODULES["claude-agent-sdk"];
+    const module = await import(
+      /* webpackIgnore: true */
+      modulePath
+    );
+    return module;
+  } catch {
+    return null;
+  }
+}
+async function* runWithClaudeAgentSDK(sdk, options, userInput) {
+  yield* runWithAISDKUIOutput(sdk, options, userInput);
+}
+function createSDKOptions(options) {
+  const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+  return {
+    model: options.model,
+    systemPrompt: options.systemPrompt,
+    maxTurns: options.maxTurns,
+    allowedTools: [
+      ...options.allowedTools ?? [],
+      "Skill",
+      "WebSearch",
+      "WebFetch"
+    ],
+    cwd: options.cwd,
+    env: options.env,
+    resume: options.resume,
+    settingSources: ["project", "user"],
+    canUseTool: createCanUseToolCallback(options),
+    permissionMode: isRoot || options.yolo ? "bypassPermissions" : "default",
+    allowDangerouslySkipPermissions: !isRoot && !!options.yolo,
+    includePartialMessages: options.includePartialMessages
+  };
+}
+function setupAbortHandler(queryIterator, signal) {
+  const abortHandler = async () => {
+    console.error("[ClaudeRunner] Abort signal received, will call query.interrupt()...");
+    await queryIterator.interrupt();
+    console.error("[ClaudeRunner] query.interrupt() completed");
+  };
+  if (signal) {
+    console.error("[ClaudeRunner] Signal provided, adding abort listener");
+    signal.addEventListener("abort", abortHandler);
+    if (signal.aborted) {
+      console.error("[ClaudeRunner] Signal already aborted!");
+    }
+  } else {
+    console.error("[ClaudeRunner] No signal provided");
+  }
+  return () => {
+    if (signal) {
+      signal.removeEventListener("abort", abortHandler);
+      console.error("[ClaudeRunner] Abort listener removed");
+    }
+  };
+}
+async function* runWithAISDKUIOutput(sdk, options, userInput) {
+  const sdkOptions = createSDKOptions({
+    ...options,
+    includePartialMessages: true
+  });
+  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
+  const cleanup = setupAbortHandler(queryIterator, options.abortController?.signal);
+  try {
+    yield* streamSDKMessagesToAISDKUI(queryIterator);
+  } finally {
+    cleanup();
+  }
+}
+async function* runMockAgent(options, userInput, signal) {
+  if (signal?.aborted) {
+    console.log("[ClaudeRunner] Mock agent: Operation already aborted");
+    return;
+  }
+  try {
+    const messageId = generateId();
+    yield formatDataStream({
+      type: "start",
+      messageId
+    });
+    const response = `I received your request: "${userInput}"
+
+Model: ${options.model}
+
+This is a mock response because:
+- No Claude auth (ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, AWS_BEARER_TOKEN_BEDROCK, or Bedrock proxy env) is set, OR
+- @anthropic-ai/claude-agent-sdk is not installed
+
+To use the real Claude Agent SDK:
+1. Set ANTHROPIC_API_KEY, or for Bedrock proxy: ANTHROPIC_AUTH_TOKEN/LITELLM_MASTER_KEY and ANTHROPIC_BEDROCK_BASE_URL, CLAUDE_CODE_USE_BEDROCK=1
+2. Install the SDK: npm install @anthropic-ai/claude-agent-sdk
+
+Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-preview`;
+    const textId = generateId();
+    yield formatDataStream({ type: "text-start", id: textId });
+    const words = response.split(" ");
+    for (const word of words) {
+      yield formatDataStream({
+        type: "text-delta",
+        id: textId,
+        delta: word + " "
+      });
+      await new Promise((resolve4) => setTimeout(resolve4, 20));
+    }
+    yield formatDataStream({ type: "text-end", id: textId });
+    yield formatDataStream({
+      type: "finish",
+      finishReason: mapFinishReason("success"),
+      usage: convertUsageToAISDK({
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      })
+    });
+    yield `data: [DONE]
+
+`;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    console.error("[ClaudeRunner] Mock agent error:", errorMessage);
+    yield formatDataStream({ type: "error", errorText: errorMessage });
+    yield formatDataStream({
+      type: "finish",
+      finishReason: mapFinishReason("error_during_execution", true),
+      usage: convertUsageToAISDK({
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      })
+    });
+    yield `data: [DONE]
+
+`;
+  }
+}
+
+// ../../packages/runner-codex/dist/codex-runner.js
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Codex } from "@openai/codex-sdk";
+function normalizeCodexModel(model) {
+  const trimmed = model.trim();
+  const withoutProvider = trimmed.startsWith("openai:") ? trimmed.slice("openai:".length) : trimmed;
+  if (/^\d+(\.\d+)?$/.test(withoutProvider)) {
+    return `gpt-${withoutProvider}`;
+  }
+  return withoutProvider;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function toToolStartPayload(event) {
+  if (event.type !== "item.started") {
+    return null;
+  }
+  const item = event.item;
+  if (item.type === "command_execution") {
+    return {
+      toolCallId: item.id,
+      toolName: "shell",
+      args: { command: item.command }
+    };
+  }
+  if (item.type === "mcp_tool_call") {
+    return {
+      toolCallId: item.id,
+      toolName: `${item.server}:${item.tool}`,
+      args: item.arguments
+    };
+  }
+  if (item.type === "web_search") {
+    return {
+      toolCallId: item.id,
+      toolName: "web_search",
+      args: { query: item.query }
+    };
+  }
+  return null;
+}
+function toToolEndPayload(event) {
+  if (event.type !== "item.completed") {
+    return null;
+  }
+  const item = event.item;
+  if (item.type === "command_execution") {
+    return {
+      toolCallId: item.id,
+      result: {
+        status: item.status,
+        exitCode: item.exit_code,
+        output: item.aggregated_output
+      },
+      isError: item.exit_code !== 0
+    };
+  }
+  if (item.type === "mcp_tool_call") {
+    return {
+      toolCallId: item.id,
+      result: item.result ?? item.error ?? { status: item.status },
+      isError: item.error != null || item.status === "failed"
+    };
+  }
+  if (item.type === "web_search") {
+    return {
+      toolCallId: item.id,
+      result: { query: item.query }
+    };
+  }
+  return null;
+}
+function toAssistantText(event) {
+  if (event.type === "item.completed" && event.item.type === "agent_message") {
+    return event.item.text;
+  }
+  if (event.type === "item.completed" && event.item.type === "reasoning") {
+    return `[Reasoning] ${event.item.text}`;
+  }
+  if (event.type === "item.completed" && event.item.type === "error") {
+    return `[Error] ${event.item.message}`;
+  }
+  return null;
+}
+function createCodexRunner(options) {
+  const codex = new Codex({
+    apiKey: process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY,
+    baseUrl: process.env.OPENAI_BASE_URL,
+    env: options.env
+  });
+  return {
+    async *run(userInput) {
+      const threadOptions = {
+        model: normalizeCodexModel(options.model),
+        sandboxMode: options.sandboxMode,
+        workingDirectory: options.cwd || process.cwd(),
+        skipGitRepoCheck: options.skipGitRepoCheck ?? true,
+        modelReasoningEffort: options.modelReasoningEffort,
+        networkAccessEnabled: options.networkAccessEnabled,
+        webSearchMode: options.webSearchMode,
+        approvalPolicy: options.approvalPolicy
+      };
+      const thread = options.resume ? codex.resumeThread(options.resume, threadOptions) : codex.startThread(threadOptions);
+      let inputToCodex = userInput;
+      const tempFiles = [];
+      try {
+        if (userInput.startsWith("[") && userInput.endsWith("]")) {
+          const parsed = JSON.parse(userInput);
+          if (Array.isArray(parsed)) {
+            const parts = [];
+            for (const p of parsed) {
+              if (p.type === "image" && typeof p.data === "string") {
+                const match = /^data:([^;]+);base64,(.+)$/.exec(p.data);
+                if (match) {
+                  const ext = match[1].split("/")[1] ?? "png";
+                  const tmpPath = path.join(os.tmpdir(), `bunny-agent-img-${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`);
+                  fs.writeFileSync(tmpPath, Buffer.from(match[2], "base64"));
+                  tempFiles.push(tmpPath);
+                  parts.push({ type: "local_image", path: tmpPath });
+                }
+              } else {
+                const text = typeof p.text === "string" ? p.text : JSON.stringify(p);
+                parts.push({ type: "text", text });
+              }
+            }
+            if (parts.length > 0) {
+              inputToCodex = parts;
+            }
+          }
+        }
+      } catch (_e) {
+      }
+      const streamedTurn = await thread.runStreamed(inputToCodex, {
+        signal: options.abortController?.signal
+      });
+      for await (const event of streamedTurn.events) {
+        const assistantText = toAssistantText(event);
+        if (assistantText) {
+          yield `data: ${JSON.stringify({ type: "text-delta", delta: assistantText })}
+
+`;
+        }
+        const toolStart = toToolStartPayload(event);
+        if (toolStart) {
+          yield `data: ${JSON.stringify({ type: "tool-input-start", toolCallId: toolStart.toolCallId, toolName: toolStart.toolName })}
+
+`;
+          yield `data: ${JSON.stringify({ type: "tool-input-available", toolCallId: toolStart.toolCallId, toolName: toolStart.toolName, input: toolStart.args })}
+
+`;
+        }
+        const toolEnd = toToolEndPayload(event);
+        if (toolEnd) {
+          yield `data: ${JSON.stringify({ type: "tool-output-available", toolCallId: toolEnd.toolCallId, output: toolEnd.result, isError: toolEnd.isError })}
+
+`;
+        }
+        if (event.type === "turn.completed") {
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "stop", usage: event.usage })}
+
+`;
+          yield `data: [DONE]
+
+`;
+        }
+        if (event.type === "turn.failed") {
+          yield `data: ${JSON.stringify({ type: "error", errorText: event.error.message })}
+
+`;
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+          yield `data: [DONE]
+
+`;
+        }
+        if (event.type === "error") {
+          yield `data: ${JSON.stringify({ type: "error", errorText: stringifyUnknown(event.message) })}
+
+`;
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+          yield `data: [DONE]
+
+`;
+        }
+      }
+      for (const tmpFile of tempFiles) {
+        try {
+          fs.unlinkSync(tmpFile);
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// ../../packages/runner-gemini/dist/gemini-runner.js
+import { spawn } from "node:child_process";
+function createGeminiRunner(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  let currentProcess = null;
+  return {
+    async *run(userInput) {
+      if (options.abortController?.signal.aborted) {
+        yield `data: ${JSON.stringify({ type: "error", errorText: "Run aborted before start." })}
+
+`;
+        yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+        yield "data: [DONE]\n\n";
+        return;
+      }
+      const args = ["--experimental-acp"];
+      if (options.model)
+        args.push("--model", options.model);
+      let aborted = false;
+      let completed = false;
+      currentProcess = spawn("gemini", args, {
+        cwd,
+        env: { ...process.env, ...options.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (!currentProcess.stdin || !currentProcess.stdout)
+        throw new Error("Failed to spawn gemini");
+      const abortSignal = options.abortController?.signal;
+      const abortHandler = () => {
+        aborted = true;
+        currentProcess?.kill();
+      };
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      let msgId = 1;
+      const send = (method, params, id) => {
+        const msg = JSON.stringify({
+          jsonrpc: "2.0",
+          method,
+          params,
+          ...id ? { id } : {}
+        });
+        currentProcess.stdin.write(msg + "\n");
+      };
+      send("initialize", { protocolVersion: 1, clientCapabilities: {} }, msgId++);
+      let sessionId = null;
+      const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const textId = `text_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      let hasStarted = false;
+      let hasTextStarted = false;
+      try {
+        let buffer = "";
+        for await (const chunk of currentProcess.stdout) {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim())
+              continue;
+            let msg;
+            try {
+              msg = JSON.parse(line);
+            } catch {
+              continue;
+            }
+            if (msg.id === 1 && msg.result) {
+              send("session/new", { cwd, mcpServers: [] }, msgId++);
+            }
+            if (msg.id === 2 && msg.result) {
+              const result = msg.result;
+              sessionId = result.sessionId;
+              send("session/prompt", {
+                sessionId,
+                prompt: [{ type: "text", text: userInput }]
+              }, msgId++);
+            }
+            if (msg.id === 3 && "result" in msg) {
+              if (hasTextStarted)
+                yield `data: ${JSON.stringify({ type: "text-end", id: textId })}
+
+`;
+              yield `data: ${JSON.stringify({ type: "finish", finishReason: "stop" })}
+
+`;
+              yield `data: [DONE]
+
+`;
+              completed = true;
+              currentProcess.kill();
+              return;
+            }
+            if (msg.method === "session/update" && msg.params?.update) {
+              const update = msg.params.update;
+              if (!hasStarted) {
+                yield `data: ${JSON.stringify({ type: "start", messageId })}
+
+`;
+                hasStarted = true;
+              }
+              if (update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && update.content.text) {
+                if (!hasTextStarted) {
+                  yield `data: ${JSON.stringify({ type: "text-start", id: textId })}
+
+`;
+                  hasTextStarted = true;
+                }
+                yield `data: ${JSON.stringify({ type: "text-delta", id: textId, delta: update.content.text })}
+
+`;
+              }
+            }
+          }
+        }
+        if (!completed) {
+          const errorText = aborted ? "Gemini run aborted by signal." : "Gemini ACP process exited before completion.";
+          yield `data: ${JSON.stringify({ type: "error", errorText })}
+
+`;
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+          yield "data: [DONE]\n\n";
+        }
+      } finally {
+        if (abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        currentProcess = null;
+      }
+    },
+    abort() {
+      currentProcess?.kill();
+      currentProcess = null;
+    }
+  };
+}
+
+// ../../packages/runner-opencode/dist/opencode-runner.js
+import { spawn as spawn2 } from "node:child_process";
+function createOpenCodeRunner(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  let currentProcess = null;
+  return {
+    async *run(userInput) {
+      if (options.abortController?.signal.aborted) {
+        yield `data: ${JSON.stringify({ type: "error", errorText: "Run aborted before start." })}
+
+`;
+        yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+        yield "data: [DONE]\n\n";
+        return;
+      }
+      const args = ["acp"];
+      if (options.model)
+        args.push("--model", options.model);
+      let aborted = false;
+      let completed = false;
+      currentProcess = spawn2("opencode", args, {
+        cwd,
+        env: { ...process.env, ...options.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (!currentProcess.stdin || !currentProcess.stdout)
+        throw new Error("Failed to spawn opencode");
+      const abortSignal = options.abortController?.signal;
+      const abortHandler = () => {
+        aborted = true;
+        currentProcess?.kill();
+      };
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      let msgId = 1;
+      const send = (method, params, id) => {
+        const msg = JSON.stringify({
+          jsonrpc: "2.0",
+          method,
+          params,
+          ...id ? { id } : {}
+        });
+        currentProcess.stdin.write(msg + "\n");
+      };
+      send("initialize", { protocolVersion: 1, clientCapabilities: {} }, msgId++);
+      let sessionId = null;
+      const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const textId = `text_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      let hasStarted = false;
+      let hasTextStarted = false;
+      try {
+        let buffer = "";
+        for await (const chunk of currentProcess.stdout) {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim())
+              continue;
+            let msg;
+            try {
+              msg = JSON.parse(line);
+            } catch {
+              continue;
+            }
+            if (msg.id === 1 && msg.result) {
+              send("session/new", { cwd, mcpServers: [] }, msgId++);
+            }
+            if (msg.id === 2 && msg.result) {
+              const result = msg.result;
+              sessionId = result.sessionId;
+              send("session/prompt", {
+                sessionId,
+                prompt: [{ type: "text", text: userInput }]
+              }, msgId++);
+            }
+            if (msg.id === 3 && "result" in msg) {
+              if (hasTextStarted)
+                yield `data: ${JSON.stringify({ type: "text-end", id: textId })}
+
+`;
+              yield `data: ${JSON.stringify({ type: "finish", finishReason: "stop" })}
+
+`;
+              yield `data: [DONE]
+
+`;
+              completed = true;
+              currentProcess.kill();
+              return;
+            }
+            if (msg.method === "session/update" && msg.params?.update) {
+              const update = msg.params.update;
+              if (!hasStarted) {
+                yield `data: ${JSON.stringify({ type: "start", messageId })}
+
+`;
+                hasStarted = true;
+              }
+              if (update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && update.content.text) {
+                if (!hasTextStarted) {
+                  yield `data: ${JSON.stringify({ type: "text-start", id: textId })}
+
+`;
+                  hasTextStarted = true;
+                }
+                yield `data: ${JSON.stringify({ type: "text-delta", id: textId, delta: update.content.text })}
+
+`;
+              }
+            }
+          }
+        }
+        if (!completed) {
+          const errorText = aborted ? "OpenCode run aborted by signal." : "OpenCode ACP process exited before completion.";
+          yield `data: ${JSON.stringify({ type: "error", errorText })}
+
+`;
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`;
+          yield "data: [DONE]\n\n";
+        }
+      } finally {
+        if (abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        currentProcess = null;
+      }
+    },
+    abort() {
+      currentProcess?.kill();
+      currentProcess = null;
+    }
+  };
+}
+
+// ../../packages/runner-pi/dist/pi-runner.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+import { getModel } from "@mariozechner/pi-ai";
+import { AuthStorage, createAgentSession, ModelRegistry, SessionManager } from "@mariozechner/pi-coding-agent";
+
+// ../../packages/runner-pi/dist/bunny-agent-resource-loader.js
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join as join5, resolve as resolve2 } from "node:path";
+import { DefaultResourceLoader, loadSkills } from "@mariozechner/pi-coding-agent";
+var LOG_PREFIX = "[bunny-agent:pi]";
+function logSkillLoad(cwd, agentDir, skillPaths, result) {
+  const lines = [
+    `${LOG_PREFIX} loadSkills`,
+    `  cwd: ${cwd}`,
+    `  agentDir: ${agentDir}`,
+    `  extra skillPaths (${skillPaths.length}):`
+  ];
+  for (const raw of skillPaths) {
+    const abs = isAbsolute(raw) ? raw : resolve2(cwd, raw);
+    lines.push(`    ${raw} -> ${abs} (exists: ${existsSync4(abs) ? "yes" : "no"})`);
+  }
+  lines.push(`  loaded skills: ${result.skills.length}`);
+  if (result.skills.length > 0) {
+    lines.push(`  skill names: ${result.skills.map((s) => s.name).join(", ")}`);
+  }
+  if (result.diagnostics.length > 0) {
+    lines.push(`  diagnostics (${result.diagnostics.length}):`);
+    for (const d of result.diagnostics) {
+      const pathPart = d.path !== void 0 ? ` path=${d.path}` : "";
+      lines.push(`    [${d.type}] ${d.message}${pathPart}`);
+    }
+  }
+  console.error(lines.join("\n"));
+}
+var BunnyAgentResourceLoader = class {
+  constructor(options = {}) {
+    this.cwd = options.cwd ?? process.cwd();
+    this.agentDir = options.agentDir ?? join5(homedir(), ".pi", "agent");
+    this.skillPaths = options.skillPaths ?? [];
+    this.extraAppendPrompt = options.appendSystemPrompt;
+    this.delegate = new DefaultResourceLoader({
+      cwd: this.cwd,
+      agentDir: this.agentDir,
+      settingsManager: options.settingsManager
+    });
+  }
+  async reload() {
+    await this.delegate.reload();
+    this.cachedSkills = void 0;
+  }
+  getSkills() {
+    if (!this.cachedSkills) {
+      this.cachedSkills = loadSkills({
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+        skillPaths: this.skillPaths
+      });
+      if (this.skillPaths.length > 0) {
+        logSkillLoad(this.cwd, this.agentDir, this.skillPaths, this.cachedSkills);
+      }
+    }
+    return this.cachedSkills;
+  }
+  // Delegate all other methods
+  getExtensions() {
+    return this.delegate.getExtensions();
+  }
+  getPrompts() {
+    return this.delegate.getPrompts();
+  }
+  getThemes() {
+    return this.delegate.getThemes();
+  }
+  getAgentsFiles() {
+    return this.delegate.getAgentsFiles();
+  }
+  getSystemPrompt() {
+    return this.delegate.getSystemPrompt();
+  }
+  getAppendSystemPrompt() {
+    const base = this.delegate.getAppendSystemPrompt();
+    if (this.extraAppendPrompt) {
+      console.error(`${LOG_PREFIX} getAppendSystemPrompt: appending extra prompt (${this.extraAppendPrompt.length} chars)`);
+      return [...base, this.extraAppendPrompt];
+    }
+    return base;
+  }
+  extendResources(paths) {
+    this.delegate.extendResources(paths);
+  }
+};
+
+// ../../packages/runner-pi/dist/image-tools.js
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, extname, join as join6 } from "node:path";
+var generateImageSchema = {
+  type: "object",
+  properties: {
+    prompt: {
+      type: "string",
+      description: "Text description of the image to generate."
+    },
+    filename: {
+      type: "string",
+      description: "Output filename with extension, e.g. 'cat.png'. Defaults to a timestamp-based name."
+    },
+    size: {
+      type: "string",
+      enum: [
+        "256x256",
+        "512x512",
+        "1024x1024",
+        "1792x1024",
+        "1024x1792",
+        "1280x1280",
+        "1568x1056",
+        "1056x1568",
+        "1472x1088",
+        "1088x1472",
+        "1728x960",
+        "960x1728"
+      ],
+      description: "Image dimensions. Common: 1024x1024 (square), 1280x1280, 1568x1056 (landscape), 1056x1568 (portrait), 1728x960 (wide), 960x1728 (tall)."
+    },
+    quality: {
+      type: "string",
+      enum: ["standard", "hd"],
+      description: "Image quality (OpenAI only). Defaults to standard."
+    }
+  },
+  required: ["prompt"],
+  additionalProperties: false
+};
+async function resolveB64(item) {
+  if (item.b64_json)
+    return item.b64_json;
+  if (item.url) {
+    const res = await fetch(item.url);
+    if (res.ok)
+      return Buffer.from(await res.arrayBuffer()).toString("base64");
+  }
+  return void 0;
+}
+async function saveImageItem(item, filePath) {
+  const b64 = await resolveB64(item);
+  if (!b64)
+    return void 0;
+  mkdirSync2(dirname3(filePath), { recursive: true });
+  writeFileSync3(filePath, Buffer.from(b64, "base64"));
+  return filePath;
+}
+function buildImageGenerateTool(cwd, imageModelId, baseUrl, apiKey) {
+  return {
+    name: "generate_image",
+    label: "generate image",
+    description: "Generate an image from a text prompt. Saves the image to disk and returns the file path.",
+    promptSnippet: "generate_image(prompt, filename?, size?, quality?) - generate an image from text",
+    promptGuidelines: [
+      "Use generate_image when the user asks to create, draw, or visualize something.",
+      "Be descriptive in the prompt \u2014 more detail produces better results.",
+      "Provide a filename with extension, e.g. 'cat.png'."
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: plain JSON Schema compatible with TypeBox TSchema
+    parameters: generateImageSchema,
+    async execute(_toolCallId, params, _signal, _onUpdate) {
+      const p = params;
+      const prompt = p.prompt;
+      const size = p.size ?? "1024x1024";
+      const quality = p.quality ?? "standard";
+      const rawFilename = p.filename;
+      const filename = rawFilename ? extname(rawFilename) ? rawFilename : `${rawFilename}.png` : `image_${Date.now()}.png`;
+      const filePath = join6(cwd, filename.replace(/[^a-zA-Z0-9_\-./]/g, "_"));
+      try {
+        const url = `${baseUrl.replace(/\/$/, "")}/v1/images/generations`;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model: imageModelId,
+            prompt,
+            n: 1,
+            size,
+            quality
+          })
+        });
+        if (!res.ok) {
+          throw new Error(`Image generation failed (${res.status}): ${await res.text()}`);
+        }
+        const json = await res.json();
+        const item = json.data?.[0] ?? {};
+        const savedPath = await saveImageItem(item, filePath);
+        return {
+          content: [
+            {
+              type: "text",
+              text: savedPath ?? "Image generated but could not be saved."
+            }
+          ],
+          details: {
+            filePath: savedPath,
+            response: json
+          }
+        };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+          content: [
+            { type: "text", text: `Image generation error: ${msg}` }
+          ],
+          details: void 0
+        };
+      }
+    }
+  };
+}
+
+// ../../packages/runner-pi/dist/tool-overrides.js
+import { createBashTool, createReadTool } from "@mariozechner/pi-coding-agent";
+
+// ../../packages/runner-pi/dist/web-tools.js
+var braveProvider = {
+  id: "brave",
+  label: "Brave Search",
+  envKeys: ["BRAVE_API_KEY"],
+  async search({ apiKey, query, count, country, freshness }) {
+    const params = new URLSearchParams({
+      q: query,
+      count: String(Math.min(count, 20))
+    });
+    if (country)
+      params.set("country", country);
+    if (freshness)
+      params.set("freshness", freshness);
+    const res = await fetch(`https://api.search.brave.com/res/v1/web/search?${params}`, {
+      headers: {
+        Accept: "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": apiKey
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Brave API ${res.status}: ${res.statusText}
+${body}`);
+    }
+    const data = await res.json();
+    const results = [];
+    if (data.web?.results) {
+      for (const r of data.web.results) {
+        if (results.length >= count)
+          break;
+        results.push({
+          title: r.title ?? "",
+          link: r.url ?? "",
+          snippet: r.description ?? "",
+          age: r.age ?? r.page_age ?? ""
+        });
+      }
+    }
+    return results;
+  }
+};
+var tavilyProvider = {
+  id: "tavily",
+  label: "Tavily",
+  envKeys: ["TAVILY_API_KEY"],
+  async search({ apiKey, query, count }) {
+    const res = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        api_key: apiKey,
+        query,
+        max_results: Math.min(count, 10),
+        include_answer: false
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Tavily API ${res.status}: ${res.statusText}
+${body}`);
+    }
+    const data = await res.json();
+    const results = [];
+    if (Array.isArray(data.results)) {
+      for (const r of data.results) {
+        results.push({
+          title: r.title ?? "",
+          link: r.url ?? "",
+          snippet: r.content ?? ""
+        });
+      }
+    }
+    return results;
+  }
+};
+var AUTO_DETECT_ORDER = [braveProvider, tavilyProvider];
+function getEnv(env, key) {
+  const v = env[key] ?? process.env[key];
+  return v && v.length > 0 ? v : void 0;
+}
+function resolveSearchProviders(env) {
+  const available = [];
+  for (const p of AUTO_DETECT_ORDER) {
+    for (const key of p.envKeys) {
+      const val = getEnv(env, key);
+      if (val) {
+        available.push({ provider: p, apiKey: val });
+        break;
+      }
+    }
+  }
+  return available;
+}
+function resolveSearchProvider(env) {
+  const all = resolveSearchProviders(env);
+  return all.length > 0 ? all[0] : null;
+}
+function isRateLimitError(err) {
+  if (!(err instanceof Error))
+    return false;
+  const msg = err.message;
+  return msg.includes("429") || msg.includes("rate") || msg.includes("quota") || msg.includes("limit");
+}
+var BROWSER_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+function htmlToText(html) {
+  return html.replace(/<(script|style|noscript)[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|h[1-6]|li|tr)>/gi, "\n").replace(/<(p|div|h[1-6]|li|tr)[^>]*>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function fetchPageContent(url) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const res = await fetch(url, {
+      headers: {
+        "User-Agent": BROWSER_UA,
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9"
+      },
+      signal: controller.signal
+    });
+    if (!res.ok)
+      return `(HTTP ${res.status}: ${res.statusText})`;
+    const html = await res.text();
+    const text = htmlToText(html);
+    return text.length > 5e4 ? `${text.slice(0, 5e4)}
+
+[Truncated]` : text;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return `(Error fetching ${url}: ${msg})`;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function formatSearchResults(results, providerLabel) {
+  if (results.length === 0)
+    return "No results found.";
+  const header = `[${providerLabel}] ${results.length} result(s)
+`;
+  return header + results.map((r, i) => {
+    const lines = [
+      `--- Result ${i + 1} ---`,
+      `Title: ${r.title}`,
+      `Link: ${r.link}`
+    ];
+    if (r.age)
+      lines.push(`Age: ${r.age}`);
+    lines.push(`Snippet: ${r.snippet}`);
+    if (r.content)
+      lines.push(`Content:
+${r.content}`);
+    return lines.join("\n");
+  }).join("\n\n");
+}
+var webSearchSchema = {
+  type: "object",
+  required: ["query"],
+  properties: {
+    query: {
+      type: "string",
+      description: "Search query string"
+    },
+    count: {
+      type: "number",
+      description: "Number of results to return (default: 5, max: 20)"
+    },
+    freshness: {
+      type: "string",
+      description: 'Filter by time: "pd" (past day), "pw" (past week), "pm" (past month), "py" (past year), or "YYYY-MM-DDtoYYYY-MM-DD"'
+    },
+    country: {
+      type: "string",
+      description: "Two-letter country code for results (default: US)"
+    },
+    fetch_content: {
+      type: "boolean",
+      description: "If true, also fetch and include page content for each result (slower)"
+    }
+  }
+};
+var webFetchSchema = {
+  type: "object",
+  required: ["url"],
+  properties: {
+    url: {
+      type: "string",
+      description: "URL to fetch and extract readable content from"
+    }
+  }
+};
+function buildWebSearchTool(env) {
+  const providers = resolveSearchProviders(env);
+  if (providers.length === 0) {
+    throw new Error("web_search: no search provider available. Set BRAVE_API_KEY or TAVILY_API_KEY.");
+  }
+  return {
+    name: "web_search",
+    label: "web search",
+    description: "Search the web for information. Returns titles, URLs, and snippets. Use for documentation lookups, fact-checking, current events, or any query requiring web results.",
+    promptSnippet: "web_search(query, count?, freshness?, country?, fetch_content?) - search the web",
+    promptGuidelines: [
+      "Use web_search when you need current information, documentation, or facts not available locally.",
+      "Set fetch_content=true only when you need the actual page text, not just snippets \u2014 it is slower.",
+      "Prefer specific, focused queries over broad ones for better results."
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: plain JSON Schema compatible with TypeBox TSchema
+    parameters: webSearchSchema,
+    async execute(_toolCallId, params, _signal, _onUpdate) {
+      const p = params;
+      const query = p.query;
+      const count = p.count ?? 5;
+      const country = p.country ?? "US";
+      const freshness = p.freshness;
+      const shouldFetchContent = p.fetch_content ?? false;
+      let lastError;
+      for (const { provider, apiKey } of providers) {
+        try {
+          const results = await provider.search({
+            apiKey,
+            query,
+            count,
+            country,
+            freshness
+          });
+          if (shouldFetchContent) {
+            for (const r of results) {
+              r.content = await fetchPageContent(r.link);
+            }
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatSearchResults(results, provider.label)
+              }
+            ],
+            details: void 0
+          };
+        } catch (e) {
+          lastError = e;
+          if (isRateLimitError(e) && providers.length > 1) {
+            console.error(`[bunny-agent:pi] ${provider.label} rate-limited, trying next provider...`);
+            continue;
+          }
+          break;
+        }
+      }
+      const msg = lastError instanceof Error ? lastError.message : String(lastError);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Web search error: ${msg}`
+          }
+        ],
+        details: void 0
+      };
+    }
+  };
+}
+function buildWebFetchTool() {
+  return {
+    name: "web_fetch",
+    label: "web fetch",
+    description: "Fetch a web page and extract its readable text content. Use when you need the full content of a specific URL (article, docs page, etc.).",
+    promptSnippet: "web_fetch(url) - fetch and extract content from a URL",
+    promptGuidelines: [
+      "Use web_fetch when you already have a URL and need its content.",
+      "For finding URLs first, use web_search instead."
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: plain JSON Schema compatible with TypeBox TSchema
+    parameters: webFetchSchema,
+    async execute(_toolCallId, params, _signal, _onUpdate) {
+      const p = params;
+      const url = p.url;
+      try {
+        const content = await fetchPageContent(url);
+        return {
+          content: [{ type: "text", text: content }],
+          details: void 0
+        };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+          content: [
+            { type: "text", text: `Error fetching URL: ${msg}` }
+          ],
+          details: void 0
+        };
+      }
+    }
+  };
+}
+
+// ../../packages/runner-pi/dist/tool-overrides.js
+function redactSecrets(text, secrets) {
+  if (Object.keys(secrets).length === 0)
+    return text;
+  let result = text;
+  const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const values = Object.values(secrets).filter((v) => v.length >= 8).filter((v) => !/^\//.test(v) && !/^[A-Za-z]:[/\\]/.test(v)).sort((a, b) => b.length - a.length);
+  for (const v of values) {
+    const ev = escapeRegex(v);
+    result = result.replace(new RegExp(`^\\S+=.*${ev}.*$\\n?`, "gm"), "");
+    result = result.replace(new RegExp(`\\s*["']?\\w+["']?\\s*:\\s*['"][^'"]*${ev}[^'"]*['"],?`, "g"), "");
+    result = result.split(v).join("***");
+  }
+  result = result.replace(/\n{3,}/g, "\n\n");
+  return result.trim();
+}
+function redactResultContent(result, secrets) {
+  if (result?.content && Array.isArray(result.content)) {
+    result.content = result.content.map((c) => c.type === "text" && typeof c.text === "string" ? { ...c, text: redactSecrets(c.text, secrets) } : c);
+  }
+}
+function isEnvDumpCommand(command) {
+  const cmd = command.replace(/\s+/g, " ").trim();
+  return /(?:^|[|;&])\s*(?:env|printenv|export\s+-p|declare\s+-x)\b/.test(cmd);
+}
+function buildEnvInjectedBashTool(cwd, extraEnv) {
+  const bashAgentTool = createBashTool(cwd, {
+    spawnHook: (ctx) => ({
+      ...ctx,
+      env: { ...ctx.env, ...extraEnv }
+    })
+  });
+  return {
+    name: bashAgentTool.name,
+    label: bashAgentTool.label ?? "bash",
+    description: bashAgentTool.description,
+    // biome-ignore lint/suspicious/noExplicitAny: TypeBox schema from pi internals
+    parameters: bashAgentTool.parameters,
+    async execute(toolCallId, params, signal, onUpdate) {
+      const command = params.command ?? "";
+      if (isEnvDumpCommand(command)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Command blocked: printing or redirecting environment variables is not allowed."
+            }
+          ],
+          details: void 0
+        };
+      }
+      const result = await bashAgentTool.execute(toolCallId, params, signal, onUpdate);
+      redactResultContent(result, extraEnv);
+      return result;
+    }
+  };
+}
+function buildSecretRedactingReadTool(cwd, secrets) {
+  const readAgentTool = createReadTool(cwd);
+  return {
+    name: readAgentTool.name,
+    label: readAgentTool.label ?? "read",
+    description: readAgentTool.description,
+    // biome-ignore lint/suspicious/noExplicitAny: TypeBox schema from pi internals
+    parameters: readAgentTool.parameters,
+    async execute(toolCallId, params, signal, onUpdate) {
+      const result = await readAgentTool.execute(toolCallId, params, signal, onUpdate);
+      redactResultContent(result, secrets);
+      return result;
+    }
+  };
+}
+function buildSecretAwareTools(cwd, secrets) {
+  const tools = [
+    buildEnvInjectedBashTool(cwd, secrets),
+    buildSecretRedactingReadTool(cwd, secrets),
+    buildWebFetchTool()
+  ];
+  if (resolveSearchProvider(secrets)) {
+    tools.push(buildWebSearchTool(secrets));
+  }
+  return tools;
+}
+
+// ../../packages/runner-pi/dist/pi-runner.js
+var LOG_PREFIX2 = "[bunny-agent:pi]";
+function parseModelSpec(model) {
+  const trimmed = model.trim();
+  const separator = trimmed.indexOf(":");
+  if (separator <= 0 || separator === trimmed.length - 1) {
+    throw new Error(`Invalid pi model "${model}". Expected format "<provider>:<model>", for example "google:gemini-2.5-pro".`);
+  }
+  return {
+    provider: trimmed.slice(0, separator),
+    modelName: trimmed.slice(separator + 1)
+  };
+}
+function resolveImageModelName(chatProvider, env) {
+  const spec = env?.IMAGE_GENERATION_MODEL;
+  if (!spec)
+    return void 0;
+  try {
+    const { provider, modelName } = parseModelSpec(spec);
+    return provider === chatProvider ? modelName : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getEnvValue(optionsEnv, name) {
+  return optionsEnv?.[name] ?? process.env[name];
+}
+function applyModelOverrides(model, provider, optionsEnv) {
+  if (model == null)
+    return;
+  const openAiBaseUrl = getEnvValue(optionsEnv, "OPENAI_BASE_URL");
+  const geminiBaseUrl = getEnvValue(optionsEnv, "GEMINI_BASE_URL");
+  const anthropicBaseUrl = getEnvValue(optionsEnv, "ANTHROPIC_BASE_URL");
+  if (provider === "openai" && openAiBaseUrl) {
+    model.baseUrl = openAiBaseUrl;
+  } else if (provider === "google" && geminiBaseUrl) {
+    model.baseUrl = geminiBaseUrl;
+  } else if (provider === "anthropic" && anthropicBaseUrl) {
+    model.baseUrl = anthropicBaseUrl;
+  }
+}
+function emitStreamError(errorText) {
+  return [
+    `data: ${JSON.stringify({ type: "error", errorText })}
+
+`,
+    `data: ${JSON.stringify({ type: "finish", finishReason: "error" })}
+
+`,
+    "data: [DONE]\n\n"
+  ];
+}
+function extractToolResultText(result) {
+  if (result !== null && typeof result === "object") {
+    const r = result;
+    if (Array.isArray(r.content) && r.content.length > 0) {
+      const text = r.content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+      if (text.length > 0) {
+        return text;
+      }
+    }
+  }
+  if (typeof result === "string")
+    return result;
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+function usageToMessageMetadata(usage) {
+  return {
+    input_tokens: usage.input,
+    output_tokens: usage.output,
+    cache_read_input_tokens: usage.cacheRead,
+    cache_creation_input_tokens: usage.cacheWrite
+  };
+}
+function getUsageFromAgentEndMessages(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role === "assistant" && m.usage != null) {
+      return m.usage;
+    }
+  }
+  return void 0;
+}
+function getErrorFromAgentEndMessages(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role === "assistant" && m.errorMessage) {
+      return m.errorMessage;
+    }
+  }
+  return void 0;
+}
+function traceRawMessage(debugCwd, data, reset = false, optionsEnv) {
+  const debugVal = getEnvValue(optionsEnv, "DEBUG");
+  const enabled = debugVal === "true" || debugVal === "1";
+  if (!enabled)
+    return;
+  try {
+    const file = join7(debugCwd, "pi-message-stream-debug.json");
+    if (reset && existsSync5(file))
+      unlinkSync3(file);
+    const type = data !== null && typeof data === "object" ? data.type : void 0;
+    let payload = data;
+    try {
+      payload = data !== void 0 ? JSON.parse(JSON.stringify(data)) : void 0;
+    } catch {
+      payload = "[non-serializable]";
+    }
+    const entry = { _t: (/* @__PURE__ */ new Date()).toISOString(), type, payload };
+    appendFileSync2(file, JSON.stringify(entry, null, 2) + ",\n");
+  } catch {
+  }
+}
+function createPiRunner(options = {}) {
+  const modelSpec = options.model;
+  if (modelSpec == null || modelSpec.trim() === "") {
+    throw new Error("Pi runner: model is required. Pass a model in the form <provider>:<model>, e.g. openai:gpt-4o or google:gemini-2.5-flash.");
+  }
+  const { provider, modelName } = parseModelSpec(modelSpec.trim());
+  const cwd = options.cwd || process.cwd();
+  const apiKeyEnvKey = `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+  const inlineApiKey = typeof options.env?.[apiKeyEnvKey] === "string" && options.env[apiKeyEnvKey].length > 0 ? options.env[apiKeyEnvKey] : void 0;
+  const modelRegistry = ModelRegistry.inMemory(AuthStorage.create());
+  const defaultModel = getModel(provider, modelName);
+  let model = defaultModel ?? modelRegistry.find(provider, modelName);
+  if (model == null) {
+    const baseUrlEnvKey = `${provider.toUpperCase().replace(/-/g, "_")}_BASE_URL`;
+    const baseUrl = getEnvValue(options.env, baseUrlEnvKey) ?? getEnvValue(options.env, "OPENAI_BASE_URL");
+    if (!baseUrl) {
+      throw new Error(`Pi runner: model "${modelSpec}" not found in built-in catalog. Set ${baseUrlEnvKey} (or OPENAI_BASE_URL) to auto-register it.`);
+    }
+    modelRegistry.registerProvider(provider, {
+      baseUrl,
+      apiKey: inlineApiKey ?? apiKeyEnvKey,
+      api: "openai-completions",
+      models: [
+        {
+          id: modelName,
+          name: modelName,
+          reasoning: false,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 128e3,
+          maxTokens: 8192
+        }
+      ]
+    });
+    const registered = modelRegistry.find(provider, modelName);
+    if (!registered) {
+      throw new Error(`Pi runner: failed to resolve model "${modelSpec}" after registration.`);
+    }
+    model = registered;
+  }
+  applyModelOverrides(model, provider, options.env);
+  const imageModelName = resolveImageModelName(provider, options.env);
+  return {
+    async *run(userInput) {
+      if (inlineApiKey !== void 0) {
+        modelRegistry.authStorage.setRuntimeApiKey(provider, inlineApiKey);
+      }
+      try {
+        const resume = options.sessionId?.trim();
+        const sessionManager = await (async () => {
+          if (resume !== void 0 && resume !== "") {
+            if (resume.includes("/")) {
+              return SessionManager.open(resume);
+            }
+            const sessions = await SessionManager.list(cwd);
+            const found = sessions.find((s) => s.id === resume);
+            return found ? SessionManager.open(found.path) : SessionManager.create(cwd);
+          }
+          return SessionManager.create(cwd);
+        })();
+        const resourceLoader = options.skillPaths ? new BunnyAgentResourceLoader({
+          cwd,
+          skillPaths: options.skillPaths,
+          appendSystemPrompt: options.systemPrompt
+        }) : void 0;
+        if (options.skillPaths && options.skillPaths.length > 0) {
+          console.error(`${LOG_PREFIX2} runner: cwd=${cwd} skillPaths=${JSON.stringify(options.skillPaths)}`);
+        }
+        if (resourceLoader) {
+          await resourceLoader.reload();
+        }
+        const customTools = options.env && Object.keys(options.env).length > 0 ? buildSecretAwareTools(cwd, options.env) : [];
+        if (imageModelName) {
+          const apiKey = await modelRegistry.authStorage.getApiKey(provider) ?? "";
+          customTools.push(buildImageGenerateTool(cwd, imageModelName, model.baseUrl, apiKey));
+        }
+        const { session } = await createAgentSession({
+          cwd,
+          model,
+          sessionManager,
+          modelRegistry,
+          resourceLoader,
+          customTools
+        });
+        const eventQueue = [];
+        let isComplete = false;
+        let aborted = false;
+        let wakeConsumer = null;
+        const notify = () => {
+          wakeConsumer?.();
+          wakeConsumer = null;
+        };
+        const unsubscribe = session.subscribe((e) => {
+          eventQueue.push(e);
+          if (e.type === "agent_end") {
+            isComplete = true;
+          }
+          notify();
+        });
+        const abortSignal = options.abortController?.signal;
+        const abortHandler = () => {
+          aborted = true;
+          isComplete = true;
+          void session.abort();
+          notify();
+        };
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", abortHandler);
+          if (abortSignal.aborted) {
+            abortHandler();
+          }
+        }
+        try {
+          traceRawMessage(cwd, null, true, options.env);
+          let promptText = userInput;
+          let images;
+          try {
+            if (userInput.startsWith("[") && userInput.endsWith("]")) {
+              const parsed = JSON.parse(userInput);
+              if (Array.isArray(parsed)) {
+                promptText = parsed.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+                const imageParts = parsed.filter((p) => p.type === "image");
+                if (imageParts.length > 0) {
+                  images = imageParts.map((p) => ({
+                    type: "image",
+                    data: p.data,
+                    mimeType: p.mimeType
+                  }));
+                }
+              }
+            }
+          } catch (_e) {
+          }
+          const promptPromise = session.prompt(promptText, images ? { images } : void 0);
+          const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+          let hasStarted = false;
+          let hasFinished = false;
+          const imageToolUsage = { input_tokens: 0, output_tokens: 0 };
+          const newTextPartId = () => `text_${Date.now()}_${Math.random().toString(36).slice(2)}_${Math.random().toString(36).slice(2)}`;
+          let activeTextPartId = null;
+          let textStreamOpen = false;
+          const endTextStreamIfOpen = function* () {
+            if (textStreamOpen && activeTextPartId != null) {
+              yield `data: ${JSON.stringify({ type: "text-end", id: activeTextPartId })}
+
+`;
+              textStreamOpen = false;
+              activeTextPartId = null;
+            }
+          };
+          const beginTextStream = function* () {
+            activeTextPartId = newTextPartId();
+            yield `data: ${JSON.stringify({ type: "text-start", id: activeTextPartId })}
+
+`;
+            textStreamOpen = true;
+          };
+          const ensureStartEvent = async function* () {
+            if (!hasStarted) {
+              yield `data: ${JSON.stringify({ type: "start", messageId })}
+
+`;
+              yield `data: ${JSON.stringify({
+                type: "message-metadata",
+                messageMetadata: { sessionId: session.sessionId }
+              })}
+
+`;
+              hasStarted = true;
+            }
+          };
+          const finishSuccess = async function* (usage) {
+            yield* endTextStreamIfOpen();
+            const finishPayload = { type: "finish", finishReason: "stop" };
+            const hasImageUsage = imageToolUsage.input_tokens > 0 || imageToolUsage.output_tokens > 0;
+            if (usage != null || hasImageUsage) {
+              const base = usage != null ? usageToMessageMetadata(usage) : {};
+              finishPayload.messageMetadata = {
+                usage: {
+                  ...base,
+                  input_tokens: (base.input_tokens ?? 0) + imageToolUsage.input_tokens,
+                  output_tokens: (base.output_tokens ?? 0) + imageToolUsage.output_tokens
+                }
+              };
+            }
+            yield `data: ${JSON.stringify(finishPayload)}
+
+`;
+            yield "data: [DONE]\n\n";
+            hasFinished = true;
+          };
+          const finishError = async function* (errorText) {
+            for (const chunk of emitStreamError(errorText)) {
+              yield chunk;
+            }
+            hasFinished = true;
+          };
+          while (!isComplete || eventQueue.length > 0) {
+            while (eventQueue.length > 0) {
+              const event = eventQueue.shift();
+              traceRawMessage(cwd, event, false, options.env);
+              yield* ensureStartEvent();
+              if (event.type === "message_start") {
+                const msg = event.message;
+                if (msg?.role === "assistant") {
+                  yield* endTextStreamIfOpen();
+                }
+              } else if (event.type === "message_update") {
+                const sub = event.assistantMessageEvent;
+                if (sub.type === "text_start") {
+                  yield* endTextStreamIfOpen();
+                  yield* beginTextStream();
+                } else if (sub.type === "text_delta") {
+                  let delta = sub.delta;
+                  if (delta) {
+                    if (options.env && Object.keys(options.env).length > 0) {
+                      delta = redactSecrets(delta, options.env);
+                    }
+                    if (!textStreamOpen) {
+                      yield* beginTextStream();
+                    }
+                    yield `data: ${JSON.stringify({
+                      type: "text-delta",
+                      id: activeTextPartId,
+                      delta
+                    })}
+
+`;
+                  }
+                } else if (sub.type === "toolcall_start") {
+                  yield* endTextStreamIfOpen();
+                }
+              } else if (event.type === "tool_execution_start") {
+                yield* endTextStreamIfOpen();
+                yield `data: ${JSON.stringify({ type: "tool-input-start", toolCallId: event.toolCallId, toolName: event.toolName, dynamic: true, providerExecuted: true })}
+
+`;
+                yield `data: ${JSON.stringify({ type: "tool-input-available", toolCallId: event.toolCallId, toolName: event.toolName, input: event.args, dynamic: true, providerExecuted: true })}
+
+`;
+              } else if (event.type === "tool_execution_end") {
+                let output = extractToolResultText(event.result);
+                if (options.env && Object.keys(options.env).length > 0) {
+                  output = redactSecrets(output, options.env);
+                }
+                if (event.toolName === "generate_image" && event.result !== null && typeof event.result === "object") {
+                  const details = event.result.details;
+                  const u = details?.response?.usage;
+                  if (u) {
+                    imageToolUsage.input_tokens += u.input_tokens ?? 0;
+                    imageToolUsage.output_tokens += u.output_tokens ?? 0;
+                  }
+                }
+                yield `data: ${JSON.stringify({ type: "tool-output-available", toolCallId: event.toolCallId, output, isError: event.isError, dynamic: true, providerExecuted: true })}
+
+`;
+              } else if (event.type === "agent_end") {
+                if (aborted) {
+                  yield* finishError("Run aborted by signal.");
+                } else {
+                  const errorMsg = getErrorFromAgentEndMessages(event.messages);
+                  if (errorMsg) {
+                    yield* finishError(errorMsg);
+                  } else {
+                    const usage = getUsageFromAgentEndMessages(event.messages);
+                    yield* finishSuccess(usage);
+                  }
+                }
+              }
+            }
+            if (aborted && !hasFinished) {
+              yield* ensureStartEvent();
+              yield* finishError("Run aborted by signal.");
+              break;
+            }
+            if (!isComplete && eventQueue.length === 0) {
+              await new Promise((resolve4) => {
+                wakeConsumer = resolve4;
+              });
+            }
+          }
+          if (hasFinished) {
+            return;
+          }
+          try {
+            await promptPromise;
+          } catch (error) {
+            if (!hasFinished) {
+              yield* ensureStartEvent();
+              const message = error instanceof Error ? error.message : "Pi agent run failed.";
+              yield* finishError(message);
+            }
+            return;
+          }
+          if (!hasFinished && session.agent.state.error) {
+            yield* ensureStartEvent();
+            yield* finishError(session.agent.state.error);
+          }
+        } finally {
+          if (abortSignal) {
+            abortSignal.removeEventListener("abort", abortHandler);
+          }
+          unsubscribe();
+          session.dispose();
+        }
+      } finally {
+        if (inlineApiKey !== void 0) {
+          modelRegistry.authStorage.removeRuntimeApiKey(provider);
+        }
+      }
+    }
+  };
+}
+
+// ../../packages/runner-harness/dist/session.js
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+var DIR = ".bunny-agent";
+var FILE = "session-id";
+function sessionPath(cwd) {
+  return join8(cwd, DIR, FILE);
+}
+function readSessionId(cwd) {
+  try {
+    const p = sessionPath(cwd);
+    if (!existsSync6(p))
+      return void 0;
+    return readFileSync3(p, "utf8").trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeSessionId(cwd, id) {
+  try {
+    mkdirSync3(join8(cwd, DIR), { recursive: true });
+    writeFileSync4(sessionPath(cwd), id, "utf8");
+  } catch {
+  }
+}
+
+// ../../packages/runner-harness/dist/skills.js
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join9 } from "node:path";
+function discoverSkillPaths(cwd) {
+  const paths = [];
+  for (const base of [
+    join9(cwd, "skills"),
+    join9(homedir2(), ".bunny-agent", "skills")
+  ]) {
+    if (!existsSync7(base))
+      continue;
+    try {
+      for (const entry of readdirSync2(base)) {
+        const full = join9(base, entry);
+        if (statSync2(full).isDirectory() && existsSync7(join9(full, "SKILL.md"))) {
+          paths.push(full);
+        }
+      }
+    } catch {
+    }
+  }
+  return paths;
+}
+
+// ../../packages/runner-harness/dist/runner.js
+function createRunner(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const abortController = options.abortController ?? new AbortController();
+  const autoInject = options.autoInject ?? true;
+  const systemPrompt = options.systemPrompt ?? (autoInject ? loadSystemPrompt(cwd) : void 0);
+  const resume = options.resume ?? (autoInject ? readSessionId(cwd) : void 0);
+  const base = {
+    model: options.model,
+    systemPrompt,
+    maxTurns: options.maxTurns,
+    allowedTools: options.allowedTools,
+    resume,
+    yolo: options.yolo,
+    env,
+    abortController
+  };
+  const rawStream = dispatchRunner(options.runner, base, cwd, options);
+  return autoInject ? captureSessionId(rawStream, cwd) : rawStream;
+}
+function dispatchRunner(runner, base, cwd, options) {
+  const _env = base.env;
+  switch (runner) {
+    case "claude":
+      return createClaudeRunner(base).run(options.userInput);
+    case "codex": {
+      const { outputFormat: _of, ...codexBase } = base;
+      return createCodexRunner({ ...codexBase, cwd }).run(options.userInput);
+    }
+    case "gemini":
+      return createGeminiRunner({
+        model: options.model,
+        cwd,
+        env: base.env,
+        abortController: base.abortController
+      }).run(options.userInput);
+    case "pi":
+      return createPiRunner({
+        ...base,
+        cwd,
+        sessionId: base.resume,
+        skillPaths: options.skillPaths ?? discoverSkillPaths(cwd)
+      }).run(options.userInput);
+    case "opencode":
+      return createOpenCodeRunner({
+        model: options.model,
+        cwd,
+        env: base.env,
+        abortController: base.abortController
+      }).run(options.userInput);
+    case "copilot":
+      throw new Error("Copilot runner not yet implemented");
+    default:
+      throw new Error(`Unknown runner: ${runner}`);
+  }
+}
+async function* captureSessionId(stream, cwd) {
+  for await (const chunk of stream) {
+    if (chunk.includes('"sessionId"') || chunk.includes('"session_id"')) {
+      try {
+        const payload = chunk.replace(/^data:\s*/, "").trim();
+        if (payload && payload !== "[DONE]") {
+          const json = JSON.parse(payload);
+          const sessionId = json?.messageMetadata?.sessionId ?? json?.messageMetadata?.session_id ?? json?.sessionId;
+          if (sessionId && typeof sessionId === "string") {
+            writeSessionId(cwd, sessionId);
+          }
+        }
+      } catch {
+      }
+    }
+    yield chunk;
+  }
+}
+
+// ../../packages/runner-harness/dist/tools/bash-execute.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+
+// src/runner.ts
+async function runAgent(options) {
+  const abortController = new AbortController();
+  const signalHandler = () => abortController.abort();
+  process.on("SIGTERM", signalHandler);
+  process.on("SIGINT", signalHandler);
+  try {
+    for await (const chunk of createRunner({ ...options, abortController })) {
+      process.stdout.write(chunk);
+    }
+  } finally {
+    process.off("SIGTERM", signalHandler);
+    process.off("SIGINT", signalHandler);
+  }
+}
+
+// src/cli.ts
+config({ path: resolve3(process.cwd(), ".env") });
+config({ path: resolve3(process.cwd(), "../.env") });
+config({ path: resolve3(process.cwd(), "../../.env") });
+function getSubcommand() {
+  for (let i = 2; i < process.argv.length; i++) {
+    const a = process.argv[i];
+    if (a === "--") break;
+    if (!a.startsWith("-")) return a;
+  }
+  return void 0;
+}
+function getSubSubcommand() {
+  let found = 0;
+  for (let i = 2; i < process.argv.length; i++) {
+    const a = process.argv[i];
+    if (a === "--") break;
+    if (!a.startsWith("-")) {
+      found++;
+      if (found === 2) return a;
+    }
+  }
+  return void 0;
+}
+function argsAfterPositionals(n) {
+  let found = 0;
+  for (let i = 2; i < process.argv.length; i++) {
+    if (!process.argv[i].startsWith("-") && process.argv[i] !== "--") {
+      found++;
+      if (found === n) return process.argv.slice(i + 1);
+    }
+  }
+  return [];
+}
+function parseRunArgs() {
+  const { values, positionals } = parseArgs({
+    args: argsAfterPositionals(1),
+    options: {
+      runner: { type: "string", short: "r", default: "claude" },
+      model: {
+        type: "string",
+        short: "m",
+        default: "claude-sonnet-4-20250514"
+      },
+      cwd: {
+        type: "string",
+        short: "c",
+        default: process.env.BUNNY_AGENT_WORKSPACE ?? process.cwd()
+      },
+      "system-prompt": { type: "string", short: "s" },
+      "max-turns": { type: "string", short: "t" },
+      "allowed-tools": { type: "string", short: "a" },
+      "skill-path": { type: "string", multiple: true },
+      resume: { type: "string" },
+      yolo: { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help) {
+    printRunHelp();
+    process.exit(0);
+  }
+  const dashIndex = process.argv.indexOf("--");
+  let userInput = "";
+  if (dashIndex !== -1 && dashIndex < process.argv.length - 1) {
+    userInput = process.argv.slice(dashIndex + 1).join(" ");
+  } else if (positionals.length > 0) {
+    userInput = positionals.join(" ");
+  }
+  if (!userInput) {
+    console.error("Error: User input is required");
+    console.error('Usage: bunny-agent run [options] -- "<user input>"');
+    process.exit(1);
+  }
+  const runner = values.runner;
+  if (!["claude", "codex", "gemini", "opencode", "copilot", "pi"].includes(runner)) {
+    console.error(
+      'Error: --runner must be one of: "claude", "codex", "gemini", "opencode", "copilot", "pi"'
+    );
+    process.exit(1);
+  }
+  return {
+    runner,
+    model: values.model,
+    cwd: values.cwd,
+    systemPrompt: values["system-prompt"],
+    maxTurns: values["max-turns"] ? Number.parseInt(values["max-turns"], 10) : void 0,
+    allowedTools: values["allowed-tools"]?.split(",").map((t) => t.trim()),
+    skillPaths: values["skill-path"],
+    resume: values.resume,
+    yolo: values["yolo"],
+    userInput
+  };
+}
+function parseImageBuildArgs() {
+  const { values } = parseArgs({
+    args: argsAfterPositionals(2),
+    options: {
+      name: { type: "string", default: "bunny-agent" },
+      tag: { type: "string", default: "latest" },
+      image: { type: "string" },
+      platform: { type: "string", default: "linux/amd64" },
+      template: { type: "string" },
+      push: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: false,
+    strict: true
+  });
+  if (values.help) {
+    printImageBuildHelp();
+    process.exit(0);
+  }
+  return {
+    name: values.name,
+    tag: values.tag,
+    image: values.image,
+    platform: values.platform,
+    template: values.template,
+    push: values.push ?? false
+  };
+}
+function printRunHelp() {
+  console.log(`
+\u{1F916} BunnyAgent Runner CLI \u2014 run
+
+Runs an agent locally in your terminal, streaming AI SDK UI messages to stdout.
+
+Usage:
+  bunny-agent run [options] -- "<user input>"
+
+Options:
+  -r, --runner <runner>        Runner: claude, codex, gemini, opencode, copilot, pi (default: claude)
+  -m, --model <model>          Model (default: claude-sonnet-4-20250514)
+  -c, --cwd <path>             Working directory (default: cwd)
+  -s, --system-prompt <prompt> Custom system prompt
+  -t, --max-turns <n>          Max conversation turns
+  -a, --allowed-tools <tools>  Comma-separated allowed tools
+      --skill-path <path>      Additional skill path (can be repeated, for pi runner)
+      --resume <session-id>    Resume a previous session
+  -h, --help                   Show this help
+
+Environment:
+  ANTHROPIC_API_KEY            Anthropic API key (for claude runner)
+  OPENAI_API_KEY               OpenAI API key (for codex runner)
+  CODEX_API_KEY                OpenAI API key alias (for codex runner)
+  GEMINI_API_KEY               Gemini API key (for gemini runner)
+  BUNNY_AGENT_WORKSPACE          Default workspace path
+`);
+}
+function printImageBuildHelp() {
+  console.log(`
+\u{1F433} BunnyAgent Runner CLI \u2014 image build
+
+Build (and optionally push) a BunnyAgent Docker image.
+The image includes Claude Agent SDK + runner-cli pre-installed.
+
+Usage:
+  bunny-agent image build [options]
+
+Options:
+  --name <name>          Image name, e.g. vikadata/bunny-agent-seo (default: bunny-agent)
+  --tag <tag>            Image tag (default: latest)
+  --image <full>         Full image name override (e.g. myorg/myimage:v1)
+  --platform <plat>      Build platform (default: linux/amd64)
+  --template <path>      Path to agent template directory to bake into the image
+  --push                 Push image to registry after build
+  -h, --help             Show this help
+
+Examples:
+  bunny-agent image build --name vikadata/bunny-agent-seo --tag 0.1.0
+  bunny-agent image build --name vikadata/bunny-agent-seo --tag 0.1.0 --template ./templates/seo-agent
+  bunny-agent image build --name vikadata/bunny-agent-seo --tag 0.1.0 --template ./templates/seo-agent --push
+`);
+}
+function printImageHelp() {
+  console.log(`
+\u{1F433} BunnyAgent Runner CLI \u2014 image
+
+Manage BunnyAgent Docker images.
+
+Usage:
+  bunny-agent image <subcommand> [options]
+
+Subcommands:
+  build    Build (and optionally push) a Docker image
+
+Run "bunny-agent image build --help" for build options.
+`);
+}
+function printGlobalHelp() {
+  console.log(`
+\u{1F916} BunnyAgent Runner CLI
+
+Usage:
+  bunny-agent <command> [options]
+
+Commands:
+  run          Run an agent locally (streams AI SDK UI messages to stdout)
+  image build  Build a BunnyAgent Docker image (with optional --push)
+
+Run "bunny-agent <command> --help" for command-specific options.
+`);
+}
+async function main() {
+  const sub = getSubcommand();
+  if (!sub || sub === "--help" || sub === "-h") {
+    printGlobalHelp();
+    process.exit(0);
+  }
+  switch (sub) {
+    case "run": {
+      const args = parseRunArgs();
+      process.chdir(args.cwd);
+      await runAgent({
+        runner: args.runner,
+        model: args.model,
+        userInput: args.userInput,
+        systemPrompt: args.systemPrompt,
+        maxTurns: args.maxTurns,
+        allowedTools: args.allowedTools,
+        skillPaths: args.skillPaths,
+        resume: args.resume,
+        yolo: args.yolo
+      });
+      break;
+    }
+    case "image": {
+      const subSub = getSubSubcommand();
+      if (!subSub || subSub === "--help" || subSub === "-h") {
+        printImageHelp();
+        process.exit(0);
+      }
+      if (subSub === "build") {
+        const args = parseImageBuildArgs();
+        await buildImage(args);
+      } else {
+        console.error(`Unknown image subcommand: ${subSub}`);
+        printImageHelp();
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${sub}`);
+      printGlobalHelp();
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});