@obtoai/agent-bridge 0.1.0-beta.3 → 0.1.0-beta.5

package/README.md

@@ -1,8 +1,8 @@
 # @obtoai/agent-bridge
 
-A local daemon that lets a coding agent — [Claude Code](https://claude.ai/code) or [OpenAI Codex](https://developers.openai.com/codex) — running on your machine be driven from the [OBTO Agent Bridge](https://obto.co) web UI, even when you're away from the keyboard.
+A local daemon that lets coding agents — [Claude Code](https://claude.ai/code), [OpenAI Codex](https://developers.openai.com/codex), or [opencode](https://opencode.ai) — running on your machine be driven from the [OBTO Agent Bridge](https://obto.co) web UI, even when you're away from the keyboard.
 
-You post a message on a thread from your phone or laptop. The daemon (running on your machine, no port forwarding required) receives it over a long-lived HTTPS stream, spawns or resumes an agent session in your project directory, and the response posts back to the bridge thread within seconds.
+You post a message on a thread from your phone or laptop. The daemon (running on your machine, no port forwarding required) receives it over a long-lived HTTPS stream, spawns or resumes a session for the agent that thread is bound to, and the response posts back to the bridge thread within seconds.
 
 ## Status
 
@@ -11,10 +11,11 @@ You post a message on a thread from your phone or laptop. The daemon (running on
 ## What you'll need
 
 - macOS, Linux, or Windows, **Node.js 18.17+**
-- One coding agent installed, with your own auth:
-  - **Claude** — Claude Code / the Claude Agent SDK, billed to your Anthropic account; or
-  - **Codex** — the `codex` CLI (`npm i -g @openai/codex`), signed in to your OpenAI/ChatGPT account
-- An invite from `support@obto.co` (gives you an `accountId`, browser username/password, and an API token)
+- At least one coding agent installed on the machine (the daemon drives whichever ones it finds, with your own auth):
+  - **Claude** — Claude Code / the Claude Agent SDK, billed to your Anthropic account.
+  - **Codex** — the `codex` CLI (`npm i -g @openai/codex`), signed in to your OpenAI/ChatGPT account.
+  - **opencode** — `npm i -g opencode-ai` (the `opencode` CLI; the daemon bundles the `@opencode-ai/sdk`). Auth is your own provider key (Anthropic by default; override with env vars below).
+- An invite from `support@obto.co` (gives you an `accountId`, browser username/password, and an API token).
 
 ## Install
 
@@ -34,18 +35,25 @@ npx @obtoai/agent-bridge <command>
 obto-bridge init
 ```
 
-Walks you through a few questions: your account ID, API token, an agent name (to distinguish multiple machines on one account), which coding agent to drive (`claude` or `codex`), the project directory to work in, and whether to relay tool-permission requests via the bridge. (The server URL is a built-in default; advanced / self-hosted users can override it with the `BRIDGE_BASE_URL` env var.)
+Walks you through a few questions: your account ID, API token, an agent name (to distinguish multiple machines on one account), a *fallback* agent (`claude`, `codex`, or `opencode` — used only for legacy events without an explicit agent), the project directory to work in, and whether to relay tool-permission requests via the bridge. (The server URL is a built-in default; advanced / self-hosted users can override it with the `BRIDGE_BASE_URL` env var.)
 
 Config lands at `~/.obto-bridge/config.json` (mode 0600). Safe to commit your account ID; **never commit the `apiToken`**.
 
-### claude vs codex
+### Agents (claude / codex / opencode)
 
-Both drive real coding work on your machine; they differ in how they report back:
+v1.1 makes the daemon **agent-agnostic per event**: at startup it detects which of `claude`, `codex`, and `opencode` are installed on the machine, advertises that to the bridge, and routes each incoming reply to the right driver based on what the thread is bound to in the UI. You can switch a thread's agent live from the thread header; each engine keeps its own session for that thread, so flipping claude→codex→claude resumes each side's context.
 
-- **claude** — the fuller integration. Posts status updates, questions, and results as it works (via an in-process MCP tool), and supports the human-in-the-loop tool-permission relay.
-- **codex** — runs the task and delivers one final answer per turn. No mid-task updates and no per-tool relay (the Codex SDK exposes neither); it runs unattended inside a sandbox (`workspace-write` by default, override with `BRIDGE_CODEX_SANDBOX`).
+How the three differ in how they report back:
 
-One daemon drives one agent. To run both, use two daemons on two accounts.
+- **claude** — the fullest integration. Posts status updates, mid-task questions, and final results as it works (via an in-process MCP tool), and supports the human-in-the-loop tool-permission relay.
+- **codex** — runs the turn and delivers one final answer per turn. No mid-task updates and no per-tool relay (the Codex SDK exposes neither). Runs unattended inside a sandbox (`workspace-write` by default, override with `BRIDGE_CODEX_SANDBOX`).
+- **opencode** — same capture-model shape as codex: one final answer per turn, no mid-task chatter. Defaults to provider `anthropic` and model `claude-sonnet-4-5`; override with `BRIDGE_OPENCODE_PROVIDER` and `BRIDGE_OPENCODE_MODEL`.
+
+Picking a model is done in the bridge UI's **+ New thread** dialog and the thread-header switcher — not in the daemon config.
+
+### Multi-daemon (running across more than one machine)
+
+You can run the same account's daemon on more than one machine (e.g. a Mac and a Windows box). Each daemon advertises its `agentId` (machine name) + capabilities on connect; threads are atomically **first-touch claimed** by whichever daemon gets the event first, and every other daemon skips the event cleanly. No duplicate replies, no special configuration — just install + start the daemon on each machine.
 
 ## Run
 
@@ -56,14 +64,16 @@ obto-bridge start
 You'll see two log lines and then the daemon waits silently:
 
 ```
-{"msg":"starting daemon","data":{"accountId":"acc_...","agentId":"my-mac",...}}
+{"msg":"starting daemon","data":{"accountId":"acc_...","agentId":"my-mac","capabilities":["claude","codex"],...}}
 {"msg":"sse stream connected","data":{"status":200}}
 ```
 
+`capabilities` is the list of agents this daemon will accept — the bridge UI offers exactly the union across your connected machines.
+
 Now open the bridge UI in any browser, log in with the browser credentials from your invite, and either:
 
-- Reply on an existing thread — daemon resumes the session bound to that thread
-- Start a new thread via the **+ New thread** button — daemon spawns a fresh session in your project directory
+- Reply on an existing thread — daemon resumes the session bound to that thread (and to whichever agent the thread currently uses).
+- Start a new thread via the **+ New thread** button — pick Claude, Codex, or Opencode; the daemon spawns a fresh session in your project directory.
 
 Within ~5–10 seconds you should see the agent's reply appear back on the thread.
 
@@ -72,40 +82,41 @@ Within ~5–10 seconds you should see the agent's reply appear back on the threa
 | Command | What it does |
 |---|---|
 | `obto-bridge whoami` | Verify your token works + show your account info |
-| `obto-bridge status` | List active thread→session bindings |
+| `obto-bridge status` | List bindings per (thread, agent) — one row per engine that's ever driven a thread |
 | `obto-bridge logout` | Wipe `~/.obto-bridge/config.json` |
 
 ## How it actually works
 
 ```
-Your phone        OBTO server                      Your machine
-─────────         ───────────                      ────────────
+Your phone        OBTO server                      Your machine(s)
+─────────         ───────────                      ───────────────
 [reply form] ──►  /api/reply ─► Mongo (durable)
-                  └─►  RabbitMQ (publish bridge.<acct>.reply.<thread>)
+                  └─►  RabbitMQ (publish bridge.<acct>.reply.<thread>,
+                                 payload carries agent + agentId)
                                                 ◄── /api/bridge/stream  (SSE, Bearer auth)
-                                                    └─► daemon process
-                                                        └─► Claude Agent SDK
-                                                            └─► session JSONL in
-                                                                ~/.claude/projects/...
-                  /api/message ◄────  bridge_post (in-process MCP tool from daemon)
+                                                    └─► daemon (dispatches per payload.agent)
+                                                        ├─► Claude Agent SDK   → ~/.claude/projects/...
+                                                        ├─► @openai/codex-sdk  → ~/.codex/sessions/...
+                                                        └─► @opencode-ai/sdk   → opencode server
+                  /api/message ◄────  bridge_post (in-process MCP tool, Claude only)
 [poll: /api/messages] ◄──── (4s loop)
 ```
 
 Key bits:
 
 - The daemon **never** holds RabbitMQ credentials; broker access stays server-side. Per-account routing key isolation enforced by `BridgeAuth`.
-- The daemon's spawned Claude session uses an **in-process MCP server** (`mcp__bridge__bridge_post`) — not the platform's hosted MCP, so the daemon's tools don't depend on a long-lived OBTO MCP proxy session.
-- Each bridge **thread** binds to its own agent **session ID** at first message. Subsequent messages on the same thread resume the same session, so the agent keeps full context. Your interactive sessions are unaffected — they live in separate session stores.
+- For the **claude** driver, the spawned Claude session uses an **in-process MCP server** (`mcp__bridge__bridge_post`) — not the platform's hosted MCP, so the daemon's tools don't depend on a long-lived OBTO MCP proxy session. For **codex** and **opencode**, the SDKs can't auto-approve a write tool when run unattended, so the daemon captures the final response and posts it to the thread on the agent's behalf.
+- Each bridge **thread** binds to its own session ID **per agent**. Subsequent messages on the same thread + same agent resume the same engine-specific session, so the agent keeps full context. Switching the thread's agent in the UI starts (or resumes) the other engine's session — each side's state stays intact. Your interactive sessions are unaffected — they live in separate session stores.
 - Per-thread serialization means rapid bursts on the same thread are handled in order, never racing the same session.
-- With **codex**, there is no in-process MCP tool — the Codex SDK can't auto-approve a write tool when run unattended, so the daemon captures Codex's final response and posts it to the thread on the agent's behalf.
+- Multi-daemon races are killed by atomic first-touch claim against the thread record on the bridge.
 
 ## Agent costs
 
-The daemon runs your chosen agent on your machine with **your** credentials — Anthropic for `claude` (whatever Claude Code uses: `ANTHROPIC_API_KEY` or your Claude.ai session), or your OpenAI/ChatGPT account for `codex`. Every bridge-driven turn is a normal API call billed to you. We don't proxy.
+The daemon runs your chosen agent on your machine with **your** credentials — Anthropic for `claude` (whatever Claude Code uses: `ANTHROPIC_API_KEY` or your Claude.ai session); your OpenAI/ChatGPT account for `codex`; whichever provider you've configured `opencode` to call (Anthropic by default for this daemon). Every bridge-driven turn is a normal API call billed to you. We don't proxy.
 
 ## Data handling
 
-**Your model traffic never touches us.** The daemon runs on your machine and calls Anthropic or OpenAI with *your own* credentials. Your prompts, your code, and the model's responses pass directly between your machine and the model provider, under your own API account and its terms. OBTO does not proxy, route, or see that traffic.
+**Your model traffic never touches us.** The daemon runs on your machine and calls Anthropic, OpenAI, or whichever provider opencode is configured for, with *your own* credentials. Your prompts, your code, and the model's responses pass directly between your machine and the model provider, under your own API account and its terms. OBTO does not proxy, route, or see that traffic.
 
 **What the bridge stores.** For threads to work, the messages you and the agent post are saved in OBTO's database — that's what makes a thread durable and readable from your phone. Threads are strictly scoped to your account; one tenant can never see another's. Your daemon's API token is stored server-side only as a SHA-256 hash; the plaintext token never leaves your local config file.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obtoai/agent-bridge",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.5",
   "description": "Local consumer for the OBTO Agent Bridge. Receives bridge events over SSE and drives a coding agent (Claude Code or OpenAI Codex) on your machine.",
   "license": "Apache-2.0",
   "author": "OBTO Inc.",
@@ -32,6 +32,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.126",
-    "@openai/codex-sdk": "^0.130.0"
+    "@openai/codex-sdk": "^0.130.0",
+    "@opencode-ai/sdk": "^1.16.1"
   }
 }

package/src/bridge-http.js

@@ -78,10 +78,18 @@ const getMessages = (threadId, sinceCursor) => {
 const postAgentActivity = (threadId, state) =>
   postJson('/api/bridge/agent-activity', { threadId, state });
 
+// Phase 2b — atomic first-touch claim. Called by the daemon when it sees a
+// reply event for a thread whose `agentId` is null (unrouted). The bridge's
+// claimThread does a conditional Mongo update — only one daemon wins.
+// Returns { ok, won, winner }: `won` is the only thing the caller acts on.
+const claimThread = (threadId, agentId) =>
+  postJson('/api/bridge/thread/claim', { threadId, agentId });
+
 module.exports = {
   getCfg,
   buildHeaders,
   postMessage,
   getMessages,
   postAgentActivity,
+  claimThread,
 };

package/src/capabilities.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Phase 2b — what this machine can drive. The Claude Agent SDK is a hard
+// dependency of the daemon (declared in package.json), so `claude` is always
+// available. `codex` and `opencode` need their respective CLIs on PATH —
+// we probe with `which` (POSIX) or `where` (Windows).
+//
+// Sent to the bridge as `?capabilities=claude,codex,...` on SSE connect; the
+// bridge records them in `agent_bridge_daemons` so the UI picker can offer
+// only what's actually installable across the account's machines.
+
+const { spawnSync } = require('child_process');
+
+const onPath = (cmd) => {
+  try {
+    const tool = process.platform === 'win32' ? 'where' : 'which';
+    const r = spawnSync(tool, [cmd], { stdio: 'ignore' });
+    return r.status === 0;
+  } catch (_) {
+    return false;
+  }
+};
+
+const detect = () => {
+  const out = ['claude']; // bundled SDK; always advertised
+  if (onPath('codex')) out.push('codex');
+  if (onPath('opencode')) out.push('opencode');
+  return out;
+};
+
+module.exports = { detect, onPath };

package/src/daemon.js

@@ -4,7 +4,8 @@ const { loadConfig } = require('./config');
 const { startStream } = require('./stream-client');
 const { loadState, saveState, getAgentSession, setAgentSession } = require('./state');
 const { drive, tryResolvePermission, agentFor } = require('./driver');
-const { postAgentActivity } = require('./bridge-http');
+const { postAgentActivity, claimThread } = require('./bridge-http');
+const { detect: detectCapabilities } = require('./capabilities');
 
 const log = (level, msg, data) => {
   const line = { ts: new Date().toISOString(), level, msg };
@@ -67,6 +68,37 @@ const handleEvent = async (sseEvent) => {
     return;
   }
 
+  // Phase 2b — multi-daemon race check. The thread's target machine is
+  // included on the event when known (postReply publishes it). If it's set
+  // and isn't us, skip. If null, attempt the atomic first-touch claim — only
+  // the winning daemon handles the event; the rest skip cleanly.
+  const targetAgentId = payload.agentId ? String(payload.agentId).trim() : null;
+  if (targetAgentId && targetAgentId !== cfg.agentId) {
+    log('event', 'skip — claimed by other daemon', {
+      threadId,
+      targetAgentId,
+      messageId: payload.messageId,
+    });
+    return;
+  }
+  if (!targetAgentId) {
+    try {
+      const r = await claimThread(threadId, cfg.agentId);
+      if (!r || !r.ok || !r.data || !r.data.won) {
+        log('info', 'claim lost or failed', {
+          threadId,
+          winner: r && r.data && r.data.winner,
+          status: r && r.status,
+        });
+        return;
+      }
+      log('info', 'claim won', { threadId, agentId: cfg.agentId });
+    } catch (e) {
+      log('error', 'claim threw', { threadId, error: e && e.message });
+      return; // conservative — skip on uncertainty rather than double-drive
+    }
+  }
+
   // v1.1 — which agent this thread is bound to (server-set, on the event).
   const agent = agentFor(payload);
   const session = getAgentSession(state, threadId, agent);
@@ -137,16 +169,23 @@ const handleEvent = async (sseEvent) => {
 };
 
 const start = () => {
+  // Phase 2b — advertise capabilities to the bridge on connect so the UI
+  // picker can offer just the agents that are actually installable here.
+  const capabilities = detectCapabilities();
+
   log('info', 'starting daemon', {
     baseUrl: cfg.baseUrl,
     accountId: cfg.accountId,
     agentId: cfg.agentId,
-    agents: ['claude', 'codex'],
+    capabilities,
     projectDir: cfg.projectDir,
     boundThreads: Object.keys(state.bindings || {}),
   });
 
-  const url = cfg.baseUrl.replace(/\/$/, '') + '/api/bridge/stream';
+  const url = cfg.baseUrl.replace(/\/$/, '') +
+    '/api/bridge/stream' +
+    '?agentId=' + encodeURIComponent(cfg.agentId) +
+    '&capabilities=' + encodeURIComponent(capabilities.join(','));
   stream = startStream({
     url,
     // Re-read config on every (re)connect so a rotated token (via

package/src/driver.js

@@ -13,15 +13,16 @@
 
 const { loadConfig } = require('./config');
 
-const KNOWN_AGENTS = ['claude', 'codex'];
+const KNOWN_AGENTS = ['claude', 'codex', 'opencode'];
 
 const cache = {};
 
 const loadDriver = (name) => {
   if (cache[name]) return cache[name];
-  const mod = name === 'codex'
-    ? require('./codex-driver')
-    : require('./claude-driver');
+  let mod;
+  if (name === 'codex') mod = require('./codex-driver');
+  else if (name === 'opencode') mod = require('./opencode-driver');
+  else mod = require('./claude-driver');
   cache[name] = mod;
   return mod;
 };
@@ -38,7 +39,7 @@ const getFallbackAgent = () => {
   } catch (_) {
     // config unreadable — default to claude
   }
-  fallbackAgent = a === 'codex' ? 'codex' : 'claude';
+  fallbackAgent = KNOWN_AGENTS.indexOf(a) !== -1 ? a : 'claude';
   return fallbackAgent;
 };
 

package/src/opencode-driver.js

@@ -0,0 +1,220 @@
+'use strict';
+
+// Opencode driver — drives an opencode session per bridge thread, the
+// opencode counterpart of codex-driver.js. Selected when payload.agent ===
+// 'opencode'. Same capture-model shape as Codex: opencode runs the turn, this
+// driver posts the agent's final response to the bridge on its behalf.
+//
+// Why this is shaped like the Codex driver (and not Claude):
+//
+//   • No bridge MCP tool exposed to opencode. Easiest path is the SDK's
+//     session.prompt() and concatenating returned text parts as the answer.
+//
+//   • No fine-grained permission relay. opencode's SDK gives a single
+//     prompt-in / parts-out call per turn. tryResolvePermission() is a no-op.
+//
+// SDK-specific calls are isolated in runOpencode(), verified against
+// @opencode-ai/sdk@^1.16 (Node SDK docs as of 2026-05-21).
+
+const { loadConfig } = require('./config');
+const { buildEnvelope } = require('./claude-driver');
+const bridgeHttp = require('./bridge-http');
+
+// Per-thread promise queue — concurrent replies on one thread are serialized
+// so first-touch completes before any resume. Mirrors codex-driver.
+const queues = new Map();
+
+// Defaults can be overridden per-machine via env. Anthropic Claude is the
+// default because users running opencode usually already have Claude auth.
+const DEFAULT_PROVIDER = process.env.BRIDGE_OPENCODE_PROVIDER || 'anthropic';
+const DEFAULT_MODEL = process.env.BRIDGE_OPENCODE_MODEL || 'claude-sonnet-4-5';
+
+const buildOpencodePrompt = (payload, isFirst) => {
+  const head = buildEnvelope(payload);
+  if (!isFirst) return head;
+  return head +
+    '\n\n---\n' +
+    'You are an opencode session spawned by the OBTO Agent Bridge to handle ' +
+    'thread "' + payload.threadId + '". The human who sent the message above ' +
+    'is on the OBTO bridge web UI — they do NOT see your terminal, your tool ' +
+    'calls, or any intermediate output. They see ONLY your final response, ' +
+    'delivered to them verbatim.\n\n' +
+    'Therefore: do the requested work, then make your final response a ' +
+    'complete, self-contained answer addressed to that human. Markdown is ' +
+    'supported. If you need information you do not have, make your final ' +
+    'response a single clear question. Now handle the message above.';
+};
+
+// Best-effort extraction of the assistant's final text from an opencode
+// prompt result. The SDK returns `{ parts: [...] }` or `{ data: { parts } }`
+// depending on the call; we tolerate both and concatenate every text part.
+const extractFinalResponse = (result) => {
+  if (!result) return '';
+  const parts = (result && result.parts) ||
+    (result && result.data && result.data.parts) ||
+    [];
+  if (!Array.isArray(parts)) return '';
+  return parts
+    .filter((p) => p && (p.type === 'text' || typeof p.text === 'string'))
+    .map((p) => String(p.text || ''))
+    .join('\n')
+    .trim();
+};
+
+// ── SDK boundary ──────────────────────────────────────────────────────────
+// All @opencode-ai/sdk calls. The SDK spawns a local opencode HTTP server;
+// we tear it down at the end of every turn (cheap, simple, no shared state).
+const runOpencode = async ({ prompt, projectDir, resumeId }) => {
+  const { createOpencode } = await import('@opencode-ai/sdk');
+  const handle = await createOpencode({ directory: projectDir });
+  const client = handle.client;
+  const closeHandle = handle.close || (handle.server && handle.server.close);
+
+  try {
+    let sessionId = resumeId;
+    if (!sessionId) {
+      const created = await client.session.create({
+        body: { title: 'obto-bridge' },
+      });
+      sessionId = (created && created.id) ||
+        (created && created.data && created.data.id) ||
+        null;
+    }
+
+    const result = await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        model: { providerID: DEFAULT_PROVIDER, modelID: DEFAULT_MODEL },
+        parts: [{ type: 'text', text: prompt }],
+      },
+    });
+
+    return {
+      sessionId: sessionId || (result && result.sessionId) || null,
+      finalResponse: extractFinalResponse(result),
+    };
+  } finally {
+    try { if (typeof closeHandle === 'function') await closeHandle(); } catch (_) {}
+  }
+};
+// ──────────────────────────────────────────────────────────────────────────
+
+const postToBridge = async ({ threadId, body, kind, log }) => {
+  try {
+    const r = await bridgeHttp.postMessage({
+      threadId,
+      body,
+      kind: kind || 'result',
+      author: 'opencode-bridge',
+      role: 'agent',
+    });
+    if (!r.ok) {
+      log('error', 'opencode bridge post failed', { threadId, status: r.status });
+    }
+    return !!r.ok;
+  } catch (e) {
+    log('error', 'opencode bridge post threw', {
+      threadId,
+      error: e && e.message ? e.message : String(e),
+    });
+    return false;
+  }
+};
+
+const driveTurn = async ({ threadId, projectDir, resumeId, payload, log }) => {
+  const isFirst = !resumeId;
+  log('info', isFirst ? 'opencode first-touch spawn' : 'opencode resume', {
+    threadId,
+    projectDir,
+    resumeId: resumeId || undefined,
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL,
+    messageId: payload.messageId,
+  });
+
+  const startedAt = Date.now();
+  let sessionId = resumeId || null;
+  let finalResponse = '';
+  let failure = null;
+
+  try {
+    const res = await runOpencode({
+      prompt: buildOpencodePrompt(payload, isFirst),
+      projectDir,
+      resumeId,
+    });
+    sessionId = res.sessionId || sessionId;
+    finalResponse = res.finalResponse;
+  } catch (e) {
+    failure = e && e.message ? e.message : String(e);
+  }
+
+  // Capture model — the driver delivers opencode's output.
+  if (failure) {
+    await postToBridge({ threadId, kind: 'error', body: 'Opencode run failed: ' + failure, log });
+  } else if (finalResponse) {
+    await postToBridge({ threadId, kind: 'result', body: finalResponse, log });
+  } else {
+    await postToBridge({
+      threadId,
+      kind: 'error',
+      body: 'Opencode completed the turn but produced no final response.',
+      log,
+    });
+  }
+
+  log('info', isFirst ? 'opencode first-touch done' : 'opencode resume done', {
+    threadId,
+    sessionId,
+    ok: !failure && !!finalResponse,
+    assistantTextChars: finalResponse.length,
+    durationMs: Date.now() - startedAt,
+  });
+
+  if (failure && !sessionId) {
+    throw new Error('opencode run failed before a session id was assigned: ' + failure);
+  }
+
+  // jsonlPath/lastJsonlMtimeMs are Claude-specific — null keeps the binding
+  // shape consistent for daemon.js / state.js.
+  return {
+    sessionId,
+    projectDir,
+    jsonlPath: null,
+    lastJsonlMtimeMs: null,
+    stopReason: failure ? 'error' : 'done',
+    assistantTextChars: finalResponse.length,
+  };
+};
+
+const drive = (params) => {
+  const key = params.threadId;
+  const prev = queues.get(key) || Promise.resolve();
+  const next = prev
+    .then(() => {
+      const binding = params.binding;
+      const resuming = binding && binding.sessionId;
+      return driveTurn({
+        threadId: params.threadId,
+        projectDir: resuming ? binding.projectDir : params.projectDir,
+        resumeId: resuming ? binding.sessionId : null,
+        payload: params.payload,
+        log: params.log,
+      });
+    })
+    .catch((err) => {
+      params.log('error', 'opencode drive failed', {
+        threadId: params.threadId,
+        error: err && err.message ? err.message : String(err),
+      });
+      throw err;
+    });
+  queues.set(key, next);
+  return next;
+};
+
+// Opencode has no per-tool permission callback exposed by the SDK — there is
+// nothing to relay, same shape as the Codex driver.
+const tryResolvePermission = () => false;
+
+module.exports = { drive, tryResolvePermission };