@sandagent/runner-cli 0.2.24 → 0.5.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
@@ -227,8 +229,6 @@ 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
@@ -256,13 +256,6 @@ var AISDKStreamConverter = class {
     }
     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
    */
@@ -303,18 +296,9 @@ var AISDKStreamConverter = class {
         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_")) {
+      const partId = this.getPartId(event.index);
+      if (partId.startsWith("text_")) {
         yield this.emit({ type: "text-end", id: partId });
       }
     }
@@ -372,7 +356,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,
@@ -386,7 +370,6 @@ var AISDKStreamConverter = class {
         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",
@@ -404,53 +387,21 @@ var AISDKStreamConverter = class {
         }
       }
     } 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) });
-      }
+      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);
+        yield this.emit({ type: "error", errorText: errorMessage });
+        yield this.emit({
+          type: "finish",
+          finishReason: mapFinishReason("error_during_execution", true),
+          messageMetadata: {
+            usage: convertUsageToAISDK({}),
+            sessionId: this.sessionId
           }
-          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]
@@ -501,7 +452,7 @@ function createCanUseToolCallback(claudeOptions) {
           }
         } catch {
         }
-        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        await new Promise((resolve3) => setTimeout(resolve3, 500));
       }
       try {
         fs.unlinkSync(approvalFile);
@@ -577,25 +528,9 @@ 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;
   return {
     model: options.model,
     systemPrompt: options.systemPrompt,
@@ -611,8 +546,10 @@ function createSDKOptions(options) {
     resume: options.resume,
     settingSources: ["project", "user"],
     canUseTool: createCanUseToolCallback(options),
-    permissionMode: isRoot ? "default" : "bypassPermissions",
-    allowDangerouslySkipPermissions: !isRoot,
+    // Bypass all permission checks for automated execution
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    // Enable partial messages for streaming
     includePartialMessages: options.includePartialMessages
   };
 }
@@ -638,55 +575,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 +621,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 +657,647 @@ 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 { Agent } from "@mariozechner/pi-agent-core";
+import { getModel } from "@mariozechner/pi-ai";
+import { createCodingTools } 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) {
+  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 createPiRunner(options = {}) {
+  const modelSpec = options.model || "google:gemini-2.5-flash-lite-preview-06-17";
+  const { provider, modelName } = parseModelSpec(modelSpec);
+  const cwd = options.cwd || process.cwd();
+  const model = getModel(provider, modelName);
+  applyModelOverrides(model, provider, options.env);
+  const agent = new Agent({
+    initialState: {
+      systemPrompt: options.systemPrompt || "You are a helpful coding assistant.",
+      model,
+      tools: createCodingTools(cwd)
+    }
+  });
+  return {
+    async *run(userInput) {
+      const eventQueue = [];
+      let isComplete = false;
+      let aborted = false;
+      let wakeConsumer = null;
+      const notify = () => {
+        wakeConsumer?.();
+        wakeConsumer = null;
+      };
+      const unsubscribe = agent.subscribe((e) => {
+        eventQueue.push(e);
+        if (e.type === "agent_end") {
+          isComplete = true;
+        }
+        notify();
+      });
+      const abortSignal = options.abortController?.signal;
+      const abortHandler = () => {
+        aborted = true;
+        isComplete = true;
+        agent.abort();
+        notify();
+      };
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", abortHandler);
+        if (abortSignal.aborted) {
+          abortHandler();
+        }
+      }
+      try {
+        const promptPromise = agent.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 })}
+
+`;
+            hasStarted = true;
+          }
+        };
+        const finishSuccess = async function* () {
+          if (hasTextStarted) {
+            yield `data: ${JSON.stringify({ type: "text-end", id: textId })}
+
+`;
+          }
+          yield `data: ${JSON.stringify({ type: "finish", finishReason: "stop" })}
+
+`;
+          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();
+            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 })}
+
+`;
+              yield `data: ${JSON.stringify({ type: "tool-input-available", toolCallId: event.toolCallId, toolName: event.toolName, input: event.args })}
+
+`;
+            } else if (event.type === "tool_execution_end") {
+              yield `data: ${JSON.stringify({ type: "tool-output-available", toolCallId: event.toolCallId, output: event.result })}
+
+`;
+            } else if (event.type === "agent_end") {
+              if (aborted) {
+                yield* finishError("Run aborted by signal.");
+              } else {
+                yield* finishSuccess();
+              }
+            }
+          }
+          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 && agent.state.error) {
+          yield* ensureStartEvent();
+          yield* finishError(agent.state.error);
+        }
+      } finally {
+        if (abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        unsubscribe();
+      }
+    }
+  };
+}
+
 // src/runner.ts
 async function runAgent(options) {
   const abortController = new AbortController();
@@ -786,29 +1315,65 @@ 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
+        });
+        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 +1386,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 +1438,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 +1460,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 +1474,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 +1515,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 +1603,7 @@ async function main() {
         systemPrompt: args.systemPrompt,
         maxTurns: args.maxTurns,
         allowedTools: args.allowedTools,
-        resume: args.resume,
-        outputFormat: args.outputFormat
+        resume: args.resume
       });
       break;
     }