ai-cli-mcp 2.14.1 → 2.16.0

package/src/__tests__/utils/opencode-mock.ts

@@ -0,0 +1,108 @@
+import { chmodSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface OpenCodeMockOptions {
+  argsLogPath?: string;
+  defaultSessionId?: string;
+}
+
+export interface OpenCodeMockResult {
+  scriptPath: string;
+  argsLogPath?: string;
+}
+
+export function createOpenCodeMock(dir: string, options: OpenCodeMockOptions = {}): OpenCodeMockResult {
+  const scriptPath = join(dir, 'mock-opencode');
+  const defaultSessionId = options.defaultSessionId || 'ses-opencode-default';
+  const argsLogPath = options.argsLogPath;
+  const argsLogSection = argsLogPath
+    ? `printf '%s\n' "$*" >> "${argsLogPath}"\n`
+    : '';
+
+  writeFileSync(
+    scriptPath,
+    `#!/bin/bash
+set -euo pipefail
+
+prompt=""
+session_id=""
+session_provided=0
+model=""
+work_dir=""
+
+${argsLogSection}if [[ "\${1:-}" == "run" ]]; then
+  shift
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --format)
+      shift 2
+      ;;
+    --dir)
+      work_dir="$2"
+      shift 2
+      ;;
+    --session)
+      session_id="$2"
+      session_provided=1
+      shift 2
+      ;;
+    --model)
+      model="$2"
+      shift 2
+      ;;
+    *)
+      prompt="$1"
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$session_id" ]]; then
+  session_id="${defaultSessionId}"
+fi
+
+if [[ "$prompt" == *"sleep"* ]]; then
+  sleep 5
+fi
+
+if [[ "$prompt" == *"fail"* ]]; then
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Partial failure output"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":42},"cost":0}}\n' "$session_id"
+  printf 'OpenCode failed for %s in %s\n' "$model" "$work_dir" >&2
+  exit 7
+fi
+
+if [[ "$prompt" == *"multi-step"* ]]; then
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"First step"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11},"cost":0}}\n' "$session_id"
+  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Second step"}}\n' "$session_id"
+  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":22},"cost":1}}\n' "$session_id"
+  exit 0
+fi
+
+message_prefix="Initial"
+if [[ $session_provided -eq 1 ]]; then
+  message_prefix="Resumed"
+fi
+if [[ -n "$model" ]]; then
+  message_prefix="Model $model"
+  if [[ $session_provided -eq 1 ]]; then
+    message_prefix="Resumed model $model"
+  fi
+fi
+
+printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
+printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"%s: %s"}}\n' "$session_id" "$message_prefix" "$prompt"
+printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}\n' "$session_id"
+`,
+    'utf8',
+  );
+  chmodSync(scriptPath, 0o755);
+
+  return { scriptPath, argsLogPath };
+}

package/src/__tests__/validation.test.ts

@@ -69,7 +69,6 @@ describe('Argument Validation Tests', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.resetModules();
-    vi.unmock('../server.js');
     consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     // Set up process.env
     process.env = { ...process.env };
@@ -80,6 +79,7 @@ describe('Argument Validation Tests', () => {
       mockHomedir.mockReturnValue('/home/user');
       mockExistsSync.mockReturnValue(true);
       setupServerMock();
+      vi.doUnmock('../server.js');
       const module = await import('../server.js');
       // @ts-ignore
       const { ClaudeCodeServer } = module;
@@ -114,6 +114,7 @@ describe('Argument Validation Tests', () => {
       mockHomedir.mockReturnValue('/home/user');
       mockExistsSync.mockReturnValue(true);
       setupServerMock();
+      vi.doUnmock('../server.js');
       const module = await import('../server.js');
       // @ts-ignore
       const { ClaudeCodeServer } = module;
@@ -216,7 +217,7 @@ describe('Argument Validation Tests', () => {
 
       const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
 
-      vi.mocked(Server).mockImplementation(() => {
+      vi.mocked(Server).mockImplementation(function(this: any) {
         mockServerInstance = {
           setRequestHandler: vi.fn((schema: any, handler: Function) => {
             handlers.set(schema.name, handler);
@@ -228,6 +229,7 @@ describe('Argument Validation Tests', () => {
         return mockServerInstance as any;
       });
 
+      vi.doUnmock('../server.js');
       const module = await import('../server.js');
       // @ts-ignore
       const { ClaudeCodeServer } = module;
@@ -319,5 +321,49 @@ describe('Argument Validation Tests', () => {
         })
       ).rejects.toThrow(/reasoning_effort/i);
     });
+
+    it.each([
+      'oc-',
+      'oc-openai',
+      'oc-/gpt-5.4',
+      'oc-openai/',
+      ' oc-openai/gpt-5.4',
+      'oc-openai/gpt-5.4 ',
+    ])('should reject malformed OpenCode model syntax at runtime: %s', async (model) => {
+      await setupServer();
+      const handler = handlers.get('callTool')!;
+
+      await expect(
+        handler({
+          params: {
+            name: 'run',
+            arguments: {
+              prompt: 'test',
+              workFolder: '/tmp',
+              model,
+            }
+          }
+        })
+      ).rejects.toThrow('Invalid OpenCode model. Expected exact syntax oc-<provider/model>.');
+    });
+
+    it('should reject reasoning_effort for OpenCode runtime requests', async () => {
+      await setupServer();
+      const handler = handlers.get('callTool')!;
+
+      await expect(
+        handler({
+          params: {
+            name: 'run',
+            arguments: {
+              prompt: 'test',
+              workFolder: '/tmp',
+              model: 'opencode',
+              reasoning_effort: 'high',
+            }
+          }
+        })
+      ).rejects.toThrow('reasoning_effort is not supported for opencode.');
+    });
   });
 });

package/src/app/cli.ts

@@ -2,12 +2,14 @@ import { runMcpServer } from './mcp.js';
 import { CliProcessService } from '../cli-process-service.js';
 import { getCliDoctorStatus } from '../cli-utils.js';
 import { getModelsPayload } from '../model-catalog.js';
+import { validatePeekPids, validatePeekTimeSec } from '../peek.js';
 
 export const CLI_HELP_TEXT = `Usage: ai-cli <command> [options]
 
 Commands:
   run       Start an AI CLI process in the background
   wait      Wait for one or more pids
+  peek      Observe new natural-language agent messages for a short window
   ps        List tracked processes
   result    Get the current result for a pid
   kill      Terminate a tracked pid
@@ -26,9 +28,9 @@ Options:
   --cwd <path>                 Working directory
   --prompt <text>              Prompt text
   --prompt-file <path>         Path to a prompt file
-  --model <model>              Model name or alias (e.g. sonnet, claude-ultra, gpt-5.2-codex, codex-ultra, gemini-2.5-pro, gemini-ultra, forge)
-  --session-id <id>            Resume a previous session
-  --reasoning-effort <level>   Reasoning level for Claude/Codex only
+  --model <model>              Model name or alias (e.g. sonnet, claude-ultra, gpt-5.2-codex, codex-ultra, gemini-2.5-pro, gemini-ultra, forge, opencode, oc-openai/gpt-5.4)
+  --session-id <id>            Resume a previous session, including OpenCode in-place resumes
+  --reasoning-effort <level>   Reasoning level for Claude/Codex only; unsupported for Gemini, Forge, and OpenCode
   --help, -h                   Show this help message
 
 Compatibility aliases:
@@ -58,6 +60,17 @@ Options:
   --help, -h                   Show this help message
 `;
 
+export const PEEK_HELP_TEXT = `Usage: ai-cli peek <pid...> [options]
+
+Observe new natural-language agent messages for a short one-shot window.
+In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].
+This is not a history API, gapless streaming, or stdout/stderr tailing. No --follow mode is available in v1.
+
+Options:
+  --time <seconds>             Observation window in seconds. Defaults to 10, maximum 60
+  --help, -h                   Show this help message
+`;
+
 export const KILL_HELP_TEXT = `Usage: ai-cli kill <pid>
 
 Terminate a tracked process.
@@ -92,7 +105,7 @@ Options:
 
 export const DOCTOR_HELP_TEXT = `Usage: ai-cli doctor
 
-Check whether supported AI CLI binaries are available.
+Check whether supported AI CLI binaries are available, including OpenCode.
 
 Options:
   --help, -h                   Show this help message
@@ -118,6 +131,7 @@ interface CliDeps {
   listProcesses: () => Promise<any>;
   getProcessResult: (pid: number, verbose: boolean) => Promise<any>;
   waitForProcesses: (pids: number[], timeoutSeconds?: number, verbose?: boolean) => Promise<any>;
+  peekProcesses: (pids: number[], peekTimeSec?: number) => Promise<any>;
   killProcess: (pid: number) => Promise<any>;
   cleanupProcesses: () => Promise<any>;
   getDoctorStatus: () => any;
@@ -140,6 +154,7 @@ const defaultDeps: CliDeps = {
   listProcesses: () => getCliProcessService().listProcesses(),
   getProcessResult: (pid, verbose) => getCliProcessService().getProcessResult(pid, verbose),
   waitForProcesses: (pids, timeoutSeconds, verbose) => getCliProcessService().waitForProcesses(pids, timeoutSeconds, verbose),
+  peekProcesses: (pids, peekTimeSec) => getCliProcessService().peekProcesses(pids, peekTimeSec),
   killProcess: (pid) => getCliProcessService().killProcess(pid),
   cleanupProcesses: () => getCliProcessService().cleanupProcesses(),
   getDoctorStatus: () => getCliDoctorStatus(),
@@ -204,6 +219,10 @@ function hasHelpFlag(flags: Record<string, string>): boolean {
   return 'help' in flags || 'h' in flags;
 }
 
+function parsePeekCliPids(values: string[]): number[] {
+  return validatePeekPids(values.map((value) => Number(value)));
+}
+
 export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promise<number> {
   const {
     stdout,
@@ -213,6 +232,7 @@ export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promi
     listProcesses,
     getProcessResult,
     waitForProcesses,
+    peekProcesses,
     killProcess,
     cleanupProcesses,
     getDoctorStatus,
@@ -323,6 +343,34 @@ export async function runCli(argv: string[], deps: Partial<CliDeps> = {}): Promi
     return 0;
   }
 
+  if (command === 'peek') {
+    const { positionals, flags } = parseArgs(argv.slice(1));
+    if (hasHelpFlag(flags)) {
+      stdout(PEEK_HELP_TEXT);
+      return 0;
+    }
+    if ('follow' in flags) {
+      stderr('peek does not support --follow in v1\n');
+      stdout(CLI_HELP_TEXT);
+      return 1;
+    }
+
+    let pids: number[];
+    let peekTimeSec: number;
+    try {
+      pids = parsePeekCliPids(positionals);
+      const timeRaw = getFirstFlag(flags, ['time']);
+      peekTimeSec = validatePeekTimeSec(timeRaw === undefined ? undefined : Number(timeRaw));
+    } catch (error: any) {
+      stderr(`${error.message}\n`);
+      stdout(CLI_HELP_TEXT);
+      return 1;
+    }
+
+    writeJson(stdout, await peekProcesses(pids, peekTimeSec));
+    return 0;
+  }
+
   if (command === 'kill') {
     const { positionals, flags } = parseArgs(argv.slice(1));
     if (hasHelpFlag(flags)) {

package/src/app/mcp.ts

@@ -8,8 +8,9 @@ import {
   type ServerResult,
 } from '@modelcontextprotocol/sdk/types.js';
 import { spawn } from 'node:child_process';
-import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from '../cli-utils.js';
+import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from '../cli-utils.js';
 import { getModelParameterDescription, getSupportedModelsDescription } from '../model-catalog.js';
+import { validatePeekPids, validatePeekTimeSec } from '../peek.js';
 import { ProcessService } from '../process-service.js';
 
 // Server version - update this when releasing new versions
@@ -73,6 +74,7 @@ export class ClaudeCodeServer {
   private codexCliPath: string;
   private geminiCliPath: string;
   private forgeCliPath: string;
+  private opencodeCliPath: string;
   private processService: ProcessService;
   private sigintHandler?: () => Promise<void>;
   private packageVersion: string;
@@ -82,10 +84,12 @@ export class ClaudeCodeServer {
     this.codexCliPath = findCodexCli();
     this.geminiCliPath = findGeminiCli();
     this.forgeCliPath = findForgeCli();
+    this.opencodeCliPath = findOpencodeCli();
     console.error(`[Setup] Using Claude CLI command/path: ${this.claudeCliPath}`);
     console.error(`[Setup] Using Codex CLI command/path: ${this.codexCliPath}`);
     console.error(`[Setup] Using Gemini CLI command/path: ${this.geminiCliPath}`);
     console.error(`[Setup] Using Forge CLI command/path: ${this.forgeCliPath}`);
+    console.error(`[Setup] Using OpenCode CLI command/path: ${this.opencodeCliPath}`);
     this.packageVersion = SERVER_VERSION;
     this.processService = new ProcessService({
       cliPaths: {
@@ -93,6 +97,7 @@ export class ClaudeCodeServer {
         codex: this.codexCliPath,
         gemini: this.geminiCliPath,
         forge: this.forgeCliPath,
+        opencode: this.opencodeCliPath,
       },
     });
 
@@ -123,7 +128,7 @@ export class ClaudeCodeServer {
       tools: [
         {
           name: 'run',
-          description: `AI Agent Runner: Starts a Claude, Codex, Gemini, or Forge CLI process in the background and returns a PID immediately. Use list_processes and get_result to monitor progress.
+          description: `AI Agent Runner: Starts a Claude, Codex, Gemini, Forge, or OpenCode CLI process in the background and returns a PID immediately. Use list_processes and get_result to monitor progress.
 
 • File ops: Create, read, (fuzzy) edit, move, copy, delete, list files, analyze/ocr images, file content analysis
 • Code: Generate / analyse / refactor / fix
@@ -167,11 +172,11 @@ ${getSupportedModelsDescription()}
               },
               reasoning_effort: {
                 type: 'string',
-                description: 'Reasoning control for Claude and Codex. Claude uses --effort with "low", "medium", "high". Codex uses model_reasoning_effort with "low", "medium", "high", "xhigh". Forge does not support reasoning_effort in this integration.',
+                description: 'Reasoning control for Claude and Codex. Claude uses --effort with "low", "medium", "high". Codex uses model_reasoning_effort with "low", "medium", "high", "xhigh". Gemini, Forge, and OpenCode do not support reasoning_effort in this integration.',
               },
               session_id: {
                 type: 'string',
-                description: 'Optional session ID to resume a previous session. Supported for: haiku, sonnet, opus, gemini-2.5-pro, gemini-2.5-flash, gemini-3.1-pro-preview, gemini-3-pro-preview, gemini-3-flash-preview, forge.',
+                description: 'Optional session ID to resume a previous session. Supported for Claude, Codex, Gemini, Forge, and OpenCode. OpenCode resumes in-place via --session and may also be combined with explicit oc-<provider/model> selection.',
               },
             },
             required: ['workFolder'],
@@ -226,6 +231,25 @@ ${getSupportedModelsDescription()}
             required: ['pids'],
           },
         },
+        {
+          name: 'peek',
+          description: 'One-shot short observation window for running child agents. Returns only natural-language agent messages observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with messages: [].',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              pids: {
+                type: 'array',
+                items: { type: 'number' },
+                description: 'Process IDs returned by run. Duplicates are deduplicated server-side, preserving first occurrence order. Unknown PIDs are returned per process as not_found.',
+              },
+              peek_time_sec: {
+                type: 'number',
+                description: 'Optional positive integer observation window in seconds. Defaults to 10; maximum is 60.',
+              },
+            },
+            required: ['pids'],
+          },
+        },
         {
           name: 'kill_process',
           description: 'Terminate a running AI agent process by PID.',
@@ -266,6 +290,8 @@ ${getSupportedModelsDescription()}
           return this.handleGetResult(toolArguments);
         case 'wait':
           return this.handleWait(toolArguments);
+        case 'peek':
+          return this.handlePeek(toolArguments);
         case 'kill_process':
           return this.handleKillProcess(toolArguments);
         case 'cleanup_processes':
@@ -355,6 +381,30 @@ ${getSupportedModelsDescription()}
     }
   }
 
+  private async handlePeek(toolArguments: any): Promise<ServerResult> {
+    let pids: number[];
+    let peekTimeSec: number;
+
+    try {
+      pids = validatePeekPids(toolArguments.pids);
+      peekTimeSec = validatePeekTimeSec(toolArguments.peek_time_sec);
+    } catch (error: any) {
+      throw new McpError(ErrorCode.InvalidParams, error.message);
+    }
+
+    try {
+      const response = await this.processService.peekProcesses(pids, peekTimeSec);
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(response, null, 2)
+        }]
+      };
+    } catch (error: any) {
+      throw new McpError(ErrorCode.InternalError, `Failed to peek processes: ${error.message}`);
+    }
+  }
+
   private async handleKillProcess(toolArguments: any): Promise<ServerResult> {
     if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
       throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');

package/src/cli-builder.ts

@@ -1,11 +1,21 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve as pathResolve, isAbsolute } from 'node:path';
+import type { CliPaths } from './cli-utils.js';
 import { MODEL_ALIASES } from './model-catalog.js';
 
 export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
 const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
+const OPENCODE_MODEL_ERROR = 'Invalid OpenCode model. Expected exact syntax oc-<provider/model>.';
 
-function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' | 'forge' {
+type Agent = 'codex' | 'claude' | 'gemini' | 'forge' | 'opencode';
+
+interface ModelSelection {
+  agent: Agent;
+  resolvedModel: string;
+  openCodeModel: string | null;
+}
+
+function getStandardAgentForModel(model: string): Exclude<Agent, 'opencode'> {
   if (model === 'forge') {
     return 'forge';
   }
@@ -18,20 +28,63 @@ function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' | 'forge
   return 'claude';
 }
 
-/**
- * Resolves model aliases to their full model names
- * @param model - The model name or alias to resolve
- * @returns The full model name, or the original value if no alias exists
- */
+function isPotentialOpenCodeExplicitModel(rawModel: string): boolean {
+  return rawModel.startsWith('oc-') || rawModel.trim().startsWith('oc-');
+}
+
+function extractOpenCodeModel(rawModel: string): string {
+  if (rawModel !== rawModel.trim()) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  if (!rawModel.startsWith('oc-')) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  const remainder = rawModel.slice(3);
+  const slashIndex = remainder.indexOf('/');
+  if (slashIndex === -1) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  const provider = remainder.slice(0, slashIndex);
+  const model = remainder.slice(slashIndex + 1);
+  if (!provider || !model) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  return remainder;
+}
+
+function resolveModelSelection(rawModel: string): ModelSelection {
+  if (rawModel === 'opencode') {
+    return {
+      agent: 'opencode',
+      resolvedModel: rawModel,
+      openCodeModel: null,
+    };
+  }
+
+  if (isPotentialOpenCodeExplicitModel(rawModel)) {
+    return {
+      agent: 'opencode',
+      resolvedModel: rawModel,
+      openCodeModel: extractOpenCodeModel(rawModel),
+    };
+  }
+
+  const resolvedModel = resolveModelAlias(rawModel);
+  return {
+    agent: getStandardAgentForModel(resolvedModel),
+    resolvedModel,
+    openCodeModel: null,
+  };
+}
+
 export function resolveModelAlias(model: string): string {
   return MODEL_ALIASES[model] || model;
 }
 
-/**
- * Validates and normalizes reasoning effort parameter.
- * @returns normalized reasoning effort string, or '' if not applicable
- * @throws Error for invalid values (plain Error, not MCP-specific)
- */
 export function getReasoningEffort(model: string, rawValue: unknown): string {
   if (typeof rawValue !== 'string') {
     return '';
@@ -40,13 +93,18 @@ export function getReasoningEffort(model: string, rawValue: unknown): string {
   if (!trimmed) {
     return '';
   }
+
+  if (model === 'opencode' || model.startsWith('oc-')) {
+    throw new Error('reasoning_effort is not supported for opencode.');
+  }
+
   const normalized = trimmed.toLowerCase();
   if (!ALLOWED_REASONING_EFFORTS.has(normalized)) {
     throw new Error(
       `Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`
     );
   }
-  const agent = getAgentForModel(model);
+  const agent = getStandardAgentForModel(model);
   if (agent === 'forge') {
     throw new Error('reasoning_effort is not supported for forge.');
   }
@@ -67,7 +125,7 @@ export interface CliCommand {
   cliPath: string;
   args: string[];
   cwd: string;
-  agent: 'claude' | 'codex' | 'gemini' | 'forge';
+  agent: Agent;
   prompt: string;
   resolvedModel: string;
 }
@@ -79,21 +137,14 @@ export interface BuildCliCommandOptions {
   model?: string;
   session_id?: string;
   reasoning_effort?: string;
-  cliPaths: { claude: string; codex: string; gemini: string; forge: string };
+  cliPaths: CliPaths;
 }
 
-/**
- * Build a CLI command from the given options.
- * This is a pure function (aside from filesystem reads for prompt_file / workFolder validation).
- * @throws Error on validation failures
- */
 export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
-  // Validate workFolder
   if (!options.workFolder || typeof options.workFolder !== 'string') {
     throw new Error('Missing or invalid required parameter: workFolder');
   }
 
-  // Validate prompt / prompt_file
   const hasPrompt = !!options.prompt && typeof options.prompt === 'string' && options.prompt.trim() !== '';
   const hasPromptFile = !!options.prompt_file && typeof options.prompt_file === 'string' && options.prompt_file.trim() !== '';
 
@@ -105,7 +156,6 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
   }
 
-  // Determine prompt
   let prompt: string;
   if (hasPrompt) {
     prompt = options.prompt!;
@@ -125,18 +175,14 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
   }
 
-  // Resolve workFolder
   const cwd = pathResolve(options.workFolder);
   if (!existsSync(cwd)) {
     throw new Error(`Working folder does not exist: ${options.workFolder}`);
   }
 
-  // Resolve model
   const rawModel = options.model || '';
-  const resolvedModel = resolveModelAlias(rawModel);
-  const agent = getAgentForModel(resolvedModel);
+  const { agent, resolvedModel, openCodeModel } = resolveModelSelection(rawModel);
 
-  // Special handling for ultra aliases: default to higher reasoning if not specified
   let reasoningEffortArg: string | undefined = options.reasoning_effort;
   if (!reasoningEffortArg) {
     if (rawModel === 'codex-ultra') {
@@ -146,9 +192,11 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
   }
 
-  const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
+  const reasoningTargetModel = rawModel === 'opencode' || rawModel.startsWith('oc-')
+    ? rawModel
+    : (resolvedModel || rawModel);
+  const reasoningEffort = getReasoningEffort(reasoningTargetModel, reasoningEffortArg);
 
-  // Build CLI path and args
   let cliPath: string;
   let args: string[];
 
@@ -169,10 +217,9 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push('--skip-git-repo-check', '--full-auto', '--json', prompt);
-
   } else if (agent === 'gemini') {
     cliPath = options.cliPaths.gemini;
-    args = ['-y', '--output-format', 'json'];
+    args = ['-y', '--output-format', 'stream-json'];
 
     if (options.session_id && typeof options.session_id === 'string') {
       args.push('-r', options.session_id);
@@ -183,7 +230,6 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push(prompt);
-
   } else if (agent === 'forge') {
     cliPath = options.cliPaths.forge;
     args = ['-C', cwd];
@@ -193,6 +239,19 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push('-p', prompt);
+  } else if (agent === 'opencode') {
+    cliPath = options.cliPaths.opencode;
+    args = ['run', '--format', 'json', '--dir', cwd];
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args.push('--session', options.session_id);
+    }
+
+    if (openCodeModel) {
+      args.push('--model', openCodeModel);
+    }
+
+    args.push(prompt);
   } else {
     cliPath = options.cliPaths.claude;
     args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];