ai-cli-mcp 2.14.1 → 2.15.0

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

@@ -26,9 +26,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:
@@ -92,7 +92,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/src/app/mcp.ts

@@ -8,7 +8,7 @@ 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 { ProcessService } from '../process-service.js';
 
@@ -73,6 +73,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 +83,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 +96,7 @@ export class ClaudeCodeServer {
         codex: this.codexCliPath,
         gemini: this.geminiCliPath,
         forge: this.forgeCliPath,
+        opencode: this.opencodeCliPath,
       },
     });
 
@@ -123,7 +127,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 +171,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/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,7 +217,6 @@ 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'];
@@ -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'];

package/src/cli-parse.ts

@@ -1,21 +1,24 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
 
-const AGENTS = ['claude', 'codex', 'gemini', 'forge'] as const;
+const AGENTS = ['claude', 'codex', 'gemini', 'forge', 'opencode'] as const;
 type Agent = typeof AGENTS[number];
 
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
+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
 `;
@@ -62,7 +65,7 @@ async function main(): Promise<void> {
 
   const agent = args.agent as 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);
   }
@@ -88,6 +91,9 @@ async function main(): Promise<void> {
     case 'forge':
       parsed = parseForgeOutput(input);
       break;
+    case 'opencode':
+      parsed = parseOpenCodeOutput(input);
+      break;
   }
 
   process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');