@tanstack/ai-opencode 0.1.0

package/src/adapters/projection.ts

@@ -0,0 +1,220 @@
+/**
+ * OpenCode workspace projector — mirrors the Claude Code reference
+ * implementation at `packages/ai-claude-code/src/adapters/projection.ts`.
+ *
+ * `withSandbox` surfaces a portable `WorkspaceProjection` (skills, plugins, a
+ * secret resolver, and a one-time marker path) via a capability. This adapter
+ * reads it in `chatStream` setup and projects workspace inputs into OpenCode's
+ * native format:
+ *
+ *   - MCP servers   → `opencode.json` at the workspace root (mcp section).
+ *                     Written on EVERY call (never marker-gated) so rotated
+ *                     secrets always re-apply.
+ *   - gitSkill repos → OpenCode has no recognised skills directory; we
+ *                      warn-and-skip rather than invent a path.
+ *   - agentSkill    → no bare-name primitive in opencode; warn-and-skip.
+ *   - plugins       → opencode has no `opencode plugin install` command;
+ *                     warn-and-skip.
+ *
+ * The `opencode.json` mcp-section shape mirrors the `OPENCODE_CONFIG_CONTENT`
+ * shape already used by the adapter's host-tool-bridge, ensuring both
+ * mechanisms use the same server-entry schema:
+ *
+ *   ```json
+ *   { "mcp": { "<name>": { "type": "remote", "url": "...", "enabled": true,
+ *                           "headers": { ... } } } }
+ *   ```
+ *
+ * OpenCode merges project-scoped `opencode.json` with its environment config,
+ * so the workspace file coexists safely with the runtime `OPENCODE_CONFIG_CONTENT`
+ * env written for the host-tool-bridge.
+ *
+ * External-convention caveat: the `opencode.json` location and the `remote`
+ * MCP-entry shape are derived from the adapter's existing `OPENCODE_CONFIG_CONTENT`
+ * usage. Where OpenCode has no clean primitive (gitSkill dir, agentSkill,
+ * plugins) we no-op with a warning instead of fabricating a command.
+ */
+import { isSecretRef, resolveGitSkillDir } from '@tanstack/ai-sandbox'
+import type {
+  BearerRef,
+  SandboxHandle,
+  SecretRef,
+  WorkspaceProjection,
+  WorkspaceSkill,
+} from '@tanstack/ai-sandbox'
+
+/** True when `value` is a `bearer(ref)` marker created by `@tanstack/ai-sandbox`. */
+function isBearerMarker(value: unknown): value is BearerRef {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    isSecretRef((value as { __bearerRef?: unknown }).__bearerRef)
+  )
+}
+
+/**
+ * Resolve a single MCP header value: a `SecretRef` resolves to its plaintext,
+ * a `bearer(ref)` marker resolves to `Bearer <plaintext>`, and a plain string
+ * is passed through unchanged.
+ */
+function resolveHeaderValue(
+  value: string | SecretRef | BearerRef,
+  resolveSecret: (ref: SecretRef) => string,
+): string {
+  if (isSecretRef(value)) return resolveSecret(value)
+  if (isBearerMarker(value)) return `Bearer ${resolveSecret(value.__bearerRef)}`
+  return value
+}
+
+/** An OpenCode `remote`-type MCP server entry (mirrors OPENCODE_CONFIG_CONTENT shape). */
+interface OpencodeMcpServer {
+  type: 'remote'
+  url: string
+  enabled: boolean
+  headers: Record<string, string>
+}
+
+/**
+ * Build the `mcp` section of OpenCode's `opencode.json` from the
+ * `{ kind: 'mcp' }` skills, resolving every header value (SecretRef / bearer
+ * / string). Returns `undefined` when there are no MCP skills so the caller
+ * can skip the write.
+ */
+function buildMcpSection(
+  skills: Array<WorkspaceSkill>,
+  resolveSecret: (ref: SecretRef) => string,
+): Record<string, OpencodeMcpServer> | undefined {
+  const mcp: Record<string, OpencodeMcpServer> = {}
+  let count = 0
+  for (const skill of skills) {
+    if (skill.kind !== 'mcp') continue
+    count += 1
+    const headers: Record<string, string> = {}
+    const rawHeaders = skill.config.headers ?? {}
+    for (const [name, value] of Object.entries(rawHeaders)) {
+      headers[name] = resolveHeaderValue(value, resolveSecret)
+    }
+    const rawUrl = skill.config['url']
+    const url = typeof rawUrl === 'string' ? rawUrl : ''
+    mcp[skill.name] = { type: 'remote', url, enabled: true, headers }
+  }
+  return count > 0 ? mcp : undefined
+}
+
+/**
+ * Write (or merge-update) `opencode.json` at the workspace root with the
+ * project-scoped MCP servers, re-resolving every secret. Runs on EVERY
+ * projection call (never marker-gated) so rotated secrets always re-apply.
+ *
+ * If `opencode.json` already exists (e.g. committed to the repo) we read it,
+ * merge only the `mcp` key, and rewrite, preserving other settings. When there
+ * are no MCP skills the write is skipped entirely.
+ */
+async function projectMcpServers(
+  handle: SandboxHandle,
+  projection: WorkspaceProjection,
+): Promise<void> {
+  const mcpSection = buildMcpSection(
+    projection.skills,
+    projection.resolveSecret,
+  )
+  if (mcpSection === undefined) return
+
+  const target = `${projection.root}/opencode.json`
+
+  // Read the existing file if present so we can preserve non-mcp settings.
+  let existing: Record<string, unknown> = {}
+  if (await handle.fs.exists(target)) {
+    try {
+      const raw = await handle.fs.read(target)
+      const parsed: unknown = JSON.parse(raw)
+      if (
+        typeof parsed === 'object' &&
+        parsed !== null &&
+        !Array.isArray(parsed)
+      ) {
+        existing = parsed as Record<string, unknown>
+      }
+    } catch {
+      // Unreadable or invalid JSON — start fresh so the MCP config lands cleanly.
+    }
+  }
+
+  const merged = { ...existing, mcp: mcpSection }
+  await handle.fs.write(target, JSON.stringify(merged, null, 2))
+}
+
+/**
+ * OpenCode has no recognised skills directory where we can drop gitSkill repos.
+ * AGENTS.md is already handled by the bootstrap layer (OpenCode reads it
+ * natively). We warn-and-skip instead of inventing a path.
+ */
+function projectGitSkills(projection: WorkspaceProjection): void {
+  for (const skill of projection.skills) {
+    if (skill.kind !== 'git') continue
+    const dir = skill.into ?? resolveGitSkillDir(projection.root, skill)
+    console.warn(
+      `[opencode] gitSkill "${skill.repo}" cloned to ${dir} but OpenCode has no ` +
+        'recognised skills directory to link it into. The skill is available at that ' +
+        'path — add an AGENTS.md reference to it manually if needed. Skipping.',
+    )
+  }
+}
+
+/**
+ * `agentSkill` references a public skill by bare name. OpenCode has no command
+ * to fetch a skill from a bare name, so we warn and skip.
+ */
+function projectAgentSkills(projection: WorkspaceProjection): void {
+  for (const skill of projection.skills) {
+    if (skill.kind !== 'agent-skill') continue
+    console.warn(
+      `[opencode] agentSkill "${skill.name}" cannot be projected: OpenCode has no ` +
+        'command to install a public skill by bare name. Provide it as a gitSkill ' +
+        'instead. Skipping.',
+    )
+  }
+}
+
+/**
+ * OpenCode has no plugin install command. We warn-and-skip each declared plugin
+ * rather than fabricating a command.
+ */
+function projectPlugins(projection: WorkspaceProjection): void {
+  for (const name of projection.plugins) {
+    console.warn(
+      `[opencode] plugin "${name}" cannot be installed: OpenCode has no plugin ` +
+        'install command. Skipping.',
+    )
+  }
+}
+
+/**
+ * Project a `WorkspaceProjection` into the OpenCode sandbox. Safe to call on
+ * every `chatStream`. The secret-bearing `opencode.json` mcp section is
+ * (re)written on every call, re-resolving secrets, so OpenCode always reads
+ * current values and a snapshot can never serve a stale or rotated secret.
+ * The safe, idempotent, non-secret operations (gitSkill, agentSkill, plugins
+ * — all warn-and-skip for OpenCode) are guarded by a one-time marker so they
+ * produce at most one warning per sandbox lifetime.
+ *
+ * @param handle     - The sandbox handle (`fs` + `process`).
+ * @param projection - The portable workspace inputs from `withSandbox`.
+ */
+export async function projectOpencodeWorkspace(
+  handle: SandboxHandle,
+  projection: WorkspaceProjection,
+): Promise<void> {
+  // Always re-resolve and rewrite the secret-bearing MCP config so rotated
+  // secrets re-apply and snapshots can't serve stale values.
+  await projectMcpServers(handle, projection)
+
+  // Gate only the safe, idempotent, non-secret operations on the marker.
+  if (await handle.fs.exists(projection.markerPath)) return
+
+  projectGitSkills(projection)
+  projectAgentSkills(projection)
+  projectPlugins(projection)
+
+  await handle.fs.write(projection.markerPath, '')
+}

package/src/adapters/text.ts

@@ -0,0 +1,368 @@
+import { EventType, normalizeSystemPrompts } from '@tanstack/ai'
+import { toRunErrorRawEvent } from '@tanstack/ai/adapter-internals'
+import { BaseTextAdapter } from '@tanstack/ai/adapters'
+import {
+  SandboxCapability,
+  buildApprovalRequestedEvent,
+  createBridgeEventChannel,
+  getSandbox,
+  getToolBridgeProvisioner,
+  getWorkspaceProjection,
+  mergeChunkStreams,
+  nodeHttpBridgeProvisioner,
+} from '@tanstack/ai-sandbox'
+import { buildPrompt } from '../messages/prompt'
+import { startOpencodeSession } from '../process/server'
+import { startOpencodeServerInSandbox } from '../process/sandbox-server'
+import { resolveInteractivePermission } from '../process/permissions'
+import { AsyncQueue } from '../stream/queue'
+import { translateOpencodeStream } from '../stream/translate'
+import { projectOpencodeWorkspace } from './projection'
+import type { HostToolBridge, SandboxHandle } from '@tanstack/ai-sandbox'
+import type {
+  StructuredOutputOptions,
+  StructuredOutputResult,
+} from '@tanstack/ai/adapters'
+import type {
+  DefaultMessageMetadataByModality,
+  Modality,
+  StreamChunk,
+  TextOptions,
+} from '@tanstack/ai'
+import type { OpencodeSessionHandle } from '../process/server'
+import type {
+  OpencodePermissionMode,
+  PermissionHandler,
+} from '../process/permissions'
+import type { OpencodeStreamEvent } from '../stream/sdk-types'
+import type { OpencodeModel } from '../model-meta'
+import type { OpencodeTextProviderOptions } from '../provider-options'
+
+const DEFAULT_WORKDIR = '/workspace'
+const DEFAULT_PORT = 4096
+
+export interface OpencodeTextConfig {
+  /** Working directory inside the sandbox. Defaults to `/workspace`. */
+  directory?: string
+  /**
+   * Port the in-sandbox `opencode serve` listens on. Defaults to 4096. For the
+   * Docker provider this port must also be published (`publishPorts: [4096]`)
+   * so the host can reach it.
+   */
+  port?: number
+  /** Hostname the in-sandbox server binds. Defaults to `0.0.0.0`. */
+  hostname?: string
+  /**
+   * OpenCode permission mode driving the dynamic permission handler. Defaults
+   * to `'default'`; set `'acceptEdits'` / `'bypassPermissions'` to let the
+   * harness edit files and run commands autonomously inside the sandbox.
+   */
+  permissionMode?: OpencodePermissionMode
+  /** Custom permission handler; replaces the adapter's default policy. */
+  onPermissionRequest?: PermissionHandler
+}
+
+/** Split a `provider/model` id into its provider and model halves. */
+function splitModel(model: string): { providerID: string; modelID: string } {
+  const slash = model.indexOf('/')
+  if (slash <= 0 || slash === model.length - 1) {
+    throw new Error(
+      `OpenCode models must be addressed as "provider/model" (e.g. "anthropic/claude-sonnet-4-5"); received "${model}".`,
+    )
+  }
+  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) }
+}
+
+export class OpencodeTextAdapter<
+  TModel extends OpencodeModel,
+> extends BaseTextAdapter<
+  TModel,
+  OpencodeTextProviderOptions,
+  ReadonlyArray<Modality> & readonly ['text'],
+  DefaultMessageMetadataByModality,
+  ReadonlyArray<string>,
+  unknown,
+  never
+> {
+  readonly name = 'opencode' as const
+
+  override readonly requires = [SandboxCapability] as const
+
+  private readonly adapterConfig: OpencodeTextConfig
+
+  constructor(config: OpencodeTextConfig, model: TModel) {
+    super({}, model)
+    this.adapterConfig = config
+  }
+
+  private sandboxFrom(
+    options: TextOptions<OpencodeTextProviderOptions>,
+  ): SandboxHandle {
+    const ctx = options.capabilities
+    if (!ctx) {
+      throw new Error(
+        'Adapter "opencode" requires a sandbox. Add withSandbox(defineSandbox({ ... })) to chat() middleware.',
+      )
+    }
+    return getSandbox(ctx)
+  }
+
+  private applySystemPrompts(
+    options: TextOptions<OpencodeTextProviderOptions>,
+    prompt: string,
+  ): string {
+    const systemPrompts = normalizeSystemPrompts(options.systemPrompts)
+      .map((systemPrompt) => systemPrompt.content)
+      .filter((content) => content.trim() !== '')
+    if (systemPrompts.length === 0) return prompt
+    return `${systemPrompts.join('\n\n')}\n\n${prompt}`
+  }
+
+  async *chatStream(
+    options: TextOptions<OpencodeTextProviderOptions>,
+  ): AsyncIterable<StreamChunk> {
+    const { logger } = options
+    let server:
+      | Awaited<ReturnType<typeof startOpencodeServerInSandbox>>
+      | undefined
+    let handle: OpencodeSessionHandle | undefined
+    let bridge: HostToolBridge | undefined
+    const externalSignal =
+      options.abortController?.signal ?? options.request?.signal ?? undefined
+    let onAbort: (() => void) | undefined
+    const runId = options.runId ?? this.generateId()
+    const threadId = options.threadId ?? this.generateId()
+    // Surfaces custom events from bridged tools (e.g. code mode console logs)
+    // on this run's live output stream.
+    const channel = createBridgeEventChannel({
+      model: this.model,
+      threadId,
+      runId,
+    })
+
+    try {
+      const sandbox = this.sandboxFrom(options)
+      const directory =
+        options.modelOptions?.directory ??
+        this.adapterConfig.directory ??
+        DEFAULT_WORKDIR
+
+      // Project workspace skills / MCP servers into the sandbox before starting
+      // the opencode server so the workspace config is in place for the session.
+      if (options.capabilities !== undefined) {
+        const projection = getWorkspaceProjection(options.capabilities, {
+          optional: true,
+        })
+        if (projection !== undefined) {
+          await projectOpencodeWorkspace(sandbox, projection)
+        }
+      }
+
+      const modelOptions = options.modelOptions
+      const sessionId = modelOptions?.sessionId
+      const { prompt: resumePrompt } = buildPrompt(options.messages, sessionId)
+      const { providerID, modelID } = splitModel(this.model)
+
+      // Bridge chat()-provided tools into the in-sandbox server over MCP
+      // (configured via OPENCODE_CONFIG_CONTENT at server spawn).
+      const bridgedToolNames = new Set(
+        (options.tools ?? []).map((tool) => tool.name),
+      )
+      if (options.tools && options.tools.length > 0) {
+        const provisioner =
+          (options.capabilities
+            ? getToolBridgeProvisioner(options.capabilities, { optional: true })
+            : undefined) ?? nodeHttpBridgeProvisioner
+        bridge = await provisioner.provision(options.tools, {
+          provider: sandbox.provider,
+          context: options.context,
+          emitCustomEvent: channel.emitCustomEvent,
+          ...(externalSignal ? { signal: externalSignal } : {}),
+        })
+      }
+
+      // Approval-requested events for `ask`-policy actions with no client
+      // decision yet, emitted after the stream so the client can approve + re-run.
+      const approvalRequests: Array<StreamChunk> = []
+
+      const queue = new AsyncQueue<OpencodeStreamEvent>()
+      const mode =
+        modelOptions?.permissionMode ??
+        this.adapterConfig.permissionMode ??
+        'default'
+      const permissionHandler: PermissionHandler =
+        this.adapterConfig.onPermissionRequest ??
+        ((request) => {
+          const result = resolveInteractivePermission(
+            request,
+            mode,
+            bridgedToolNames,
+            options.approvals,
+          )
+          if (result.approvalId !== undefined) {
+            approvalRequests.push(
+              buildApprovalRequestedEvent({
+                approvalId: result.approvalId,
+                title: result.title ?? request.title,
+                threadId,
+                runId,
+                detail: { provider: 'opencode' },
+              }),
+            )
+          }
+          return result.response
+        })
+
+      logger.request(
+        `activity=chat provider=opencode model=${this.model} sandbox=${sandbox.provider} messages=${options.messages.length} resume=${sessionId ?? 'none'}`,
+        { provider: 'opencode', model: this.model },
+      )
+
+      const serverEnv = bridge
+        ? {
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+              mcp: {
+                [bridge.name]: {
+                  type: 'remote',
+                  url: bridge.url,
+                  enabled: true,
+                  headers: { Authorization: `Bearer ${bridge.token}` },
+                },
+              },
+            }),
+          }
+        : undefined
+
+      server = await startOpencodeServerInSandbox(sandbox, {
+        port: this.adapterConfig.port ?? DEFAULT_PORT,
+        ...(this.adapterConfig.hostname !== undefined && {
+          hostname: this.adapterConfig.hostname,
+        }),
+        cwd: directory,
+        ...(serverEnv ? { env: serverEnv } : {}),
+        ...(externalSignal ? { signal: externalSignal } : {}),
+      })
+
+      handle = await startOpencodeSession({
+        baseUrl: server.baseUrl,
+        // Forward the channel's auth headers (e.g. Daytona's preview token) so
+        // the host client can reach a token-gated preview proxy.
+        ...(server.headers !== undefined && { headers: server.headers }),
+        // NOTE: do NOT pass `directory` here. `directory` is the VIRTUAL sandbox
+        // path (e.g. `/workspace`); the server is already spawned with that as its
+        // cwd (the provider handle maps it to the real workdir — `/workspace`
+        // inside Docker, a host temp dir for local-process). Forwarding the
+        // virtual path to the host-side opencode HTTP API breaks local-process,
+        // where `/workspace` doesn't exist → the API stalls until the request
+        // times out. Omitting it makes opencode use the server's (correct) cwd.
+        providerID,
+        modelID,
+        ...(sessionId !== undefined && { resumeSessionId: sessionId }),
+        onEvent: (event) => queue.push({ kind: 'event', event }),
+        onPermissionRequest: permissionHandler,
+        onError: (error) => queue.fail(error),
+      })
+      const session = handle
+
+      if (externalSignal !== undefined) {
+        onAbort = () => void session.abort().catch(() => undefined)
+        if (externalSignal.aborted) onAbort()
+        else externalSignal.addEventListener('abort', onAbort, { once: true })
+      }
+
+      queue.push({ kind: 'session', sessionId: session.sessionId })
+
+      const promptText = this.applySystemPrompts(
+        options,
+        session.resumed || sessionId === undefined
+          ? resumePrompt
+          : buildPrompt(options.messages, undefined).prompt,
+      )
+
+      session
+        .prompt(promptText)
+        .then(({ message }) => {
+          queue.push({ kind: 'done', message })
+          queue.end()
+        })
+        .catch((error: unknown) => queue.fail(error))
+
+      yield* mergeChunkStreams(
+        translateOpencodeStream(queue, {
+          model: this.model,
+          runId,
+          threadId,
+          ...(options.parentRunId !== undefined && {
+            parentRunId: options.parentRunId,
+          }),
+          genId: () => this.generateId(),
+          bridgedToolNames,
+          onStreamEvent: (event) =>
+            logger.provider(`provider=opencode kind=${event.kind}`, {
+              chunk: event,
+            }),
+        }),
+        channel.stream,
+      )
+
+      // Surface pending approval requests (ask-policy actions awaiting a client
+      // decision); the client approves and re-runs to continue.
+      for (const event of approvalRequests) yield event
+    } catch (error: unknown) {
+      const err = error as Error & { code?: string }
+      const rawEvent = toRunErrorRawEvent(error)
+      logger.errors('opencode.chatStream fatal', {
+        error,
+        source: 'opencode.chatStream',
+      })
+      yield {
+        type: EventType.RUN_ERROR,
+        model: options.model,
+        timestamp: Date.now(),
+        message: err.message || 'Unknown error occurred',
+        ...(err.code !== undefined && { code: err.code }),
+        ...(rawEvent !== undefined && { rawEvent }),
+        error: {
+          message: err.message || 'Unknown error occurred',
+          ...(err.code !== undefined && { code: err.code }),
+        },
+      }
+    } finally {
+      if (externalSignal !== undefined && onAbort !== undefined) {
+        externalSignal.removeEventListener('abort', onAbort)
+      }
+      channel.close()
+      await handle?.dispose()
+      await server?.dispose()
+      await bridge?.close()
+    }
+  }
+
+  structuredOutput(
+    _options: StructuredOutputOptions<OpencodeTextProviderOptions>,
+  ): Promise<StructuredOutputResult<unknown>> {
+    return Promise.reject(
+      new Error(
+        'Structured output is not yet supported by the in-sandbox OpenCode adapter. ' +
+          'Use a model adapter for structured output, or omit outputSchema.',
+      ),
+    )
+  }
+}
+
+/**
+ * Creates an OpenCode harness adapter that runs **inside a sandbox**.
+ *
+ * It declares `requires: [SandboxCapability]`, spawns `opencode serve` inside
+ * the sandbox provided by `withSandbox(...)`, exposes its port, and connects
+ * the `@opencode-ai/sdk` HTTP client to it. OpenCode owns the agent loop and
+ * executes its native tools against the sandbox workspace. The sandbox image
+ * must provide the `opencode` executable (Docker: also publish the server port
+ * via `publishPorts`). chat()-provided tools aren't bridged yet.
+ */
+export function opencodeText<TModel extends OpencodeModel>(
+  model: TModel,
+  config: OpencodeTextConfig = {},
+): OpencodeTextAdapter<TModel> {
+  return new OpencodeTextAdapter(config, model)
+}

package/src/index.ts

@@ -0,0 +1,40 @@
+export { OpencodeTextAdapter, opencodeText } from './adapters/text'
+export type { OpencodeTextConfig } from './adapters/text'
+export type { OpencodeTextProviderOptions } from './provider-options'
+export { OPENCODE_MODELS } from './model-meta'
+export type { OpencodeModel, KnownOpencodeModel } from './model-meta'
+export {
+  SESSION_ID_EVENT,
+  TODO_EVENT,
+  BRIDGED_MCP_SERVER_NAME,
+  translateOpencodeStream,
+  resolveToolName,
+} from './stream/translate'
+export type { TranslateContext } from './stream/translate'
+export type {
+  OpencodeAssistantMessage,
+  OpencodeEvent,
+  OpencodePart,
+  OpencodeStreamEvent,
+  OpencodeTokens,
+  OpencodeToolState,
+} from './stream/sdk-types'
+export { resolvePermission, matchBridgedToolName } from './process/permissions'
+export type {
+  OpencodePermissionMode,
+  OpencodePermissionRequest,
+  OpencodePermissionResponse,
+  PermissionHandler,
+} from './process/permissions'
+export { startOpencodeSession } from './process/server'
+export type {
+  OpencodeSessionHandle,
+  StartOpencodeSessionOptions,
+} from './process/server'
+export { buildPrompt } from './messages/prompt'
+export type { BuiltPrompt } from './messages/prompt'
+export { startOpencodeServerInSandbox } from './process/sandbox-server'
+export type {
+  SandboxOpencodeServer,
+  StartServerOptions,
+} from './process/sandbox-server'

package/src/messages/prompt.ts

@@ -0,0 +1,67 @@
+import type { ModelMessage } from '@tanstack/ai'
+
+export interface BuiltPrompt {
+  prompt: string
+  /** OpenCode session id to resume, when the caller threaded one through. */
+  resume?: string
+}
+
+function extractText(content: ModelMessage['content']): string {
+  if (content === null) return ''
+  if (typeof content === 'string') return content
+  return content
+    .map((part) =>
+      part.type === 'text' && typeof part.content === 'string'
+        ? part.content
+        : '',
+    )
+    .join('')
+}
+
+/**
+ * Convert TanStack chat history into the OpenCode prompt + resume inputs.
+ *
+ * With a `sessionId`, the harness already holds the conversation context, so
+ * only the trailing user message is sent and the session is resumed. Without
+ * one, prior turns are flattened into a plain-text transcript preamble (tool
+ * messages and tool-call-only assistant turns are harness-internal noise and
+ * are skipped; prompts are text-only in v1).
+ */
+export function buildPrompt(
+  messages: Array<ModelMessage>,
+  sessionId: string | undefined,
+): BuiltPrompt {
+  const lastMessage = messages.at(-1)
+  const lastUserText =
+    lastMessage?.role === 'user' ? extractText(lastMessage.content).trim() : ''
+
+  if (!lastUserText) {
+    throw new Error(
+      'OpenCode adapter requires a trailing user message with text content.',
+    )
+  }
+
+  if (sessionId !== undefined) {
+    return { prompt: lastUserText, resume: sessionId }
+  }
+
+  const priorTurns = messages
+    .slice(0, -1)
+    .filter(
+      (message) =>
+        (message.role === 'user' || message.role === 'assistant') &&
+        extractText(message.content).trim() !== '',
+    )
+    .map(
+      (message) =>
+        `${message.role === 'user' ? 'User' : 'Assistant'}: ${extractText(message.content).trim()}`,
+    )
+
+  if (priorTurns.length === 0) {
+    return { prompt: lastUserText }
+  }
+
+  return {
+    prompt: `Previous conversation:\n${priorTurns.join('\n')}\n\n${lastUserText}`,
+  }
+}