@vibe-forge/adapter-opencode 0.1.2

package/__tests__/session-runtime-config.spec.ts

@@ -0,0 +1,156 @@
+import { lstat } from 'node:fs/promises'
+import { execFile, spawn } from 'node:child_process'
+import { join } from 'node:path'
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { AdapterOutputEvent } from '@vibe-forge/core/adapter'
+
+import { createOpenCodeSession } from '#~/runtime/session.js'
+
+import {
+  createWorkspace,
+  flushAsyncWork,
+  makeCtx,
+  makeProc,
+  mockExecFileJsonResponses,
+  registerRuntimeTestHooks,
+  writeDocument
+} from './runtime-test-helpers'
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+  execFile: vi.fn()
+}))
+
+const spawnMock = vi.mocked(spawn)
+const execFileMock = vi.mocked(execFile)
+
+describe('createOpenCodeSession runtime config', () => {
+  registerRuntimeTestHooks()
+
+  it('uses the built-in plan agent when permission mode is plan', async () => {
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_plan', title: 'Vibe Forge:session-plan', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'planned\n' }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-plan',
+      permissionMode: 'plan',
+      description: 'Inspect only.',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toContain('plan')
+    expect(events[0]).toMatchObject({
+      type: 'init',
+      data: {
+        agents: ['plan']
+      }
+    })
+  })
+
+  it('applies default MCP include and exclude filters from config', async () => {
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_mcp', title: 'Vibe Forge:session-mcp-defaults', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'mcp\n' }))
+
+    const { ctx } = makeCtx({
+      configs: [{
+        mcpServers: {
+          docs: { command: 'npx', args: ['docs-server'] },
+          jira: { type: 'http', url: 'https://example.test/mcp' },
+          browser: { command: 'npx', args: ['browser-server'] }
+        },
+        defaultIncludeMcpServers: ['docs', 'jira'],
+        defaultExcludeMcpServers: ['jira']
+      }, undefined]
+    })
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-mcp-defaults',
+      description: 'list docs',
+      onEvent: () => {}
+    } as any)
+
+    await flushAsyncWork()
+
+    const spawnOptions = spawnMock.mock.calls[0]?.[2] as { env?: Record<string, string> }
+    const inlineConfig = JSON.parse(spawnOptions.env?.OPENCODE_CONFIG_CONTENT ?? '{}') as {
+      mcp?: Record<string, unknown>
+    }
+
+    expect(Object.keys(inlineConfig.mcp ?? {})).toEqual(['docs'])
+  })
+
+  it('filters nullish adapter env values before spawning opencode', async () => {
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_env', title: 'Vibe Forge:session-env', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'env\n' }))
+
+    const { ctx } = makeCtx({
+      env: {
+        KEEP_ME: 'yes',
+        DROP_ME: null,
+        DROP_ME_TOO: undefined
+      }
+    })
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-env',
+      description: 'env',
+      onEvent: () => {}
+    } as any)
+
+    await flushAsyncWork()
+
+    const childEnv = (spawnMock.mock.calls[0]?.[2] as { env?: Record<string, string> }).env ?? {}
+    expect(childEnv.KEEP_ME).toBe('yes')
+    expect('DROP_ME' in childEnv).toBe(false)
+    expect('DROP_ME_TOO' in childEnv).toBe(false)
+  })
+
+  it('bridges Vibe Forge skills into OPENCODE_CONFIG_DIR for the skill tool', async () => {
+    const workspace = await createWorkspace()
+    await writeDocument(join(workspace, '.ai/skills/research/SKILL.md'), '---\nname: research\ndescription: 检索资料\n---\n阅读 README.md')
+    await writeDocument(join(workspace, '.ai/skills/review/SKILL.md'), '---\nname: review\ndescription: 代码评审\n---\n检查风险')
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_skill', title: 'Vibe Forge:session-skill-bridge', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'skills\n' }))
+
+    const { ctx } = makeCtx({ cwd: workspace })
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-skill-bridge',
+      description: 'list skills',
+      skills: {
+        include: ['research'],
+        exclude: ['review']
+      },
+      onEvent: () => {}
+    } as any)
+
+    await flushAsyncWork()
+
+    const configDir = (spawnMock.mock.calls[0]?.[2] as { env?: Record<string, string> }).env?.OPENCODE_CONFIG_DIR
+    expect(typeof configDir).toBe('string')
+    expect((await lstat(join(configDir!, 'skills', 'research'))).isSymbolicLink()).toBe(true)
+    await expect(lstat(join(configDir!, 'skills', 'review'))).rejects.toThrow()
+  })
+})

package/__tests__/session-runtime-direct.spec.ts

@@ -0,0 +1,141 @@
+import { execFile, spawn } from 'node:child_process'
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { AdapterOutputEvent } from '@vibe-forge/core/adapter'
+
+import { createOpenCodeSession } from '#~/runtime/session.js'
+
+import {
+  flushAsyncWork,
+  makeCtx,
+  makeErrorProc,
+  makeProc,
+  mockExecFileJsonResponses,
+  registerRuntimeTestHooks
+} from './runtime-test-helpers'
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+  execFile: vi.fn()
+}))
+
+const spawnMock = vi.mocked(spawn)
+const execFileMock = vi.mocked(execFile)
+
+describe('createOpenCodeSession direct runtime', () => {
+  registerRuntimeTestHooks()
+
+  it('emits exit in direct mode after the child process finishes', async () => {
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_direct', title: 'Vibe Forge:session-direct', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ exitCode: 0 }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'cli',
+      mode: 'direct',
+      sessionId: 'session-direct',
+      description: 'say hi',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect((spawnMock.mock.calls[0]?.[2] as { stdio?: string }).stdio).toBe('inherit')
+    expect(events).toEqual([{ type: 'exit', data: { exitCode: 0 } }])
+  })
+
+  it('does not inject a placeholder prompt in direct mode when description is missing', async () => {
+    spawnMock.mockImplementation(() => makeProc({ exitCode: 0 }))
+
+    const { ctx } = makeCtx()
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'cli',
+      mode: 'direct',
+      sessionId: 'session-direct-empty',
+      onEvent: () => {}
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toEqual([
+      'run',
+      '--format',
+      'default',
+      '--title',
+      'Vibe Forge:session-direct-empty'
+    ])
+  })
+
+  it('emits exit in direct mode when the child process errors before launch', async () => {
+    spawnMock.mockImplementation(() => makeErrorProc(new Error('opencode missing')))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'cli',
+      mode: 'direct',
+      sessionId: 'session-direct-error',
+      description: 'say hi',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(events).toEqual([
+      expect.objectContaining({
+        type: 'error',
+        data: expect.objectContaining({
+          message: 'opencode missing',
+          fatal: true
+        })
+      }),
+      { type: 'exit', data: { exitCode: 1, stderr: 'opencode missing' } }
+    ])
+  })
+
+  it('resolves the latest session id before starting direct resume mode', async () => {
+    mockExecFileJsonResponses(execFileMock,
+      [{ id: 'sess_latest', title: 'Vibe Forge:session-direct-resume', updatedAt: '2026-03-26T00:00:00.000Z' }],
+      [{ id: 'sess_latest', title: 'Vibe Forge:session-direct-resume', updatedAt: '2026-03-26T00:00:01.000Z' }]
+    )
+    spawnMock.mockImplementation(() => makeProc({ exitCode: 0 }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx, cacheStore } = makeCtx({
+      cacheSeed: {
+        'adapter.opencode.session': {
+          opencodeSessionId: 'sess_stale',
+          title: 'Vibe Forge:session-direct-resume'
+        }
+      }
+    })
+
+    await createOpenCodeSession(ctx, {
+      type: 'resume',
+      runtime: 'cli',
+      mode: 'direct',
+      sessionId: 'session-direct-resume',
+      description: 'continue',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toContain('sess_latest')
+    expect(spawnMock.mock.calls[0]?.[1]).not.toContain('sess_stale')
+    expect(cacheStore.get('adapter.opencode.session')).toMatchObject({
+      opencodeSessionId: 'sess_latest',
+      title: 'Vibe Forge:session-direct-resume'
+    })
+    expect(events).toEqual([{ type: 'exit', data: { exitCode: 0 } }])
+  })
+})

package/__tests__/session-runtime-stream.spec.ts

@@ -0,0 +1,181 @@
+import { execFile, spawn } from 'node:child_process'
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { AdapterOutputEvent } from '@vibe-forge/core/adapter'
+
+import { createOpenCodeSession } from '#~/runtime/session.js'
+
+import {
+  flushAsyncWork,
+  makeCtx,
+  makeErrorProc,
+  makeProc,
+  mockExecFileJsonResponses,
+  registerRuntimeTestHooks
+} from './runtime-test-helpers'
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+  execFile: vi.fn()
+}))
+
+const spawnMock = vi.mocked(spawn)
+const execFileMock = vi.mocked(execFile)
+
+describe('createOpenCodeSession stream runtime', () => {
+  registerRuntimeTestHooks()
+
+  it('emits init, message, and stop for a successful stream turn', async () => {
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_1', title: 'Vibe Forge:session-1', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'pong\n' }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx, cacheStore } = makeCtx()
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-1',
+      description: 'Reply with exactly pong.',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toEqual([
+      'run', '--format', 'default', '--title', 'Vibe Forge:session-1', 'Reply with exactly pong.'
+    ])
+    expect(events.map(event => event.type)).toEqual(['init', 'message', 'stop'])
+    expect(events[1]).toMatchObject({ type: 'message', data: { role: 'assistant', content: 'pong' } })
+    expect(cacheStore.get('adapter.opencode.session')).toMatchObject({
+      opencodeSessionId: 'sess_1',
+      title: 'Vibe Forge:session-1'
+    })
+  })
+
+  it('reuses the cached OpenCode session id for later turns', async () => {
+    mockExecFileJsonResponses(execFileMock,
+      [{ id: 'sess_1', title: 'Vibe Forge:session-stream', updatedAt: '2026-03-26T00:00:00.000Z' }],
+      [{ id: 'sess_1', title: 'Vibe Forge:session-stream', updatedAt: '2026-03-26T00:01:00.000Z' }]
+    )
+    spawnMock
+      .mockImplementationOnce(() => makeProc({ stdout: 'first\n' }))
+      .mockImplementationOnce(() => makeProc({ stdout: 'second\n' }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+    const session = await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-stream',
+      description: 'first',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+    session.emit({ type: 'message', content: [{ type: 'text', text: 'second' }] })
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toContain('--title')
+    expect(spawnMock.mock.calls[1]?.[1]).toContain('--session')
+    expect(spawnMock.mock.calls[1]?.[1]).toContain('sess_1')
+    expect(events.filter(event => event.type === 'message')).toHaveLength(2)
+  })
+
+  it('does not start a turn until a message arrives when create has no description', async () => {
+    spawnMock.mockImplementation(() => makeProc({ stdout: 'later\n' }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+    const session = await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-empty-create',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+    expect(spawnMock).not.toHaveBeenCalled()
+    expect(events).toEqual([expect.objectContaining({ type: 'init' })])
+
+    mockExecFileJsonResponses(execFileMock, [
+      { id: 'sess_later', title: 'Vibe Forge:session-empty-create', updatedAt: '2026-03-26T00:00:00.000Z' }
+    ])
+    session.emit({ type: 'message', content: [{ type: 'text', text: 'later' }] })
+
+    await flushAsyncWork()
+    expect(spawnMock).toHaveBeenCalledTimes(1)
+    expect(spawnMock.mock.calls[0]?.[1]).toContain('later')
+  })
+
+  it('retries without the cached session id when resume hits a missing session', async () => {
+    mockExecFileJsonResponses(execFileMock,
+      [{ id: 'sess_new', title: 'Vibe Forge:session-resume', updatedAt: '2026-03-26T00:00:00.000Z' }],
+      [{ id: 'sess_new', title: 'Vibe Forge:session-resume', updatedAt: '2026-03-26T00:00:01.000Z' }]
+    )
+    spawnMock
+      .mockImplementationOnce(() => makeProc({ stderr: 'Error: session not found\n', exitCode: 1 }))
+      .mockImplementationOnce(() => makeProc({ stdout: 'recovered\n' }))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx, cacheStore } = makeCtx({
+      cacheSeed: {
+        'adapter.opencode.session': {
+          opencodeSessionId: 'sess_missing',
+          title: 'Vibe Forge:session-resume'
+        }
+      }
+    })
+
+    await createOpenCodeSession(ctx, {
+      type: 'resume',
+      runtime: 'server',
+      sessionId: 'session-resume',
+      description: 'continue',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(spawnMock.mock.calls[0]?.[1]).toContain('sess_missing')
+    expect(spawnMock.mock.calls[1]?.[1]).toContain('sess_new')
+    expect(events.some(event => event.type === 'exit')).toBe(false)
+    expect(events.some(event => event.type === 'stop')).toBe(true)
+    expect(cacheStore.get('adapter.opencode.session')).toMatchObject({
+      opencodeSessionId: 'sess_new',
+      title: 'Vibe Forge:session-resume'
+    })
+  })
+
+  it('emits exit when a stream turn fails before the child process starts cleanly', async () => {
+    spawnMock.mockImplementation(() => makeErrorProc(new Error('spawn failed')))
+
+    const events: AdapterOutputEvent[] = []
+    const { ctx } = makeCtx()
+
+    await createOpenCodeSession(ctx, {
+      type: 'create',
+      runtime: 'server',
+      sessionId: 'session-stream-error',
+      description: 'hello',
+      onEvent: (event: AdapterOutputEvent) => events.push(event)
+    } as any)
+
+    await flushAsyncWork()
+
+    expect(events).toEqual([
+      expect.objectContaining({ type: 'init' }),
+      expect.objectContaining({
+        type: 'error',
+        data: expect.objectContaining({
+          message: 'spawn failed',
+          fatal: true
+        })
+      }),
+      { type: 'exit', data: { exitCode: 1, stderr: 'spawn failed' } }
+    ])
+  })
+})

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@vibe-forge/adapter-opencode",
+  "version": "0.1.2",
+  "description": "OpenCode Adapter for Vibe Forge",
+  "imports": {
+    "#~/*.js": {
+      "__vibe-forge__": {
+        "default": "./src/*.ts"
+      },
+      "default": {
+        "import": "./dist/*.mjs",
+        "require": "./dist/*.js"
+      }
+    }
+  },
+  "exports": {
+    ".": {
+      "__vibe-forge__": {
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "import": "./dist/index.mjs",
+        "require": "./dist/index.js"
+      }
+    },
+    "./schema": {
+      "__vibe-forge__": {
+        "default": "./src/schema.ts"
+      },
+      "default": {
+        "import": "./dist/schema.mjs",
+        "require": "./dist/schema.js"
+      }
+    },
+    "./models": {
+      "__vibe-forge__": {
+        "default": "./src/models.ts"
+      },
+      "default": {
+        "import": "./dist/models.mjs",
+        "require": "./dist/models.js"
+      }
+    },
+    "./icon": {
+      "__vibe-forge__": {
+        "default": "./src/icon.ts"
+      },
+      "default": {
+        "import": "./dist/icon.mjs",
+        "require": "./dist/icon.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "opencode-ai": "1.3.2",
+    "@vibe-forge/core": "^0.7.3"
+  }
+}

package/src/AGENTS.md

@@ -0,0 +1,38 @@
+# `src` 目录说明
+
+## 入口层
+
+- `index.ts`：adapter 包对外入口，只负责导出 `init` / `query` 能力
+- `init.ts`：初始化阶段逻辑；只放启动前检查或一次性准备，不混入会话执行分支
+- `paths.ts`：CLI binary 路径解析
+- `models.ts` / `icon.ts` / `schema.ts`：展示或元数据层，不承载运行时逻辑
+- `adapter-config.ts`：adapter 自身配置 schema 和类型
+
+## Runtime 分层
+
+- `runtime/common/`：纯映射层
+- 负责 prompt、tools、permissions、model、mcp、inline config、session list parsing
+- 不直接读写文件系统，不启动子进程，不维护会话状态
+
+- `runtime/session/`：执行层
+- 负责 child env、skill bridge、OpenCode 进程启动、direct/stream 会话控制、错误传播
+- 可以依赖 `runtime/common/`，反向依赖不允许出现
+
+- `runtime/common.ts` / `runtime/session.ts`
+- 仅作为稳定入口和 re-export 路由
+- 新逻辑不要继续堆回这两个文件
+
+## 依赖方向
+
+- `src/*` 可以依赖 `runtime/*` 吗：不建议。公共入口只做装配。
+- `runtime/session/*` 可以依赖 `runtime/common/*`
+- `runtime/common/*` 不应依赖 `runtime/session/*`
+- 测试 helper 只能放在 `__tests__/runtime-test-helpers.ts`，不要从 `src` 反向引用测试代码
+
+## 修改约束
+
+- 单文件保持在 200 行以内；接近 160 行就优先继续拆模块
+- 新增参数适配时，先判断它属于“映射层”还是“执行层”，不要跨层散落
+- 涉及 OpenCode CLI 参数、env、session resume 语义的改动，至少补一条 runtime 回归测试
+- 涉及 permissions / tools / model / mcp 映射的改动，至少补一条 common 回归测试
+- 若新增目录，先在本文件补一句职责说明，再落代码

package/src/adapter-config.ts

@@ -0,0 +1,21 @@
+export {}
+
+declare module '@vibe-forge/core' {
+  interface Cache {
+    'adapter.opencode.session': {
+      opencodeSessionId?: string
+      title?: string
+    }
+  }
+
+  interface AdapterMap {
+    opencode: {
+      agent?: string
+      planAgent?: string | false
+      titlePrefix?: string
+      share?: boolean
+      sessionListMaxCount?: number
+      configContent?: Record<string, unknown>
+    }
+  }
+}

package/src/icon.ts

@@ -0,0 +1,17 @@
+const OPENCODE_ICON_SVG = `
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg">
+  <rect width="24" height="24" rx="6" fill="#0F172A"></rect>
+  <path d="M12 3.25 4.75 7.5v9L12 20.75l7.25-4.25v-9L12 3.25Zm0 2.06 5.5 3.22-5.5 3.22-5.5-3.22L12 5.31Zm-6 4.97 5 2.93v5.46l-5-2.93v-5.4Zm7 8.39v-5.46l5-2.93v5.4l-5 2.99Z" fill="url(#opencode-fill)"></path>
+  <defs>
+    <linearGradient id="opencode-fill" x1="4.75" x2="19.25" y1="3.25" y2="20.75" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#34D399"></stop>
+      <stop offset=".55" stop-color="#22C55E"></stop>
+      <stop offset="1" stop-color="#14B8A6"></stop>
+    </linearGradient>
+  </defs>
+</svg>
+`
+  .trim()
+
+export const adapterIcon = `data:image/svg+xml;utf8,${encodeURIComponent(OPENCODE_ICON_SVG)}`
+export const adapterDisplayName = 'OpenCode'

package/src/index.ts

@@ -0,0 +1,11 @@
+import './adapter-config'
+
+import { defineAdapter } from '@vibe-forge/core/adapter'
+
+import { initOpenCodeAdapter } from './runtime/init'
+import { createOpenCodeSession } from './runtime/session'
+
+export default defineAdapter({
+  init: initOpenCodeAdapter,
+  query: createOpenCodeSession
+})

package/src/models.ts

@@ -0,0 +1,24 @@
+import type { AdapterBuiltinModel } from '@vibe-forge/core'
+
+export const builtinModels: AdapterBuiltinModel[] = [
+  {
+    value: 'default',
+    title: 'default',
+    description: 'Use OpenCode\'s configured default model'
+  },
+  {
+    value: 'openai/gpt-5',
+    title: 'openai/gpt-5',
+    description: 'OpenAI GPT-5 via the OpenAI provider'
+  },
+  {
+    value: 'anthropic/claude-sonnet-4-5',
+    title: 'anthropic/claude-sonnet-4-5',
+    description: 'Anthropic Claude Sonnet 4.5 via the Anthropic provider'
+  },
+  {
+    value: 'anthropic/claude-haiku-4-5',
+    title: 'anthropic/claude-haiku-4-5',
+    description: 'Anthropic Claude Haiku 4.5 via the Anthropic provider'
+  }
+]

package/src/paths.ts

@@ -0,0 +1,30 @@
+import { existsSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, resolve } from 'node:path'
+
+import type { AdapterCtx } from '@vibe-forge/core/adapter'
+
+const require = createRequire(import.meta.url ?? __filename)
+const adapterPackageDir = dirname(require.resolve('@vibe-forge/adapter-opencode/package.json'))
+
+export const toRealPath = (targetPath: string) => {
+  try {
+    return realpathSync(targetPath)
+  } catch {
+    return targetPath
+  }
+}
+
+export const resolveOpenCodeBinaryPath = (env: AdapterCtx['env']): string => {
+  const envPath = env.__VF_PROJECT_AI_ADAPTER_OPENCODE_CLI_PATH__
+  if (typeof envPath === 'string' && envPath.trim() !== '') {
+    return envPath
+  }
+
+  const bundledPath = resolve(adapterPackageDir, 'node_modules/.bin/opencode')
+  if (existsSync(bundledPath)) {
+    return toRealPath(bundledPath)
+  }
+
+  return 'opencode'
+}