@sandagent/runner-cli 0.1.1 → 0.1.2-beta.2

package/dist/bundle.mjs

@@ -3,12 +3,244 @@
 // src/cli.ts
 import { parseArgs } from "node:util";
 
+// ../../packages/runner-claude/dist/ai-sdk-stream.js
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+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 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;
+  return {
+    inputTokens: {
+      total: inputTokens + cacheWrite + cacheRead,
+      noCache: inputTokens,
+      cacheRead,
+      cacheWrite
+    },
+    outputTokens: { total: outputTokens },
+    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;
+  accumulatedText = "";
+  textPartId;
+  streamedTextLength = 0;
+  // Track text already emitted via stream_events
+  hasReceivedStreamEvents = false;
+  sessionId;
+  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");
+  }
+  /**
+   * 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_stop") {
+      const partId = this.getPartId(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, options) {
+    const debugMessages = [];
+    const debugFile = `ai-sdk-stream-debug-${Date.now()}.json`;
+    try {
+      for await (const message of messageIterator) {
+        debugMessages.push(message);
+        if (message.type === "system" && message.subtype === "init") {
+          this.systemMessage = message;
+          this.sessionId = this.systemMessage.session_id;
+        }
+        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 (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;
+          const finishTime = (/* @__PURE__ */ new Date()).toISOString();
+          console.error(`[AISDKStream] Processing result message at ${finishTime}`);
+          const finishEvent = this.emit({
+            type: "finish",
+            finishReason: mapFinishReason(resultMsg.subtype, resultMsg.is_error),
+            messageMetadata: {
+              usage: convertUsageToAISDK(resultMsg.usage ?? {})
+            }
+          });
+          console.error(`[AISDKStream] Emitting finish event at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+          yield finishEvent;
+          console.error(`[AISDKStream] Emitted [DONE] at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        }
+      }
+    } catch (error) {
+      debugMessages.push(error);
+    } finally {
+      if (debugMessages.length > 0) {
+        writeFile(join(process.cwd(), debugFile), JSON.stringify(debugMessages, null, 2), "utf-8").catch((writeError) => {
+          console.error(`[AISDKStream] Failed to write debug file:`, writeError);
+        });
+      }
+      options?.onCleanup?.();
+      yield `data: [DONE]
+
+`;
+    }
+  }
+};
+function streamSDKMessagesToAISDKUI(messageIterator, options) {
+  return new AISDKStreamConverter().stream(messageIterator, options);
+}
+
 // ../../packages/runner-claude/dist/claude-runner.js
-var SettingSource;
-(function(SettingSource2) {
-  SettingSource2["user"] = "user";
-  SettingSource2["project"] = "project";
-})(SettingSource || (SettingSource = {}));
 function createCanUseToolCallback(claudeOptions) {
   return async (toolName, input, options) => {
     const { toolUseID } = options;
@@ -48,7 +280,7 @@ function createCanUseToolCallback(claudeOptions) {
               }
             };
           }
-        } catch (error) {
+        } catch {
         }
         await new Promise((resolve) => setTimeout(resolve, 500));
       }
@@ -83,22 +315,19 @@ var OPTIONAL_MODULES = {
 };
 function createClaudeRunner(options) {
   return {
-    async *run(userInput, signal) {
-      if (signal?.aborted) {
-        return;
-      }
+    async *run(userInput) {
       const apiKey = process.env.ANTHROPIC_API_KEY || process.env.AWS_BEARER_TOKEN_BEDROCK;
       if (!apiKey) {
         console.error("[SandAgent] Warning: ANTHROPIC_API_KEY or AWS_BEARER_TOKEN_BEDROCK not set. Using mock response.\nTo use the real Claude Agent SDK:\n1. Set ANTHROPIC_API_KEY or AWS_BEARER_TOKEN_BEDROCK environment variable\n2. Install the SDK: npm install @anthropic-ai/claude-agent-sdk");
-        yield* runMockAgent(options, userInput, signal);
+        yield* runMockAgent(options, userInput, options.abortController?.signal);
         return;
       }
       const sdk = await loadClaudeAgentSDK();
       if (sdk) {
-        yield* runWithClaudeAgentSDK(sdk, options, userInput, signal);
+        yield* runWithClaudeAgentSDK(sdk, options, userInput);
       } else {
         console.error("[SandAgent] 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, signal);
+        yield* runMockAgent(options, userInput, options.abortController?.signal);
       }
     }
   };
@@ -115,31 +344,52 @@ async function loadClaudeAgentSDK() {
     return null;
   }
 }
-async function* runWithClaudeAgentSDK(sdk, options, userInput, signal) {
-  const usage = { inputTokens: 0, outputTokens: 0 };
-  let systemMessage;
-  let messageId;
-  const sdkOptions = {
+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;
+  }
+}
+function createSDKOptions(options) {
+  return {
     model: options.model,
     systemPrompt: options.systemPrompt,
     maxTurns: options.maxTurns,
-    allowedTools: [...options.allowedTools ?? [], "Skill"],
+    allowedTools: [
+      ...options.allowedTools ?? [],
+      "Skill",
+      "WebSearch",
+      "WebFetch"
+    ],
     cwd: options.cwd,
     env: options.env,
     resume: options.resume,
-    settingSources: [SettingSource.project, SettingSource.user],
+    settingSources: ["project", "user"],
     canUseTool: createCanUseToolCallback(options),
     // Bypass all permission checks for automated execution
     permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true
+    allowDangerouslySkipPermissions: true,
+    // Enable partial messages for streaming
+    includePartialMessages: options.includePartialMessages
   };
-  const queryIterator = sdk.query({
-    prompt: userInput,
-    options: sdkOptions
-  });
+}
+function setupAbortHandler(queryIterator, signal) {
   const abortHandler = async () => {
-    console.error("[ClaudeRunner] Operation aborted, calling query.interrupt()");
+    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");
@@ -150,163 +400,71 @@ async function* runWithClaudeAgentSDK(sdk, options, userInput, signal) {
   } else {
     console.error("[ClaudeRunner] No signal provided");
   }
+  return abortHandler;
+}
+async function* runWithTextOutput(sdk, options, userInput, signal) {
+  const sdkOptions = createSDKOptions(options);
+  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
+  const abortHandler = setupAbortHandler(queryIterator, options.abortController?.signal);
   try {
+    let resultText = "";
     for await (const message of queryIterator) {
-      if (message.type === "system" && message.subtype === "init") {
-        systemMessage = message;
-        continue;
-      }
-      if (message.type === "assistant" && !messageId && systemMessage) {
-        messageId = message.message.id;
-        yield formatDataStream({
-          type: "start",
-          messageId
-        });
-        yield formatDataStream({
-          type: "message-metadata",
-          messageMetadata: {
-            tools: systemMessage.tools,
-            model: systemMessage.model,
-            sessionId: systemMessage.session_id
-          }
-        });
-      }
-      const chunks = convertSDKMessageToAISDKUI(message);
-      for (const chunk of chunks) {
-        yield chunk;
+      if (message.type === "result") {
+        const resultMsg = message;
+        if (resultMsg.subtype === "success") {
+          resultText = resultMsg.result || "";
+        }
       }
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-    console.error("[ClaudeRunner] Error:", errorMessage);
-    yield formatDataStream({ type: "error", errorText: errorMessage });
-    yield formatDataStream({
-      type: "finish",
-      finishReason: "error",
-      usage: {
-        promptTokens: usage.inputTokens,
-        completionTokens: usage.outputTokens
-      }
-    });
+    yield resultText;
   } finally {
     if (signal) {
       signal.removeEventListener("abort", abortHandler);
     }
-    yield `data: [DONE]
-
-`;
   }
 }
-function convertSDKMessageToAISDKUI(message) {
-  const chunks = [];
-  switch (message.type) {
-    case "assistant": {
-      const assistantMsg = message;
-      if (assistantMsg.error) {
-        const errorDetail = message.message.content.map((c) => c.text).join("\n");
-        chunks.push(formatDataStream({
-          type: "error",
-          errorText: `${assistantMsg.error}: ${errorDetail}`
-        }));
-        break;
-      }
-      if (assistantMsg.message) {
-        if (typeof assistantMsg.message === "string") {
-          const textId = generateId();
-          chunks.push(formatDataStream({ type: "text-start", id: textId }));
-          chunks.push(formatDataStream({
-            type: "text-delta",
-            id: textId,
-            delta: assistantMsg.message
-          }));
-          chunks.push(formatDataStream({ type: "text-end", id: textId }));
-        } else if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
-          for (const block of assistantMsg.message.content) {
-            if (block.type === "text" && block.text) {
-              const textId = generateId();
-              chunks.push(formatDataStream({ type: "text-start", id: textId }));
-              chunks.push(formatDataStream({
-                type: "text-delta",
-                id: textId,
-                delta: block.text
-              }));
-              chunks.push(formatDataStream({ type: "text-end", id: textId }));
-            } else if (block.type === "tool_use") {
-              const toolCallId = block.id || generateId();
-              chunks.push(formatDataStream({
-                type: "tool-input-start",
-                toolCallId,
-                toolName: block.name,
-                dynamic: true
-              }));
-              if (block.input) {
-                chunks.push(formatDataStream({
-                  type: "tool-input-available",
-                  toolCallId,
-                  toolName: block.name,
-                  dynamic: true,
-                  input: block.input
-                }));
-              }
-            }
-          }
-        }
+async function* runWithJSONOutput(sdk, options, userInput, signal) {
+  const sdkOptions = createSDKOptions(options);
+  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
+  const abortHandler = setupAbortHandler(queryIterator, signal);
+  try {
+    let resultMessage = null;
+    for await (const message of queryIterator) {
+      if (message.type === "result") {
+        resultMessage = message;
       }
-      break;
     }
-    case "result": {
-      const resultMsg = message;
-      chunks.push(formatDataStream({
-        type: "finish",
-        finishReason: resultMsg.is_error ? "error" : "stop",
-        messageMetadata: {
-          usage: resultMsg.usage,
-          duration_ms: resultMsg.duration_ms,
-          num_turns: resultMsg.num_turns,
-          total_cost_usd: resultMsg.total_cost_usd
-        }
-      }));
-      break;
+    if (resultMessage) {
+      yield JSON.stringify(resultMessage) + "\n";
     }
-    case "user": {
-      const usrMsg = message;
-      if (usrMsg.isSynthetic) {
-        break;
-      }
-      const contentArray = usrMsg.message.content;
-      if (usrMsg.tool_use_result || Array.isArray(contentArray) && contentArray.some((c) => c.type === "tool_result")) {
-        for (const tool of contentArray) {
-          if (tool.is_error) {
-            chunks.push(formatDataStream({
-              type: "tool-output-error",
-              toolCallId: tool.tool_use_id,
-              errorText: tool.content,
-              dynamic: true
-            }));
-          } else {
-            chunks.push(formatDataStream({
-              type: "tool-output-available",
-              toolCallId: tool.tool_use_id,
-              output: usrMsg.tool_use_result || tool.content,
-              dynamic: true
-            }));
-          }
-        }
-      }
-      break;
+  } finally {
+    if (signal) {
+      signal.removeEventListener("abort", abortHandler);
     }
-    default:
-      break;
   }
-  return chunks;
 }
-function formatDataStream(data) {
-  return `data: ${JSON.stringify(data)}
-
-`;
+async function* runWithStreamJSONOutput(sdk, options, userInput, signal) {
+  const sdkOptions = createSDKOptions(options);
+  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
+  const abortHandler = setupAbortHandler(queryIterator, signal);
+  try {
+    for await (const message of queryIterator) {
+      yield JSON.stringify(message) + "\n";
+    }
+  } finally {
+    if (signal) {
+      signal.removeEventListener("abort", abortHandler);
+    }
+  }
 }
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+async function* runWithAISDKUIOutput(sdk, options, userInput) {
+  const sdkOptions = createSDKOptions({
+    ...options,
+    includePartialMessages: true
+  });
+  const queryIterator = sdk.query({ prompt: userInput, options: sdkOptions });
+  setupAbortHandler(queryIterator, options.abortController?.signal);
+  yield* streamSDKMessagesToAISDKUI(queryIterator);
 }
 async function* runMockAgent(options, userInput, signal) {
   if (signal?.aborted) {
@@ -314,6 +472,11 @@ async function* runMockAgent(options, userInput, signal) {
     return;
   }
   try {
+    const messageId = generateId();
+    yield formatDataStream({
+      type: "start",
+      messageId
+    });
     const response = `I received your request: "${userInput}"
 
 Model: ${options.model}
@@ -341,7 +504,13 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
     yield formatDataStream({ type: "text-end", id: textId });
     yield formatDataStream({
       type: "finish",
-      finishReason: "stop"
+      finishReason: mapFinishReason("success"),
+      usage: convertUsageToAISDK({
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      })
     });
     yield `data: [DONE]
 
@@ -352,7 +521,13 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
     yield formatDataStream({ type: "error", errorText: errorMessage });
     yield formatDataStream({
       type: "finish",
-      finishReason: "error"
+      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]
 
@@ -363,28 +538,47 @@ Documentation: https://platform.claude.com/docs/en/agent-sdk/typescript-v2-previ
 // src/runner.ts
 async function runAgent(options) {
   const abortController = new AbortController();
-  const signalHandler = () => {
+  const signalHandler = async () => {
     console.error("[Runner] Received termination signal, stopping...");
     abortController.abort();
-    console.error("[Runner] AbortController.abort() called");
+    console.error(
+      "[Runner] AbortController.abort() completed (listeners triggered)"
+    );
   };
   process.on("SIGTERM", signalHandler);
   process.on("SIGINT", signalHandler);
   console.error("[Runner] Signal handlers registered");
   try {
-    const runnerOptions = {
-      model: options.model,
-      systemPrompt: options.systemPrompt,
-      maxTurns: options.maxTurns,
-      allowedTools: options.allowedTools,
-      resume: options.resume,
-      approvalDir: options.approvalDir
-    };
-    const runner = createClaudeRunner(runnerOptions);
-    for await (const chunk of runner.run(
-      options.userInput,
-      abortController.signal
-    )) {
+    let runner;
+    switch (options.runner) {
+      case "claude": {
+        const runnerOptions = {
+          model: options.model,
+          systemPrompt: options.systemPrompt,
+          maxTurns: options.maxTurns,
+          allowedTools: options.allowedTools,
+          resume: options.resume,
+          approvalDir: options.approvalDir,
+          outputFormat: options.outputFormat,
+          abortController
+        };
+        runner = createClaudeRunner(runnerOptions);
+        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."
+        );
+      default:
+        throw new Error(
+          `Unknown runner: ${options.runner}. Supported runners: claude, codex, copilot`
+        );
+    }
+    for await (const chunk of runner.run(options.userInput)) {
       process.stdout.write(chunk);
     }
   } finally {
@@ -397,6 +591,11 @@ async function runAgent(options) {
 function parseCliArgs() {
   const { values, positionals } = parseArgs({
     options: {
+      runner: {
+        type: "string",
+        short: "r",
+        default: "claude"
+      },
       model: {
         type: "string",
         short: "m",
@@ -407,11 +606,6 @@ function parseCliArgs() {
         short: "c",
         default: process.env.SANDAGENT_WORKSPACE ?? process.cwd()
       },
-      template: {
-        type: "string",
-        short: "T",
-        default: process.env.SANDAGENT_TEMPLATE ?? "default"
-      },
       "system-prompt": {
         type: "string",
         short: "s"
@@ -431,6 +625,10 @@ function parseCliArgs() {
       "approval-dir": {
         type: "string"
       },
+      "output-format": {
+        type: "string",
+        short: "o"
+      },
       help: {
         type: "boolean",
         short: "h"
@@ -460,15 +658,30 @@ function parseCliArgs() {
     console.error('Usage: sandagent run [options] -- "<user input>"');
     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)) {
+    console.error(
+      'Error: --output-format must be one of: "text", "json", "stream-json", "stream"'
+    );
+    process.exit(1);
+  }
   return {
+    runner,
     model: values.model,
     cwd: values.cwd,
-    template: values.template,
     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()),
     resume: values.resume,
     approvalDir: values["approval-dir"],
+    outputFormat: outputFormat ?? "stream",
     userInput
   };
 }
@@ -482,43 +695,29 @@ Streams AI SDK UI messages directly to stdout.
 Usage:
   sandagent run [options] -- "<user input>"
 
-  # Or run from a template directory:
-  cd templates/coder
-  sandagent run -- "Build a REST API"
-
 Options:
+  -r, --runner <runner>        Runner to use: claude, codex, copilot (default: claude)
   -m, --model <model>          Model to use (default: claude-sonnet-4-20250514)
   -c, --cwd <path>             Working directory (default: current directory)
-  -T, --template <name>        Template to use (default: default)
-                               Available: default, coder, analyst, researcher
-  -s, --system-prompt <prompt> Custom system prompt (overrides template)
+  -s, --system-prompt <prompt> Custom system prompt
   -t, --max-turns <n>          Maximum conversation turns
   -a, --allowed-tools <tools>  Comma-separated list of allowed tools
   -r, --resume <session-id>    Resume a previous session
+  -o, --output-format <format> Output format (default: stream)
+                               Available: text, json(single result), stream-json(realtime streaming), stream(ai sdk ui sse format)
   -h, --help                   Show this help message
 
 Environment Variables:
   ANTHROPIC_API_KEY           Anthropic API key (required)
   SANDAGENT_WORKSPACE         Default workspace path
-  SANDAGENT_TEMPLATE          Default template to use
   SANDAGENT_LOG_LEVEL         Logging level (debug, info, warn, error)
 
-Templates:
-  default     General-purpose assistant
-  coder       Optimized for software development
-  analyst     Optimized for data analysis
-  researcher  Optimized for research tasks
-
 Examples:
-  # Run with default template
+  # Run with default settings
   sandagent run -- "Create a hello world script"
 
-  # Run from a template directory (recommended)
-  cd templates/coder
-  sandagent run -- "Build a REST API with Express"
-
-  # Use a specific template
-  sandagent run --template analyst -- "Analyze sales.csv"
+  # Run with custom system prompt
+  sandagent run --system-prompt "You are a coding assistant" -- "Build a REST API with Express"
 
   # Specify working directory
   sandagent run --cwd ./my-project -- "Fix the bug in main.ts"
@@ -528,14 +727,15 @@ async function main() {
   const args = parseCliArgs();
   process.chdir(args.cwd);
   await runAgent({
+    runner: args.runner,
     model: args.model,
-    template: args.template,
     userInput: args.userInput,
     systemPrompt: args.systemPrompt,
     maxTurns: args.maxTurns,
     allowedTools: args.allowedTools,
     resume: args.resume,
-    approvalDir: args.approvalDir
+    approvalDir: args.approvalDir,
+    outputFormat: args.outputFormat
   });
 }
 main().catch((error) => {