@sandagent/runner-cli 0.2.24 → 0.5.1-beta.0

package/dist/bundle.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import { resolve as resolve2 } from "node:path";
+import { config } from "dotenv";
 import { parseArgs } from "node:util";
 
 // src/build-image.ts
@@ -372,7 +374,7 @@ var AISDKStreamConverter = class {
           const userMsg = message;
           const content = userMsg.message?.content;
           for (const part of content) {
-            if (part.type === "tool_result") {
+            if (typeof part !== "string" && part.type === "tool_result") {
               yield this.emit({
                 type: "tool-output-available",
                 toolCallId: part.tool_use_id,
@@ -501,7 +503,7 @@ function createCanUseToolCallback(claudeOptions) {
           }
         } catch {
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        await new Promise((resolve3) => setTimeout(resolve3, 500));
       }
       try {
         fs.unlinkSync(approvalFile);
@@ -577,22 +579,7 @@ async function loadClaudeAgentSDK() {
   }
 }
 async function* runWithClaudeAgentSDK(sdk, options, userInput) {
-  const outputFormat = options.outputFormat || "stream-json";
-  switch (outputFormat) {
-    case "text":
-      yield* runWithTextOutput(sdk, options, userInput);
-      break;
-    case "json":
-      yield* runWithJSONOutput(sdk, options, userInput);
-      break;
-    case "stream-json":
-      yield* runWithStreamJSONOutput(sdk, options, userInput);
-      break;
-    // case "stream":
-    default:
-      yield* runWithAISDKUIOutput(sdk, options, userInput);
-      break;
-  }
+  yield* runWithAISDKUIOutput(sdk, options, userInput);
 }
 function createSDKOptions(options) {
   const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
@@ -638,55 +625,6 @@ function setupAbortHandler(queryIterator, signal) {
     }
   };
 }
-async function* runWithTextOutput(sdk, options, userInput) {
-  const sdkOptions = createSDKOptions(options);
-  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
-  const cleanup = setupAbortHandler(queryIterator, options.abortController?.signal);
-  try {
-    let resultText = "";
-    for await (const message of queryIterator) {
-      if (message.type === "result") {
-        const resultMsg = message;
-        if (resultMsg.subtype === "success") {
-          resultText = resultMsg.result || "";
-        }
-      }
-    }
-    yield resultText;
-  } finally {
-    cleanup();
-  }
-}
-async function* runWithJSONOutput(sdk, options, userInput) {
-  const sdkOptions = createSDKOptions(options);
-  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
-  const cleanup = setupAbortHandler(queryIterator, options.abortController?.signal);
-  try {
-    let resultMessage = null;
-    for await (const message of queryIterator) {
-      if (message.type === "result") {
-        resultMessage = message;
-      }
-    }
-    if (resultMessage) {
-      yield JSON.stringify(resultMessage) + "\n";
-    }
-  } finally {
-    cleanup();
-  }
-}
-async function* runWithStreamJSONOutput(sdk, options, userInput) {
-  const sdkOptions = createSDKOptions(options);
-  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
-  const cleanup = setupAbortHandler(queryIterator, options.abortController?.signal);
-  try {
-    for await (const message of queryIterator) {
-      yield JSON.stringify(message) + "\n";
-    }
-  } finally {
-    cleanup();
-  }
-}
 async function* runWithAISDKUIOutput(sdk, options, userInput) {
   const sdkOptions = createSDKOptions({
     ...options,
@@ -733,7 +671,7 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
         id: textId,
         delta: word + " "
       });
-      await new Promise((resolve2) => setTimeout(resolve2, 20));
+      await new Promise((resolve3) => setTimeout(resolve3, 20));
     }
     yield formatDataStream({ type: "text-end", id: textId });
     yield formatDataStream({
@@ -769,6 +707,738 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
   }
 }
 
+// ../../packages/runner-codex/dist/codex-runner.js
+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
+      }
+    };
+  }
+  if (item.type === "mcp_tool_call") {
+    return {
+      toolCallId: item.id,
+      result: item.result ?? item.error ?? { status: item.status }
+    };
+  }
+  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);
+      const streamedTurn = await thread.runStreamed(userInput, {
+        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 })}
+
+`;
+        }
+        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]
+
+`;
+        }
+      }
+    }
+  };
+}
+
+// ../../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 existsSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { getModel } from "@mariozechner/pi-ai";
+import { SessionManager, createAgentSession } from "@mariozechner/pi-coding-agent";
+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 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 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) {
+  const enabled = process.env.DEBUG === "true" || process.env.DEBUG === "1";
+  if (!enabled)
+    return;
+  try {
+    const file = join3(debugCwd, "pi-message-stream-debug.json");
+    if (reset && existsSync3(file))
+      unlinkSync2(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 model = getModel(provider, modelName);
+  if (model == null) {
+    throw new Error(`Pi runner: unsupported model "${modelSpec}". getModel("${provider}", "${modelName}") returned undefined. Use a model from the pi-ai catalog; supported providers are typically: google, openai.`);
+  }
+  applyModelOverrides(model, provider, options.env);
+  return {
+    async *run(userInput) {
+      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.continueRecent(cwd);
+        }
+        return SessionManager.continueRecent(cwd);
+      })();
+      const { session } = await createAgentSession({
+        cwd,
+        model,
+        sessionManager
+      });
+      if (options.systemPrompt != null && options.systemPrompt !== "") {
+        session.agent.setSystemPrompt(options.systemPrompt);
+      } else {
+        session.agent.setSystemPrompt("You are a helpful coding assistant.");
+      }
+      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);
+        const promptPromise = session.prompt(userInput);
+        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;
+        let hasFinished = false;
+        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) {
+          if (hasTextStarted) {
+            yield `data: ${JSON.stringify({ type: "text-end", id: textId })}
+
+`;
+          }
+          const finishPayload = { type: "finish", finishReason: "stop" };
+          if (usage != null) {
+            finishPayload.messageMetadata = {
+              usage: usageToMessageMetadata(usage)
+            };
+          }
+          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);
+            yield* ensureStartEvent();
+            if (event.type === "message_update") {
+              if (event.assistantMessageEvent.type === "text_delta") {
+                const delta = event.assistantMessageEvent.delta;
+                if (delta) {
+                  if (!hasTextStarted) {
+                    yield `data: ${JSON.stringify({ type: "text-start", id: textId })}
+
+`;
+                    hasTextStarted = true;
+                  }
+                  yield `data: ${JSON.stringify({ type: "text-delta", id: textId, delta })}
+
+`;
+                }
+              }
+            } else if (event.type === "tool_execution_start") {
+              yield `data: ${JSON.stringify({ type: "tool-input-start", toolCallId: event.toolCallId, toolName: event.toolName, dynamic: true })}
+
+`;
+              yield `data: ${JSON.stringify({ type: "tool-input-available", toolCallId: event.toolCallId, toolName: event.toolName, input: event.args, dynamic: true })}
+
+`;
+            } else if (event.type === "tool_execution_end") {
+              yield `data: ${JSON.stringify({ type: "tool-output-available", toolCallId: event.toolCallId, output: event.result, dynamic: 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((resolve3) => {
+              wakeConsumer = resolve3;
+            });
+          }
+        }
+        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();
+      }
+    }
+  };
+}
+
 // src/runner.ts
 async function runAgent(options) {
   const abortController = new AbortController();
@@ -786,29 +1456,66 @@ async function runAgent(options) {
     let runner;
     switch (options.runner) {
       case "claude": {
-        const runnerOptions = {
+        runner = createClaudeRunner({
           model: options.model,
           systemPrompt: options.systemPrompt,
           maxTurns: options.maxTurns,
           allowedTools: options.allowedTools,
           resume: options.resume,
-          outputFormat: options.outputFormat,
+          env: process.env,
           abortController
-        };
-        runner = createClaudeRunner(runnerOptions);
+        });
+        break;
+      }
+      case "codex": {
+        runner = createCodexRunner({
+          model: options.model,
+          systemPrompt: options.systemPrompt,
+          maxTurns: options.maxTurns,
+          allowedTools: options.allowedTools,
+          resume: options.resume,
+          cwd: process.cwd(),
+          env: process.env,
+          abortController
+        });
         break;
       }
-      case "codex":
-        throw new Error(
-          "Codex runner not yet implemented. Use --runner=claude for now."
-        );
       case "copilot":
         throw new Error(
           "Copilot runner not yet implemented. Use --runner=claude for now."
         );
+      case "gemini": {
+        runner = createGeminiRunner({
+          model: options.model,
+          cwd: process.cwd(),
+          env: process.env,
+          abortController
+        });
+        break;
+      }
+      case "pi": {
+        runner = createPiRunner({
+          model: options.model,
+          systemPrompt: options.systemPrompt,
+          cwd: process.cwd(),
+          env: process.env,
+          abortController,
+          sessionId: options.resume
+        });
+        break;
+      }
+      case "opencode": {
+        runner = createOpenCodeRunner({
+          model: options.model,
+          cwd: process.cwd(),
+          env: process.env,
+          abortController
+        });
+        break;
+      }
       default:
         throw new Error(
-          `Unknown runner: ${options.runner}. Supported runners: claude, codex, copilot`
+          `Unknown runner: ${options.runner}. Supported runners: claude, codex, gemini, opencode, copilot, pi`
         );
     }
     for await (const chunk of runner.run(options.userInput)) {
@@ -821,6 +1528,9 @@ async function runAgent(options) {
 }
 
 // src/cli.ts
+config({ path: resolve2(process.cwd(), ".env") });
+config({ path: resolve2(process.cwd(), "../.env") });
+config({ path: resolve2(process.cwd(), "../../.env") });
 function getSubcommand() {
   for (let i = 2; i < process.argv.length; i++) {
     const a = process.argv[i];
@@ -870,7 +1580,6 @@ function parseRunArgs() {
       "max-turns": { type: "string", short: "t" },
       "allowed-tools": { type: "string", short: "a" },
       resume: { type: "string" },
-      "output-format": { type: "string", short: "o" },
       help: { type: "boolean", short: "h" }
     },
     allowPositionals: true,
@@ -893,16 +1602,9 @@ function parseRunArgs() {
     process.exit(1);
   }
   const runner = values.runner;
-  if (!["claude", "codex", "copilot"].includes(runner)) {
-    console.error(
-      'Error: --runner must be one of: "claude", "codex", "copilot"'
-    );
-    process.exit(1);
-  }
-  const outputFormat = values["output-format"];
-  if (outputFormat && !["text", "json", "stream-json", "stream"].includes(outputFormat)) {
+  if (!["claude", "codex", "gemini", "opencode", "copilot", "pi"].includes(runner)) {
     console.error(
-      'Error: --output-format must be one of: "text", "json", "stream-json", "stream"'
+      'Error: --runner must be one of: "claude", "codex", "gemini", "opencode", "copilot", "pi"'
     );
     process.exit(1);
   }
@@ -914,7 +1616,6 @@ function parseRunArgs() {
     maxTurns: values["max-turns"] ? Number.parseInt(values["max-turns"], 10) : void 0,
     allowedTools: values["allowed-tools"]?.split(",").map((t) => t.trim()),
     resume: values.resume,
-    outputFormat: outputFormat ?? "stream",
     userInput
   };
 }
@@ -956,18 +1657,20 @@ Usage:
   sandagent run [options] -- "<user input>"
 
 Options:
-  -r, --runner <runner>        Runner: claude, codex, copilot (default: claude)
+  -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
       --resume <session-id>    Resume a previous session
-  -o, --output-format <fmt>    text | json | stream-json | stream (default: stream)
   -h, --help                   Show this help
 
 Environment:
-  ANTHROPIC_API_KEY            Anthropic API key (required)
+  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)
   SANDAGENT_WORKSPACE          Default workspace path
 `);
 }
@@ -1042,8 +1745,7 @@ async function main() {
         systemPrompt: args.systemPrompt,
         maxTurns: args.maxTurns,
         allowedTools: args.allowedTools,
-        resume: args.resume,
-        outputFormat: args.outputFormat
+        resume: args.resume
       });
       break;
     }