ai-cli-mcp 2.14.0 → 2.15.0

package/dist/__tests__/parsers.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseCodexOutput, parseClaudeOutput, parseForgeOutput } from '../parsers.js';
+import { parseCodexOutput, parseClaudeOutput, parseForgeOutput, parseOpenCodeOutput } from '../parsers.js';
 describe('parseCodexOutput', () => {
     it('should parse basic Codex output with message and session_id', () => {
         const output = `
@@ -132,3 +132,64 @@ still streaming`;
         expect(parseForgeOutput('plain text')).toBeNull();
     });
 });
+describe('parseOpenCodeOutput', () => {
+    it('parses a single completed OpenCode step', () => {
+        const output = `{"type":"step_start","sessionID":"ses_1"}
+{"type":"text","sessionID":"ses_1","part":{"type":"text","text":"Hello"}}
+{"type":"step_finish","sessionID":"ses_1","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Hello',
+            session_id: 'ses_1',
+            tokens: { total: 11833 },
+            cost: 0,
+        });
+    });
+    it('returns the last completed step for multi-step output', () => {
+        const output = `{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"First"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":10},"cost":0}}
+{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"Second"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":20},"cost":1}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Second',
+            session_id: 'ses_2',
+            tokens: { total: 20 },
+            cost: 1,
+        });
+    });
+    it('resets the current-step buffer on each step_start', () => {
+        const output = `{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Discard me"}}
+{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Keep me"}}
+{"type":"step_finish","sessionID":"ses_3","part":{"type":"step-finish","tokens":{"total":5},"cost":0}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Keep me',
+            session_id: 'ses_3',
+            tokens: { total: 5 },
+            cost: 0,
+        });
+    });
+    it('returns partial output when text exists without step_finish', () => {
+        const output = `{"type":"step_start","sessionID":"ses_4"}
+{"type":"text","sessionID":"ses_4","part":{"type":"text","text":"Partial"}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Partial',
+            session_id: 'ses_4',
+        });
+    });
+    it('ignores malformed lines and unknown event types', () => {
+        const output = `not-json
+{"type":"unknown","sessionID":"ses_5"}
+{"type":"text","sessionID":"ses_5","part":{"type":"text","text":"Hello"}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Hello',
+            session_id: 'ses_5',
+        });
+    });
+    it('returns null when no useful OpenCode events exist', () => {
+        expect(parseOpenCodeOutput('{"type":"unknown"}')).toBeNull();
+        expect(parseOpenCodeOutput('')).toBeNull();
+    });
+});

package/dist/__tests__/process-management.test.js

@@ -60,7 +60,7 @@ describe('Process Management Tests', () => {
     });
     async function setupServer() {
         const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-        vi.mocked(Server).mockImplementation(() => {
+        vi.mocked(Server).mockImplementation(function () {
             mockServerInstance = {
                 setRequestHandler: vi.fn((schema, handler) => {
                     handlers.set(schema.name, handler);

package/dist/__tests__/server.test.js

@@ -174,6 +174,37 @@ describe('ClaudeCodeServer Unit Tests', () => {
             expect(() => findClaudeCli()).toThrow('Invalid CLAUDE_CLI_NAME: Relative paths are not allowed');
         });
     });
+    describe('findOpencodeCli function', () => {
+        it('should fallback to PATH for OpenCode when no override is configured', async () => {
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode');
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/usr/bin/opencode')
+                    return undefined;
+                throw new Error('not executable');
+            });
+            process.env.PATH = '/usr/bin';
+            const module = await import('../server.js');
+            // @ts-ignore
+            const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+            expect(findOpencodeCli()).toBe('/usr/bin/opencode');
+        });
+        it('should use custom name from OPENCODE_CLI_NAME', async () => {
+            process.env.OPENCODE_CLI_NAME = 'opencode-custom';
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockImplementation((path) => path === '/usr/bin/opencode-custom');
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/usr/bin/opencode-custom')
+                    return undefined;
+                throw new Error('not executable');
+            });
+            process.env.PATH = '/usr/bin';
+            const module = await import('../server.js');
+            // @ts-ignore
+            const findOpencodeCli = module.default?.findOpencodeCli || module.findOpencodeCli;
+            expect(findOpencodeCli()).toBe('opencode-custom');
+        });
+    });
     describe('spawnAsync function', () => {
         let mockProcess;
         beforeEach(() => {
@@ -276,13 +307,11 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const server = new ClaudeCodeServer();
             expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('[Setup] Using Claude CLI command/path:'));
         });
-        it('should set up tool handlers', async () => {
+        it('should include OpenCode in setup logging', async () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(true);
-            const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-            const mockSetRequestHandler = vi.fn();
             vi.mocked(Server).mockImplementation(function () {
-                this.setRequestHandler = mockSetRequestHandler;
+                this.setRequestHandler = vi.fn();
                 this.connect = vi.fn();
                 this.close = vi.fn();
                 this.onerror = undefined;
@@ -291,8 +320,8 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            expect(mockSetRequestHandler).toHaveBeenCalled();
+            new ClaudeCodeServer();
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('[Setup] Using OpenCode CLI command/path:'));
         });
         it('should set up error handler', async () => {
             mockHomedir.mockReturnValue('/home/user');

package/dist/__tests__/utils/opencode-mock.js

@@ -0,0 +1,91 @@
+import { chmodSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function createOpenCodeMock(dir, options = {}) {
+    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/dist/__tests__/validation.test.js

@@ -63,7 +63,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 };
@@ -73,6 +72,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;
@@ -99,6 +99,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;
@@ -183,7 +184,7 @@ describe('Argument Validation Tests', () => {
             vi.mocked(existsSync).mockReturnValue(true);
             vi.mocked(homedir).mockReturnValue('/home/user');
             const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-            vi.mocked(Server).mockImplementation(() => {
+            vi.mocked(Server).mockImplementation(function () {
                 mockServerInstance = {
                     setRequestHandler: vi.fn((schema, handler) => {
                         handlers.set(schema.name, handler);
@@ -194,6 +195,7 @@ describe('Argument Validation Tests', () => {
                 };
                 return mockServerInstance;
             });
+            vi.doUnmock('../server.js');
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
@@ -266,5 +268,41 @@ 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/dist/app/cli.js

@@ -24,9 +24,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:
@@ -83,7 +83,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

package/dist/app/mcp.js

@@ -2,7 +2,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } 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 { ProcessService } from '../process-service.js';
 // Server version - update this when releasing new versions
@@ -59,6 +59,7 @@ export class ClaudeCodeServer {
     codexCliPath;
     geminiCliPath;
     forgeCliPath;
+    opencodeCliPath;
     processService;
     sigintHandler;
     packageVersion;
@@ -67,10 +68,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: {
@@ -78,6 +81,7 @@ export class ClaudeCodeServer {
                 codex: this.codexCliPath,
                 gemini: this.geminiCliPath,
                 forge: this.forgeCliPath,
+                opencode: this.opencodeCliPath,
             },
         });
         this.server = new Server({
@@ -101,7 +105,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
@@ -145,11 +149,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'],

package/dist/cli-builder.js

@@ -3,7 +3,8 @@ import { resolve as pathResolve, isAbsolute } from 'node:path';
 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']);
-function getAgentForModel(model) {
+const OPENCODE_MODEL_ERROR = 'Invalid OpenCode model. Expected exact syntax oc-<provider/model>.';
+function getStandardAgentForModel(model) {
     if (model === 'forge') {
         return 'forge';
     }
@@ -15,19 +16,53 @@ function getAgentForModel(model) {
     }
     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) {
+    return rawModel.startsWith('oc-') || rawModel.trim().startsWith('oc-');
+}
+function extractOpenCodeModel(rawModel) {
+    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) {
+    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) {
     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, rawValue) {
     if (typeof rawValue !== 'string') {
         return '';
@@ -36,11 +71,14 @@ export function getReasoningEffort(model, rawValue) {
     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.');
     }
@@ -52,17 +90,10 @@ export function getReasoningEffort(model, rawValue) {
     }
     return normalized;
 }
-/**
- * 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) {
-    // 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() !== '';
     if (!hasPrompt && !hasPromptFile) {
@@ -71,7 +102,6 @@ export function buildCliCommand(options) {
     if (hasPrompt && hasPromptFile) {
         throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
     }
-    // Determine prompt
     let prompt;
     if (hasPrompt) {
         prompt = options.prompt;
@@ -90,16 +120,12 @@ export function buildCliCommand(options) {
             throw new Error(`Failed to read prompt file: ${error.message}`);
         }
     }
-    // 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);
-    // Special handling for ultra aliases: default to higher reasoning if not specified
+    const { agent, resolvedModel, openCodeModel } = resolveModelSelection(rawModel);
     let reasoningEffortArg = options.reasoning_effort;
     if (!reasoningEffortArg) {
         if (rawModel === 'codex-ultra') {
@@ -109,8 +135,10 @@ export function buildCliCommand(options) {
             reasoningEffortArg = 'high';
         }
     }
-    const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
-    // Build CLI path and args
+    const reasoningTargetModel = rawModel === 'opencode' || rawModel.startsWith('oc-')
+        ? rawModel
+        : (resolvedModel || rawModel);
+    const reasoningEffort = getReasoningEffort(reasoningTargetModel, reasoningEffortArg);
     let cliPath;
     let args;
     if (agent === 'codex') {
@@ -148,6 +176,17 @@ export function buildCliCommand(options) {
         }
         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'];

package/dist/cli-parse.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
-const AGENTS = ['claude', 'codex', 'gemini', 'forge'];
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
+const AGENTS = ['claude', 'codex', 'gemini', 'forge', 'opencode'];
+const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge|opencode>
 
 Reads raw CLI output from stdin and outputs parsed JSON to stdout.
 
 Options:
-  --agent   Agent type: claude, codex, gemini, or forge (required)
+  --agent   Agent type: claude, codex, gemini, forge, or opencode (required)
   --help    Show this help message
 
 Examples:
   npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" > raw.txt
   npm run -s cli.run.parse -- --agent claude < raw.txt
 
+  npm run -s cli.run -- --model opencode --workFolder /tmp --prompt "hi" > raw.txt
+  npm run -s cli.run.parse -- --agent opencode < raw.txt
+
   # Or pipe directly
   npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" | npm run -s cli.run.parse -- --agent claude
 `;
@@ -56,7 +59,7 @@ async function main() {
     }
     const agent = args.agent;
     if (!agent || !AGENTS.includes(agent)) {
-        process.stderr.write(`Error: --agent is required (claude, codex, gemini, or forge)\n\n`);
+        process.stderr.write(`Error: --agent is required (claude, codex, gemini, forge, or opencode)\n\n`);
         process.stderr.write(USAGE);
         process.exit(1);
     }
@@ -79,6 +82,9 @@ async function main() {
         case 'forge':
             parsed = parseForgeOutput(input);
             break;
+        case 'opencode':
+            parsed = parseOpenCodeOutput(input);
+            break;
     }
     process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
 }