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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obtoai/agent-bridge",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.4",
   "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 };