ai-cli-mcp 2.14.1 → 2.15.0

package/src/__tests__/e2e.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createTestClient, MCPTestClient } from './utils/mcp-client.js';
 import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 
 describe('Claude Code MCP E2E Tests', () => {
   let client: MCPTestClient;
@@ -40,40 +41,10 @@ describe('Claude Code MCP E2E Tests', () => {
       
       expect(tools).toHaveLength(6);
       const claudeCodeTool = tools.find((t: any) => t.name === 'run');
-      expect(claudeCodeTool).toEqual({
-        name: 'run',
-        description: expect.stringContaining('AI Agent Runner'),
-        inputSchema: {
-          type: 'object',
-          properties: {
-            prompt: {
-              type: 'string',
-              description: expect.stringContaining('Either this or prompt_file is required'),
-            },
-            prompt_file: {
-              type: 'string',
-              description: expect.stringContaining('Path to a file containing the prompt'),
-            },
-            workFolder: {
-              type: 'string',
-              description: expect.stringContaining('working directory'),
-            },
-            model: {
-              type: 'string',
-              description: expect.stringContaining('sonnet'),
-            },
-            reasoning_effort: {
-              type: 'string',
-              description: expect.stringContaining('model_reasoning_effort'),
-            },
-            session_id: {
-              type: 'string',
-              description: expect.stringContaining('session ID'),
-            },
-          },
-          required: ['workFolder'],
-        },
-      });
+      expect(claudeCodeTool.inputSchema.properties.model.description).toContain('sonnet');
+      expect(claudeCodeTool.inputSchema.properties.model.description).toContain('opencode');
+      expect(claudeCodeTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+      expect(claudeCodeTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode');
       
       // Verify other tools exist
       expect(tools.some((t: any) => t.name === 'list_processes')).toBe(true);
@@ -219,6 +190,78 @@ describe('Claude Code MCP E2E Tests', () => {
     });
   });
 
+  describe('OpenCode flows', () => {
+    it('should execute and resume OpenCode runs through the MCP client', async () => {
+      await client.disconnect();
+
+      const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+      const { scriptPath } = createOpenCodeMock(testDir, {
+        argsLogPath: opencodeArgsLogPath,
+        defaultSessionId: 'ses-opencode-e2e',
+      });
+
+      client = createTestClient({
+        debug: false,
+        env: {
+          OPENCODE_CLI_NAME: scriptPath,
+        },
+      });
+      await client.connect();
+
+      const runResponse = await client.callTool('run', {
+        prompt: 'e2e OpenCode initial prompt',
+        workFolder: testDir,
+        model: 'opencode',
+      });
+      const runData = JSON.parse(runResponse[0].text);
+      expect(runData.agent).toBe('opencode');
+
+      const initialWait = JSON.parse((await client.callTool('wait', { pids: [runData.pid], timeout: 5 }))[0].text);
+      expect(initialWait).toHaveLength(1);
+      expect(initialWait[0]).toMatchObject({
+        pid: runData.pid,
+        agent: 'opencode',
+        status: 'completed',
+        exitCode: 0,
+        model: 'opencode',
+        session_id: 'ses-opencode-e2e',
+        agentOutput: {
+          message: 'Initial: e2e OpenCode initial prompt',
+          session_id: 'ses-opencode-e2e',
+        },
+      });
+
+      const resumedResponse = await client.callTool('run', {
+        prompt: 'e2e OpenCode resumed prompt',
+        workFolder: testDir,
+        model: 'oc-openai/gpt-5.4',
+        session_id: 'ses-opencode-e2e',
+      });
+      const resumedRunData = JSON.parse(resumedResponse[0].text);
+
+      const resumedWait = JSON.parse((await client.callTool('wait', { pids: [resumedRunData.pid], timeout: 5 }))[0].text);
+      expect(resumedWait).toHaveLength(1);
+      expect(resumedWait[0]).toMatchObject({
+        pid: resumedRunData.pid,
+        agent: 'opencode',
+        status: 'completed',
+        exitCode: 0,
+        model: 'oc-openai/gpt-5.4',
+        session_id: 'ses-opencode-e2e',
+        agentOutput: {
+          message: 'Resumed model openai/gpt-5.4: e2e OpenCode resumed prompt',
+          session_id: 'ses-opencode-e2e',
+        },
+      });
+
+      const invocationLog = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+      expect(invocationLog[0]).toContain(`--dir ${testDir}`);
+      expect(invocationLog[0]).not.toContain('--model');
+      expect(invocationLog[1]).toContain('--session ses-opencode-e2e');
+      expect(invocationLog[1]).toContain('--model openai/gpt-5.4');
+    });
+  });
+
   describe('Debug Mode', () => {
     it('should log debug information when enabled', async () => {
       // Debug logs go to stderr, which we capture in the client
@@ -250,30 +293,18 @@ describe('Integration Tests (Local Only)', () => {
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  // These tests will only run locally when Claude is available
-  it.skip('should create a file with real Claude CLI', async () => {
+  // This smoke test only verifies that a real Claude CLI can be invoked.
+  it.skip('should invoke the real Claude CLI', async () => {
     await client.connect();
-    
-    const response = await client.callTool('run', {
-      prompt: 'Create a file called hello.txt with content "Hello from Claude"',
-      workFolder: testDir,
-    });
 
-    const filePath = join(testDir, 'hello.txt');
-    expect(existsSync(filePath)).toBe(true);
-    expect(readFileSync(filePath, 'utf-8')).toContain('Hello from Claude');
-  });
-
-  it.skip('should handle git operations with real Claude CLI', async () => {
-    await client.connect();
-    
-    // Initialize git repo
     const response = await client.callTool('run', {
-      prompt: 'Initialize a git repository and create a README.md file',
+      prompt: 'Reply with hi',
       workFolder: testDir,
     });
 
-    expect(existsSync(join(testDir, '.git'))).toBe(true);
-    expect(existsSync(join(testDir, 'README.md'))).toBe(true);
+    expect(response).toEqual([{
+      type: 'text',
+      text: expect.stringContaining('pid'),
+    }]);
   });
 });

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 };
+}