ai-cli-mcp 2.14.0 → 2.15.0

package/src/__tests__/mcp-contract.test.ts

@@ -3,6 +3,7 @@ import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { cleanupSharedMock, getSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 import { createTestClient, MCPTestClient } from './utils/mcp-client.js';
 
 function parseToolJson(content: any): any {
@@ -109,6 +110,13 @@ describe('MCP Contract Tests', () => {
       'session_id',
       'workFolder',
     ]);
+    expect(runTool.description).toContain('OpenCode');
+    expect(runTool.inputSchema.properties.model.description).toContain('opencode');
+    expect(runTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+    expect(runTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode do not support reasoning_effort');
+    expect(runTool.inputSchema.properties.session_id.description).toBe(
+      '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.'
+    );
 
     const getResultTool = tools.find((tool: any) => tool.name === 'get_result');
     expect(getResultTool.inputSchema.required).toEqual(['pid']);
@@ -470,6 +478,177 @@ printf '%s\n' '{"type":"system","session_id":"session-verbose-1"}'
     ).rejects.toThrow(/reasoning_effort is not supported for forge/i);
   });
 
+  it('covers OpenCode end-to-end through the MCP process path', async () => {
+    await client.disconnect();
+
+    const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+    const { scriptPath: openCodeMockPath } = createOpenCodeMock(testDir, {
+      argsLogPath: opencodeArgsLogPath,
+      defaultSessionId: 'ses-opencode-contract',
+    });
+
+    client = createTestClient({
+      debug: false,
+      env: {
+        OPENCODE_CLI_NAME: openCodeMockPath,
+      },
+    });
+    await client.connect();
+
+    const initialRunResponse = await client.callTool('run', {
+      prompt: 'opencode-initial-prompt',
+      workFolder: testDir,
+      model: 'opencode',
+    });
+    const initialRunData = parseToolJson(initialRunResponse);
+
+    expect(initialRunData).toEqual({
+      pid: expect.any(Number),
+      status: 'started',
+      agent: 'opencode',
+      message: expect.any(String),
+    });
+
+    const initialWaitResponse = await client.callTool('wait', { pids: [initialRunData.pid], timeout: 5 });
+    const initialWaitData = parseToolJson(initialWaitResponse);
+
+    expect(initialWaitData).toHaveLength(1);
+    expect(initialWaitData[0]).toMatchObject({
+      pid: initialRunData.pid,
+      agent: 'opencode',
+      status: 'completed',
+      exitCode: 0,
+      model: 'opencode',
+      session_id: 'ses-opencode-contract',
+      agentOutput: {
+        message: 'Initial: opencode-initial-prompt',
+        session_id: 'ses-opencode-contract',
+        tokens: { total: 11833 },
+        cost: 0,
+      },
+    });
+
+    const resumedDefaultRunResponse = await client.callTool('run', {
+      prompt: 'opencode-resume-default',
+      workFolder: testDir,
+      model: 'opencode',
+      session_id: 'ses-opencode-contract',
+    });
+    const resumedDefaultRunData = parseToolJson(resumedDefaultRunResponse);
+
+    const resumedDefaultWaitResponse = await client.callTool('wait', { pids: [resumedDefaultRunData.pid], timeout: 5 });
+    const resumedDefaultWaitData = parseToolJson(resumedDefaultWaitResponse);
+
+    expect(resumedDefaultWaitData).toHaveLength(1);
+    expect(resumedDefaultWaitData[0]).toMatchObject({
+      pid: resumedDefaultRunData.pid,
+      agent: 'opencode',
+      status: 'completed',
+      exitCode: 0,
+      model: 'opencode',
+      session_id: 'ses-opencode-contract',
+      agentOutput: {
+        message: 'Resumed: opencode-resume-default',
+        session_id: 'ses-opencode-contract',
+        tokens: { total: 11833 },
+        cost: 0,
+      },
+    });
+
+    const resumedExplicitRunResponse = await client.callTool('run', {
+      prompt: 'opencode-resume-explicit',
+      workFolder: testDir,
+      model: 'oc-openai/gpt-5.4',
+      session_id: 'ses-opencode-contract',
+    });
+    const resumedExplicitRunData = parseToolJson(resumedExplicitRunResponse);
+
+    const resumedExplicitWaitResponse = await client.callTool('wait', { pids: [resumedExplicitRunData.pid], timeout: 5 });
+    const resumedExplicitWaitData = parseToolJson(resumedExplicitWaitResponse);
+
+    expect(resumedExplicitWaitData).toHaveLength(1);
+    expect(resumedExplicitWaitData[0]).toMatchObject({
+      pid: resumedExplicitRunData.pid,
+      agent: 'opencode',
+      status: 'completed',
+      exitCode: 0,
+      model: 'oc-openai/gpt-5.4',
+      session_id: 'ses-opencode-contract',
+      agentOutput: {
+        message: 'Resumed model openai/gpt-5.4: opencode-resume-explicit',
+        session_id: 'ses-opencode-contract',
+        tokens: { total: 11833 },
+        cost: 0,
+      },
+    });
+
+    const failedRunResponse = await client.callTool('run', {
+      prompt: 'please fail',
+      workFolder: testDir,
+      model: 'oc-openai/gpt-5.4',
+    });
+    const failedRunData = parseToolJson(failedRunResponse);
+
+    const compactFailedWait = parseToolJson(await client.callTool('wait', { pids: [failedRunData.pid], timeout: 5 }));
+    expect(compactFailedWait).toHaveLength(1);
+    expect(compactFailedWait[0]).toMatchObject({
+      pid: failedRunData.pid,
+      agent: 'opencode',
+      status: 'failed',
+      exitCode: 7,
+      model: 'oc-openai/gpt-5.4',
+      session_id: 'ses-opencode-contract',
+      stdout: expect.stringContaining('Partial failure output'),
+      stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+    });
+    expect(compactFailedWait[0]).not.toHaveProperty('agentOutput');
+
+    const verboseFailedResult = parseToolJson(await client.callTool('get_result', { pid: failedRunData.pid, verbose: true }));
+    expect(verboseFailedResult).toMatchObject({
+      pid: failedRunData.pid,
+      agent: 'opencode',
+      status: 'failed',
+      exitCode: 7,
+      model: 'oc-openai/gpt-5.4',
+      session_id: 'ses-opencode-contract',
+      stdout: expect.stringContaining('Partial failure output'),
+      stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+      agentOutput: {
+        message: 'Partial failure output',
+        session_id: 'ses-opencode-contract',
+        tokens: { total: 42 },
+        cost: 0,
+      },
+    });
+
+    const openCodeInvocations = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+    expect(openCodeInvocations).toHaveLength(4);
+    expect(openCodeInvocations[0]).toContain('run --format json');
+    expect(openCodeInvocations[0]).toContain(`--dir ${testDir}`);
+    expect(openCodeInvocations[0]).not.toContain('--session');
+    expect(openCodeInvocations[0]).not.toContain('--model');
+
+    expect(openCodeInvocations[1]).toContain(`--dir ${testDir}`);
+    expect(openCodeInvocations[1]).toContain('--session ses-opencode-contract');
+    expect(openCodeInvocations[1]).not.toContain('--model');
+
+    expect(openCodeInvocations[2]).toContain(`--dir ${testDir}`);
+    expect(openCodeInvocations[2]).toContain('--session ses-opencode-contract');
+    expect(openCodeInvocations[2]).toContain('--model openai/gpt-5.4');
+
+    expect(openCodeInvocations[3]).toContain(`--dir ${testDir}`);
+    expect(openCodeInvocations[3]).toContain('--model openai/gpt-5.4');
+
+    await expect(
+      client.callTool('run', {
+        prompt: 'opencode-invalid-reasoning',
+        workFolder: testDir,
+        model: 'opencode',
+        reasoning_effort: 'high',
+      })
+    ).rejects.toThrow(/reasoning_effort is not supported for opencode/i);
+  });
+
   it('keeps key invalid-input errors stable', async () => {
     await expect(
       client.callTool('run', {

package/src/__tests__/parsers.test.ts

@@ -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', () => {
@@ -149,3 +149,75 @@ 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/src/__tests__/process-management.test.ts

@@ -68,7 +68,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(this: any) {
       mockServerInstance = {
         setRequestHandler: vi.fn((schema: any, handler: Function) => {
           handlers.set(schema.name, handler);

package/src/__tests__/server.test.ts

@@ -201,6 +201,41 @@ describe('ClaudeCodeServer Unit Tests', () => {
     });
   });
 
+  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: any;
     
@@ -333,29 +368,29 @@ describe('ClaudeCodeServer Unit Tests', () => {
       );
     });
 
-    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: any) {
-        this.setRequestHandler = mockSetRequestHandler;
+        this.setRequestHandler = vi.fn();
         this.connect = vi.fn();
         this.close = vi.fn();
         this.onerror = undefined;
         return this;
       });
-      
+
       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');
       mockExistsSync.mockReturnValue(true);

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

@@ -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'],