@tanstack/ai-opencode 0.1.0

package/dist/esm/process/permissions.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Permission modes for the OpenCode adapter, mirroring the Claude Code and
+ * Gemini CLI adapters' semantics:
+ *
+ * - `'default'`: bridged TanStack tools run; anything else that asks for
+ *   permission is rejected with no prompt (a headless server must never hang
+ *   on an interactive question).
+ * - `'acceptEdits'`: additionally auto-approves file-mutation requests
+ *   (edit / write / patch).
+ * - `'bypassPermissions'`: approves everything.
+ */
+export type OpencodePermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions';
+/** Structural subset of an OpenCode `permission.updated` payload. */
+export interface OpencodePermissionRequest {
+    id: string;
+    sessionID: string;
+    /** Permission category, e.g. `'edit'`, `'bash'`, `'webfetch'`, a tool id. */
+    type: string;
+    title: string;
+    /** Tool call id this permission gates, when it gates a tool. */
+    callID?: string;
+}
+/** OpenCode permission reply: allow once, allow always, or reject. */
+export type OpencodePermissionResponse = 'once' | 'always' | 'reject';
+/** Custom permission handler; replaces the adapter's default policy. */
+export type PermissionHandler = (request: OpencodePermissionRequest) => Promise<OpencodePermissionResponse> | OpencodePermissionResponse;
+/**
+ * Decide whether an OpenCode permission request targets one of the bridged
+ * TanStack tools. OpenCode names MCP tools `<server>_<tool>` (e.g.
+ * `tanstack_lookup_user`), so a request is bridged when its type or title is
+ * a registered tool name, or carries the `tanstack` server prefix.
+ */
+export declare function matchBridgedToolName(request: OpencodePermissionRequest, bridgedToolNames: ReadonlySet<string> | undefined): boolean;
+/**
+ * The adapter's default permission policy. Always answers immediately — never
+ * hangs a headless server on a question only an interactive user could
+ * answer.
+ */
+export declare function resolvePermission(request: OpencodePermissionRequest, mode: OpencodePermissionMode, bridgedToolNames: ReadonlySet<string> | undefined): OpencodePermissionResponse;
+/**
+ * Interactive variant: when the mode/bridge policy would reject, consult the
+ * client's approval decisions. Returns the OpenCode response plus, when the
+ * action still needs a client decision, the `approvalId`/`title` the adapter
+ * should surface via an `approval-requested` event.
+ */
+export declare function resolveInteractivePermission(request: OpencodePermissionRequest, mode: OpencodePermissionMode, bridgedToolNames: ReadonlySet<string> | undefined, approvals: ReadonlyMap<string, boolean> | undefined): {
+    response: OpencodePermissionResponse;
+    approvalId?: string;
+    title?: string;
+};

package/dist/esm/process/permissions.js

@@ -0,0 +1,51 @@
+import { approvalId } from "@tanstack/ai-sandbox";
+const EDIT_TYPES = /* @__PURE__ */ new Set(["edit", "write", "patch"]);
+function matchBridgedToolName(request, bridgedToolNames) {
+  if (!bridgedToolNames || bridgedToolNames.size === 0) return false;
+  for (const field of [request.type, request.title]) {
+    if (typeof field !== "string" || field === "") continue;
+    if (bridgedToolNames.has(field)) return true;
+    if (field.startsWith("tanstack_") && bridgedToolNames.has(field.slice(9))) {
+      return true;
+    }
+    if (field.startsWith("tanstack.") && bridgedToolNames.has(field.slice(9))) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolvePermission(request, mode, bridgedToolNames) {
+  if (matchBridgedToolName(request, bridgedToolNames)) {
+    return "once";
+  }
+  if (mode === "bypassPermissions") {
+    return "once";
+  }
+  if (mode === "acceptEdits" && EDIT_TYPES.has(request.type)) {
+    return "once";
+  }
+  return "reject";
+}
+function resolveInteractivePermission(request, mode, bridgedToolNames, approvals) {
+  if (matchBridgedToolName(request, bridgedToolNames))
+    return { response: "once" };
+  if (mode === "bypassPermissions") return { response: "once" };
+  if (mode === "acceptEdits" && EDIT_TYPES.has(request.type)) {
+    return { response: "once" };
+  }
+  const id = approvalId({
+    provider: "opencode",
+    kind: "tool",
+    target: request.type || request.title
+  });
+  const granted = approvals?.get(id);
+  if (granted === true) return { response: "once" };
+  if (granted === false) return { response: "reject" };
+  return { response: "reject", approvalId: id, title: request.title };
+}
+export {
+  matchBridgedToolName,
+  resolveInteractivePermission,
+  resolvePermission
+};
+//# sourceMappingURL=permissions.js.map

package/dist/esm/process/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","sources":["../../../src/process/permissions.ts"],"sourcesContent":["import { approvalId } from '@tanstack/ai-sandbox'\n\n/**\n * Permission modes for the OpenCode adapter, mirroring the Claude Code and\n * Gemini CLI adapters' semantics:\n *\n * - `'default'`: bridged TanStack tools run; anything else that asks for\n *   permission is rejected with no prompt (a headless server must never hang\n *   on an interactive question).\n * - `'acceptEdits'`: additionally auto-approves file-mutation requests\n *   (edit / write / patch).\n * - `'bypassPermissions'`: approves everything.\n */\nexport type OpencodePermissionMode =\n  | 'default'\n  | 'acceptEdits'\n  | 'bypassPermissions'\n\n/** Structural subset of an OpenCode `permission.updated` payload. */\nexport interface OpencodePermissionRequest {\n  id: string\n  sessionID: string\n  /** Permission category, e.g. `'edit'`, `'bash'`, `'webfetch'`, a tool id. */\n  type: string\n  title: string\n  /** Tool call id this permission gates, when it gates a tool. */\n  callID?: string\n}\n\n/** OpenCode permission reply: allow once, allow always, or reject. */\nexport type OpencodePermissionResponse = 'once' | 'always' | 'reject'\n\n/** Custom permission handler; replaces the adapter's default policy. */\nexport type PermissionHandler = (\n  request: OpencodePermissionRequest,\n) => Promise<OpencodePermissionResponse> | OpencodePermissionResponse\n\n/** Permission categories treated as file mutations for `'acceptEdits'`. */\nconst EDIT_TYPES = new Set(['edit', 'write', 'patch'])\n\n/**\n * Decide whether an OpenCode permission request targets one of the bridged\n * TanStack tools. OpenCode names MCP tools `<server>_<tool>` (e.g.\n * `tanstack_lookup_user`), so a request is bridged when its type or title is\n * a registered tool name, or carries the `tanstack` server prefix.\n */\nexport function matchBridgedToolName(\n  request: OpencodePermissionRequest,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n): boolean {\n  if (!bridgedToolNames || bridgedToolNames.size === 0) return false\n  for (const field of [request.type, request.title]) {\n    if (typeof field !== 'string' || field === '') continue\n    if (bridgedToolNames.has(field)) return true\n    if (field.startsWith('tanstack_') && bridgedToolNames.has(field.slice(9))) {\n      return true\n    }\n    if (field.startsWith('tanstack.') && bridgedToolNames.has(field.slice(9))) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * The adapter's default permission policy. Always answers immediately — never\n * hangs a headless server on a question only an interactive user could\n * answer.\n */\nexport function resolvePermission(\n  request: OpencodePermissionRequest,\n  mode: OpencodePermissionMode,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n): OpencodePermissionResponse {\n  if (matchBridgedToolName(request, bridgedToolNames)) {\n    return 'once'\n  }\n  if (mode === 'bypassPermissions') {\n    return 'once'\n  }\n  if (mode === 'acceptEdits' && EDIT_TYPES.has(request.type)) {\n    return 'once'\n  }\n  return 'reject'\n}\n\n/**\n * Interactive variant: when the mode/bridge policy would reject, consult the\n * client's approval decisions. Returns the OpenCode response plus, when the\n * action still needs a client decision, the `approvalId`/`title` the adapter\n * should surface via an `approval-requested` event.\n */\nexport function resolveInteractivePermission(\n  request: OpencodePermissionRequest,\n  mode: OpencodePermissionMode,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n  approvals: ReadonlyMap<string, boolean> | undefined,\n): {\n  response: OpencodePermissionResponse\n  approvalId?: string\n  title?: string\n} {\n  if (matchBridgedToolName(request, bridgedToolNames))\n    return { response: 'once' }\n  if (mode === 'bypassPermissions') return { response: 'once' }\n  if (mode === 'acceptEdits' && EDIT_TYPES.has(request.type)) {\n    return { response: 'once' }\n  }\n\n  const id = approvalId({\n    provider: 'opencode',\n    kind: 'tool',\n    target: request.type || request.title,\n  })\n  const granted = approvals?.get(id)\n  if (granted === true) return { response: 'once' }\n  if (granted === false) return { response: 'reject' }\n  return { response: 'reject', approvalId: id, title: request.title }\n}\n"],"names":[],"mappings":";AAsCA,MAAM,aAAa,oBAAI,IAAI,CAAC,QAAQ,SAAS,OAAO,CAAC;AAQ9C,SAAS,qBACd,SACA,kBACS;AACT,MAAI,CAAC,oBAAoB,iBAAiB,SAAS,EAAG,QAAO;AAC7D,aAAW,SAAS,CAAC,QAAQ,MAAM,QAAQ,KAAK,GAAG;AACjD,QAAI,OAAO,UAAU,YAAY,UAAU,GAAI;AAC/C,QAAI,iBAAiB,IAAI,KAAK,EAAG,QAAO;AACxC,QAAI,MAAM,WAAW,WAAW,KAAK,iBAAiB,IAAI,MAAM,MAAM,CAAC,CAAC,GAAG;AACzE,aAAO;AAAA,IACT;AACA,QAAI,MAAM,WAAW,WAAW,KAAK,iBAAiB,IAAI,MAAM,MAAM,CAAC,CAAC,GAAG;AACzE,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,kBACd,SACA,MACA,kBAC4B;AAC5B,MAAI,qBAAqB,SAAS,gBAAgB,GAAG;AACnD,WAAO;AAAA,EACT;AACA,MAAI,SAAS,qBAAqB;AAChC,WAAO;AAAA,EACT;AACA,MAAI,SAAS,iBAAiB,WAAW,IAAI,QAAQ,IAAI,GAAG;AAC1D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAQO,SAAS,6BACd,SACA,MACA,kBACA,WAKA;AACA,MAAI,qBAAqB,SAAS,gBAAgB;AAChD,WAAO,EAAE,UAAU,OAAA;AACrB,MAAI,SAAS,oBAAqB,QAAO,EAAE,UAAU,OAAA;AACrD,MAAI,SAAS,iBAAiB,WAAW,IAAI,QAAQ,IAAI,GAAG;AAC1D,WAAO,EAAE,UAAU,OAAA;AAAA,EACrB;AAEA,QAAM,KAAK,WAAW;AAAA,IACpB,UAAU;AAAA,IACV,MAAM;AAAA,IACN,QAAQ,QAAQ,QAAQ,QAAQ;AAAA,EAAA,CACjC;AACD,QAAM,UAAU,WAAW,IAAI,EAAE;AACjC,MAAI,YAAY,KAAM,QAAO,EAAE,UAAU,OAAA;AACzC,MAAI,YAAY,MAAO,QAAO,EAAE,UAAU,SAAA;AAC1C,SAAO,EAAE,UAAU,UAAU,YAAY,IAAI,OAAO,QAAQ,MAAA;AAC9D;"}

package/dist/esm/process/sandbox-server.d.ts

@@ -0,0 +1,23 @@
+import { SandboxHandle } from '@tanstack/ai-sandbox';
+export interface SandboxOpencodeServer {
+    /** URL the host uses to reach the in-sandbox server. */
+    baseUrl: string;
+    /**
+     * Headers that authenticate requests to {@link baseUrl}, when the provider's
+     * channel is token-gated (e.g. Daytona's `x-daytona-preview-token`). The host
+     * opencode client must send these on every request or the preview proxy 404s.
+     */
+    headers?: Record<string, string>;
+    /** Stop the server process. */
+    dispose: () => Promise<void>;
+}
+export interface StartServerOptions {
+    port: number;
+    hostname?: string;
+    cwd: string;
+    /** Extra env for the server process (e.g. `OPENCODE_CONFIG_CONTENT`). */
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare function startOpencodeServerInSandbox(sandbox: SandboxHandle, options: StartServerOptions): Promise<SandboxOpencodeServer>;

package/dist/esm/process/sandbox-server.js

@@ -0,0 +1,72 @@
+const READY_MARKER = "opencode server listening";
+async function startOpencodeServerInSandbox(sandbox, options) {
+  const hostname = options.hostname ?? "0.0.0.0";
+  const command = `opencode serve --hostname=${hostname} --port=${options.port}`;
+  const proc = await sandbox.process.spawn(command, {
+    cwd: options.cwd,
+    ...options.env ? { env: options.env } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  await waitForReady(proc, options.timeoutMs ?? 3e4);
+  const channel = await sandbox.ports.connect(options.port);
+  const headers = channel.headers ?? (channel.token ? { Authorization: `Bearer ${channel.token}` } : void 0);
+  return {
+    baseUrl: channel.url,
+    ...headers ? { headers } : {},
+    dispose: () => proc.kill()
+  };
+}
+function waitForReady(proc, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const state = { settled: false };
+    const settle = (fn) => {
+      if (state.settled) return;
+      state.settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const diagnostics = () => [stdout, stderr].map((s) => s.trim()).filter(Boolean).join("\n").slice(-500);
+    const timer = setTimeout(
+      () => settle(
+        () => reject(
+          new Error(
+            `opencode serve did not become ready within ${timeoutMs}ms${diagnostics() ? `: ${diagnostics()}` : ""}`
+          )
+        )
+      ),
+      timeoutMs
+    );
+    void (async () => {
+      try {
+        for await (const chunk of proc.stderr) stderr += chunk;
+      } catch {
+      }
+    })();
+    void (async () => {
+      try {
+        for await (const chunk of proc.stdout) {
+          stdout += chunk;
+          if (stdout.includes(READY_MARKER)) {
+            settle(resolve);
+            return;
+          }
+        }
+        settle(
+          () => reject(
+            new Error(
+              `opencode serve exited before becoming ready${diagnostics() ? `: ${diagnostics()}` : " (no output)"}`
+            )
+          )
+        );
+      } catch (error) {
+        settle(() => reject(error));
+      }
+    })();
+  });
+}
+export {
+  startOpencodeServerInSandbox
+};
+//# sourceMappingURL=sandbox-server.js.map

package/dist/esm/process/sandbox-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-server.js","sources":["../../../src/process/sandbox-server.ts"],"sourcesContent":["/**\n * Boot an `opencode serve` HTTP server INSIDE a sandbox and expose its port so\n * the host `@opencode-ai/sdk` client can connect over `baseUrl`. Mirrors the\n * SDK's own server launch (`opencode serve --hostname=H --port=P`, ready when\n * stdout logs `opencode server listening`).\n */\nimport type { SandboxHandle, SpawnHandle } from '@tanstack/ai-sandbox'\n\nconst READY_MARKER = 'opencode server listening'\n\nexport interface SandboxOpencodeServer {\n  /** URL the host uses to reach the in-sandbox server. */\n  baseUrl: string\n  /**\n   * Headers that authenticate requests to {@link baseUrl}, when the provider's\n   * channel is token-gated (e.g. Daytona's `x-daytona-preview-token`). The host\n   * opencode client must send these on every request or the preview proxy 404s.\n   */\n  headers?: Record<string, string>\n  /** Stop the server process. */\n  dispose: () => Promise<void>\n}\n\nexport interface StartServerOptions {\n  port: number\n  hostname?: string\n  cwd: string\n  /** Extra env for the server process (e.g. `OPENCODE_CONFIG_CONTENT`). */\n  env?: Record<string, string>\n  timeoutMs?: number\n  signal?: AbortSignal\n}\n\nexport async function startOpencodeServerInSandbox(\n  sandbox: SandboxHandle,\n  options: StartServerOptions,\n): Promise<SandboxOpencodeServer> {\n  const hostname = options.hostname ?? '0.0.0.0'\n  const command = `opencode serve --hostname=${hostname} --port=${options.port}`\n  const proc: SpawnHandle = await sandbox.process.spawn(command, {\n    cwd: options.cwd,\n    ...(options.env ? { env: options.env } : {}),\n    ...(options.signal ? { signal: options.signal } : {}),\n  })\n\n  await waitForReady(proc, options.timeoutMs ?? 30_000)\n\n  const channel = await sandbox.ports.connect(options.port)\n  // Carry the channel's auth so the host client can reach a token-gated preview.\n  // Prefer ready-made `headers`; fall back to a bearer token if that's all the\n  // provider issued.\n  const headers =\n    channel.headers ??\n    (channel.token ? { Authorization: `Bearer ${channel.token}` } : undefined)\n  return {\n    baseUrl: channel.url,\n    ...(headers ? { headers } : {}),\n    dispose: () => proc.kill(),\n  }\n}\n\nfunction waitForReady(proc: SpawnHandle, timeoutMs: number): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let stdout = ''\n    // Capture stderr too: opencode logs startup failures (e.g. \"address already\n    // in use\" when a previous run's server still holds the port) to stderr, not\n    // stdout. Without this the error message is empty and the real cause is lost.\n    let stderr = ''\n    // Holder object so reads stay typed as `boolean` across async closures\n    // (a plain `let` gets flow-narrowed to a literal and trips lint).\n    const state = { settled: false }\n    const settle = (fn: () => void): void => {\n      if (state.settled) return\n      state.settled = true\n      clearTimeout(timer)\n      fn()\n    }\n    const diagnostics = (): string =>\n      [stdout, stderr]\n        .map((s) => s.trim())\n        .filter(Boolean)\n        .join('\\n')\n        .slice(-500)\n    const timer = setTimeout(\n      () =>\n        settle(() =>\n          reject(\n            new Error(\n              `opencode serve did not become ready within ${timeoutMs}ms${\n                diagnostics() ? `: ${diagnostics()}` : ''\n              }`,\n            ),\n          ),\n        ),\n      timeoutMs,\n    )\n\n    // Drain stderr in the background so its text is available for diagnostics.\n    void (async () => {\n      try {\n        for await (const chunk of proc.stderr) stderr += chunk\n      } catch {\n        // Ignore: stderr drain errors are non-fatal; stdout drives readiness.\n      }\n    })()\n\n    void (async () => {\n      try {\n        for await (const chunk of proc.stdout) {\n          stdout += chunk\n          if (stdout.includes(READY_MARKER)) {\n            settle(resolve)\n            return\n          }\n        }\n        settle(() =>\n          reject(\n            new Error(\n              `opencode serve exited before becoming ready${\n                diagnostics() ? `: ${diagnostics()}` : ' (no output)'\n              }`,\n            ),\n          ),\n        )\n      } catch (error) {\n        settle(() => reject(error))\n      }\n    })()\n  })\n}\n"],"names":[],"mappings":"AAQA,MAAM,eAAe;AAyBrB,eAAsB,6BACpB,SACA,SACgC;AAChC,QAAM,WAAW,QAAQ,YAAY;AACrC,QAAM,UAAU,6BAA6B,QAAQ,WAAW,QAAQ,IAAI;AAC5E,QAAM,OAAoB,MAAM,QAAQ,QAAQ,MAAM,SAAS;AAAA,IAC7D,KAAK,QAAQ;AAAA,IACb,GAAI,QAAQ,MAAM,EAAE,KAAK,QAAQ,IAAA,IAAQ,CAAA;AAAA,IACzC,GAAI,QAAQ,SAAS,EAAE,QAAQ,QAAQ,OAAA,IAAW,CAAA;AAAA,EAAC,CACpD;AAED,QAAM,aAAa,MAAM,QAAQ,aAAa,GAAM;AAEpD,QAAM,UAAU,MAAM,QAAQ,MAAM,QAAQ,QAAQ,IAAI;AAIxD,QAAM,UACJ,QAAQ,YACP,QAAQ,QAAQ,EAAE,eAAe,UAAU,QAAQ,KAAK,GAAA,IAAO;AAClE,SAAO;AAAA,IACL,SAAS,QAAQ;AAAA,IACjB,GAAI,UAAU,EAAE,QAAA,IAAY,CAAA;AAAA,IAC5B,SAAS,MAAM,KAAK,KAAA;AAAA,EAAK;AAE7B;AAEA,SAAS,aAAa,MAAmB,WAAkC;AACzE,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,QAAI,SAAS;AAIb,QAAI,SAAS;AAGb,UAAM,QAAQ,EAAE,SAAS,MAAA;AACzB,UAAM,SAAS,CAAC,OAAyB;AACvC,UAAI,MAAM,QAAS;AACnB,YAAM,UAAU;AAChB,mBAAa,KAAK;AAClB,SAAA;AAAA,IACF;AACA,UAAM,cAAc,MAClB,CAAC,QAAQ,MAAM,EACZ,IAAI,CAAC,MAAM,EAAE,MAAM,EACnB,OAAO,OAAO,EACd,KAAK,IAAI,EACT,MAAM,IAAI;AACf,UAAM,QAAQ;AAAA,MACZ,MACE;AAAA,QAAO,MACL;AAAA,UACE,IAAI;AAAA,YACF,8CAA8C,SAAS,KACrD,YAAA,IAAgB,KAAK,YAAA,CAAa,KAAK,EACzC;AAAA,UAAA;AAAA,QACF;AAAA,MACF;AAAA,MAEJ;AAAA,IAAA;AAIF,UAAM,YAAY;AAChB,UAAI;AACF,yBAAiB,SAAS,KAAK,OAAQ,WAAU;AAAA,MACnD,QAAQ;AAAA,MAER;AAAA,IACF,GAAA;AAEA,UAAM,YAAY;AAChB,UAAI;AACF,yBAAiB,SAAS,KAAK,QAAQ;AACrC,oBAAU;AACV,cAAI,OAAO,SAAS,YAAY,GAAG;AACjC,mBAAO,OAAO;AACd;AAAA,UACF;AAAA,QACF;AACA;AAAA,UAAO,MACL;AAAA,YACE,IAAI;AAAA,cACF,8CACE,gBAAgB,KAAK,YAAA,CAAa,KAAK,cACzC;AAAA,YAAA;AAAA,UACF;AAAA,QACF;AAAA,MAEJ,SAAS,OAAO;AACd,eAAO,MAAM,OAAO,KAAK,CAAC;AAAA,MAC5B;AAAA,IACF,GAAA;AAAA,EACF,CAAC;AACH;"}

package/dist/esm/process/server.d.ts

@@ -0,0 +1,77 @@
+import { Config } from '@opencode-ai/sdk';
+import { OpencodeAssistantMessage, OpencodeEvent } from '../stream/sdk-types.js';
+import { OpencodePermissionRequest, OpencodePermissionResponse } from './permissions.js';
+/** A live OpenCode session backed by an `opencode serve` HTTP server. */
+export interface OpencodeSessionHandle {
+    sessionId: string;
+    /** Whether an existing session was actually resumed. */
+    resumed: boolean;
+    /**
+     * Run one prompt turn. Resolves with the final assistant message (finish
+     * reason, token usage, error) and its concatenated text once the harness
+     * goes idle. Streaming deltas arrive via `onEvent` while this is pending.
+     */
+    prompt: (text: string) => Promise<{
+        message: OpencodeAssistantMessage;
+        text: string;
+    }>;
+    /** Ask the harness to abort the in-flight prompt turn. */
+    abort: () => Promise<void>;
+    /** Tear down the event subscription and (if owned) the server. */
+    dispose: () => Promise<void>;
+}
+export interface StartOpencodeSessionOptions {
+    /** Connect to an already-running server instead of spawning one. */
+    baseUrl?: string;
+    /**
+     * Headers attached to every request to the opencode server — used to
+     * authenticate a token-gated preview channel (e.g. Daytona). Without them a
+     * gated preview proxy rejects the requests (404 "Not found.").
+     */
+    headers?: Record<string, string>;
+    /** Hostname for the spawned server. Defaults to the SDK default. */
+    hostname?: string;
+    /** Port for the spawned server. Defaults to the SDK default. */
+    port?: number;
+    /**
+     * Directory the opencode HTTP API scopes the session to. Omit to use the
+     * server's own launch cwd (the common case): the server is spawned with the
+     * correct working dir per-provider, so passing a directory here is only needed
+     * to override it. Passing a VIRTUAL sandbox path (e.g. `/workspace`) is wrong
+     * for host-running providers (local-process), where that path doesn't exist —
+     * the API then stalls on it. Leave undefined and rely on the server cwd.
+     */
+    directory?: string;
+    /** Provider id (the part before `/` in the model id). */
+    providerID: string;
+    /** Model id (the part after `/` in the model id). */
+    modelID: string;
+    /** Extra OpenCode config merged with the adapter's mcp/permission config. */
+    config?: Config;
+    /** Baseline permission policy applied to the spawned server. */
+    permission?: Config['permission'];
+    /** MCP servers (e.g. the TanStack tool bridge) for the session. */
+    mcpServers?: Array<{
+        name: string;
+        url: string;
+    }>;
+    /** Session id to resume; falls back to a fresh session when not found. */
+    resumeSessionId?: string;
+    onEvent: (event: OpencodeEvent) => void;
+    onPermissionRequest: (request: OpencodePermissionRequest) => Promise<OpencodePermissionResponse> | OpencodePermissionResponse;
+    /** Called when the event subscription fails mid-turn. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Boot (or attach to) an OpenCode HTTP server, resolve a session, and wire its
+ * event subscription + permission replies.
+ *
+ * This module is the only place that touches `@opencode-ai/sdk`; the rest of
+ * the package works with the structural types in `sdk-types.ts`.
+ *
+ * Resume semantics: when `resumeSessionId` is set and the server still knows
+ * the session (same machine, same data dir), it is reused. Otherwise a fresh
+ * session is created and `resumed: false` tells the adapter to send the
+ * flattened transcript.
+ */
+export declare function startOpencodeSession(options: StartOpencodeSessionOptions): Promise<OpencodeSessionHandle>;

package/dist/esm/process/server.js

@@ -0,0 +1,160 @@
+import { createOpencodeClient, createOpencode } from "@opencode-ai/sdk";
+function sessionIdOf(event) {
+  const props = event.properties;
+  if (props?.sessionID !== void 0) return props.sessionID;
+  if (event.type === "message.part.updated") {
+    return event.properties.part.sessionID;
+  }
+  if (event.type === "message.updated") {
+    return event.properties.info.sessionID;
+  }
+  if (event.type === "permission.updated") {
+    return event.properties.sessionID;
+  }
+  return void 0;
+}
+function buildConfig(options) {
+  const mcp = { ...options.config?.mcp };
+  for (const server of options.mcpServers ?? []) {
+    mcp[server.name] = { type: "remote", url: server.url, enabled: true };
+  }
+  return {
+    ...options.config,
+    ...Object.keys(mcp).length > 0 && { mcp },
+    ...options.permission !== void 0 && { permission: options.permission }
+  };
+}
+async function startOpencodeSession(options) {
+  const { directory } = options;
+  const dirQuery = directory !== void 0 ? { directory } : {};
+  let client;
+  let ownedServer;
+  if (options.baseUrl !== void 0) {
+    client = createOpencodeClient({
+      baseUrl: options.baseUrl,
+      ...options.headers !== void 0 && { headers: options.headers },
+      ...directory !== void 0 && { directory }
+    });
+  } else {
+    const config = buildConfig(options);
+    const result = await createOpencode({
+      ...options.hostname !== void 0 && { hostname: options.hostname },
+      ...options.port !== void 0 && { port: options.port },
+      ...Object.keys(config).length > 0 && { config }
+    });
+    client = result.client;
+    ownedServer = result.server;
+  }
+  const lifecycle = { disposed: false };
+  const teardown = async () => {
+    if (lifecycle.disposed) return;
+    lifecycle.disposed = true;
+    ownedServer?.close();
+    await Promise.resolve();
+  };
+  try {
+    let sessionId;
+    let resumed = false;
+    if (options.resumeSessionId !== void 0) {
+      const existing = await client.session.get({
+        path: { id: options.resumeSessionId },
+        query: dirQuery
+      });
+      if (existing.data) {
+        sessionId = options.resumeSessionId;
+        resumed = true;
+      }
+    }
+    if (sessionId === void 0) {
+      const created = await client.session.create({
+        query: dirQuery,
+        body: {},
+        throwOnError: true
+      });
+      sessionId = created.data.id;
+    }
+    const resolvedSessionId = sessionId;
+    const handlePermission = async (permission) => {
+      try {
+        const response = await options.onPermissionRequest({
+          id: permission.id,
+          sessionID: permission.sessionID,
+          type: permission.type,
+          title: permission.title,
+          ...permission.callID !== void 0 && { callID: permission.callID }
+        });
+        await client.postSessionIdPermissionsPermissionId({
+          path: { id: permission.sessionID, permissionID: permission.id },
+          query: dirQuery,
+          body: { response },
+          throwOnError: true
+        });
+      } catch (error) {
+        if (!lifecycle.disposed) options.onError?.(error);
+      }
+    };
+    const subscription = await client.event.subscribe();
+    const stream = subscription.stream;
+    void (async () => {
+      try {
+        for await (const event of stream) {
+          if (lifecycle.disposed) break;
+          const sid = sessionIdOf(event);
+          if (sid !== void 0 && sid !== resolvedSessionId) continue;
+          if (event.type === "permission.updated") {
+            void handlePermission(event.properties);
+            continue;
+          }
+          options.onEvent(event);
+        }
+      } catch (error) {
+        if (!lifecycle.disposed) options.onError?.(error);
+      }
+    })();
+    return {
+      sessionId: resolvedSessionId,
+      resumed,
+      prompt: async (text) => {
+        const result = await client.session.prompt({
+          path: { id: resolvedSessionId },
+          query: dirQuery,
+          body: {
+            model: { providerID: options.providerID, modelID: options.modelID },
+            parts: [{ type: "text", text }]
+          },
+          throwOnError: true
+        });
+        const data = result.data;
+        const message = data.info;
+        const responseText = data.parts.filter(
+          (part) => part.type === "text"
+        ).map((part) => part.text).join("");
+        return { message, text: responseText };
+      },
+      abort: async () => {
+        try {
+          await client.session.abort({
+            path: { id: resolvedSessionId },
+            query: dirQuery
+          });
+        } catch {
+        }
+      },
+      dispose: async () => {
+        lifecycle.disposed = true;
+        try {
+          await stream.return(void 0);
+        } catch {
+        }
+        ownedServer?.close();
+      }
+    };
+  } catch (error) {
+    await teardown();
+    throw error;
+  }
+}
+export {
+  startOpencodeSession
+};
+//# sourceMappingURL=server.js.map

package/dist/esm/process/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../../src/process/server.ts"],"sourcesContent":["import { createOpencode, createOpencodeClient } from '@opencode-ai/sdk'\nimport type { Config, Event, OpencodeClient, Part } from '@opencode-ai/sdk'\nimport type {\n  OpencodeAssistantMessage,\n  OpencodeEvent,\n} from '../stream/sdk-types'\nimport type {\n  OpencodePermissionRequest,\n  OpencodePermissionResponse,\n} from './permissions'\n\n/** A live OpenCode session backed by an `opencode serve` HTTP server. */\nexport interface OpencodeSessionHandle {\n  sessionId: string\n  /** Whether an existing session was actually resumed. */\n  resumed: boolean\n  /**\n   * Run one prompt turn. Resolves with the final assistant message (finish\n   * reason, token usage, error) and its concatenated text once the harness\n   * goes idle. Streaming deltas arrive via `onEvent` while this is pending.\n   */\n  prompt: (\n    text: string,\n  ) => Promise<{ message: OpencodeAssistantMessage; text: string }>\n  /** Ask the harness to abort the in-flight prompt turn. */\n  abort: () => Promise<void>\n  /** Tear down the event subscription and (if owned) the server. */\n  dispose: () => Promise<void>\n}\n\nexport interface StartOpencodeSessionOptions {\n  /** Connect to an already-running server instead of spawning one. */\n  baseUrl?: string\n  /**\n   * Headers attached to every request to the opencode server — used to\n   * authenticate a token-gated preview channel (e.g. Daytona). Without them a\n   * gated preview proxy rejects the requests (404 \"Not found.\").\n   */\n  headers?: Record<string, string>\n  /** Hostname for the spawned server. Defaults to the SDK default. */\n  hostname?: string\n  /** Port for the spawned server. Defaults to the SDK default. */\n  port?: number\n  /**\n   * Directory the opencode HTTP API scopes the session to. Omit to use the\n   * server's own launch cwd (the common case): the server is spawned with the\n   * correct working dir per-provider, so passing a directory here is only needed\n   * to override it. Passing a VIRTUAL sandbox path (e.g. `/workspace`) is wrong\n   * for host-running providers (local-process), where that path doesn't exist —\n   * the API then stalls on it. Leave undefined and rely on the server cwd.\n   */\n  directory?: string\n  /** Provider id (the part before `/` in the model id). */\n  providerID: string\n  /** Model id (the part after `/` in the model id). */\n  modelID: string\n  /** Extra OpenCode config merged with the adapter's mcp/permission config. */\n  config?: Config\n  /** Baseline permission policy applied to the spawned server. */\n  permission?: Config['permission']\n  /** MCP servers (e.g. the TanStack tool bridge) for the session. */\n  mcpServers?: Array<{ name: string; url: string }>\n  /** Session id to resume; falls back to a fresh session when not found. */\n  resumeSessionId?: string\n  onEvent: (event: OpencodeEvent) => void\n  onPermissionRequest: (\n    request: OpencodePermissionRequest,\n  ) => Promise<OpencodePermissionResponse> | OpencodePermissionResponse\n  /** Called when the event subscription fails mid-turn. */\n  onError?: (error: unknown) => void\n}\n\n/** Locate the session id an OpenCode event belongs to, when it carries one. */\nfunction sessionIdOf(event: Event): string | undefined {\n  const props = event.properties as { sessionID?: string } | undefined\n  if (props?.sessionID !== undefined) return props.sessionID\n  if (event.type === 'message.part.updated') {\n    return event.properties.part.sessionID\n  }\n  if (event.type === 'message.updated') {\n    return event.properties.info.sessionID\n  }\n  if (event.type === 'permission.updated') {\n    return event.properties.sessionID\n  }\n  return undefined\n}\n\nfunction buildConfig(options: StartOpencodeSessionOptions): Config {\n  const mcp: NonNullable<Config['mcp']> = { ...options.config?.mcp }\n  for (const server of options.mcpServers ?? []) {\n    mcp[server.name] = { type: 'remote', url: server.url, enabled: true }\n  }\n  return {\n    ...options.config,\n    ...(Object.keys(mcp).length > 0 && { mcp }),\n    ...(options.permission !== undefined && { permission: options.permission }),\n  }\n}\n\n/**\n * Boot (or attach to) an OpenCode HTTP server, resolve a session, and wire its\n * event subscription + permission replies.\n *\n * This module is the only place that touches `@opencode-ai/sdk`; the rest of\n * the package works with the structural types in `sdk-types.ts`.\n *\n * Resume semantics: when `resumeSessionId` is set and the server still knows\n * the session (same machine, same data dir), it is reused. Otherwise a fresh\n * session is created and `resumed: false` tells the adapter to send the\n * flattened transcript.\n */\nexport async function startOpencodeSession(\n  options: StartOpencodeSessionOptions,\n): Promise<OpencodeSessionHandle> {\n  const { directory } = options\n  // Spread into a `query` object only when set; omitting lets opencode use the\n  // server's launch cwd (correct for every provider — see `directory` docs).\n  const dirQuery = directory !== undefined ? { directory } : {}\n\n  let client: OpencodeClient\n  let ownedServer: { close: () => void } | undefined\n\n  if (options.baseUrl !== undefined) {\n    client = createOpencodeClient({\n      baseUrl: options.baseUrl,\n      ...(options.headers !== undefined && { headers: options.headers }),\n      ...(directory !== undefined && { directory }),\n    })\n  } else {\n    const config = buildConfig(options)\n    const result = await createOpencode({\n      ...(options.hostname !== undefined && { hostname: options.hostname }),\n      ...(options.port !== undefined && { port: options.port }),\n      ...(Object.keys(config).length > 0 && { config }),\n    })\n    client = result.client\n    ownedServer = result.server\n  }\n\n  // Mutated from several closures (the subscription loop, dispose, teardown);\n  // a holder object keeps reads typed as `boolean` rather than being\n  // flow-narrowed to a literal across those boundaries.\n  const lifecycle = { disposed: false }\n\n  const teardown = async (): Promise<void> => {\n    if (lifecycle.disposed) return\n    lifecycle.disposed = true\n    ownedServer?.close()\n    await Promise.resolve()\n  }\n\n  try {\n    // Resolve the session before subscribing so the event filter has an id.\n    let sessionId: string | undefined\n    let resumed = false\n    if (options.resumeSessionId !== undefined) {\n      const existing = await client.session.get({\n        path: { id: options.resumeSessionId },\n        query: dirQuery,\n      })\n      if (existing.data) {\n        sessionId = options.resumeSessionId\n        resumed = true\n      }\n    }\n    if (sessionId === undefined) {\n      const created = await client.session.create({\n        query: dirQuery,\n        body: {},\n        throwOnError: true,\n      })\n      sessionId = created.data.id\n    }\n    const resolvedSessionId = sessionId\n\n    const handlePermission = async (\n      permission: Extract<Event, { type: 'permission.updated' }>['properties'],\n    ): Promise<void> => {\n      try {\n        const response = await options.onPermissionRequest({\n          id: permission.id,\n          sessionID: permission.sessionID,\n          type: permission.type,\n          title: permission.title,\n          ...(permission.callID !== undefined && { callID: permission.callID }),\n        })\n        await client.postSessionIdPermissionsPermissionId({\n          path: { id: permission.sessionID, permissionID: permission.id },\n          query: dirQuery,\n          body: { response },\n          throwOnError: true,\n        })\n      } catch (error) {\n        if (!lifecycle.disposed) options.onError?.(error)\n      }\n    }\n\n    const subscription = await client.event.subscribe()\n    const stream = subscription.stream\n\n    void (async () => {\n      try {\n        for await (const event of stream) {\n          if (lifecycle.disposed) break\n          const sid = sessionIdOf(event)\n          if (sid !== undefined && sid !== resolvedSessionId) continue\n          if (event.type === 'permission.updated') {\n            void handlePermission(event.properties)\n            continue\n          }\n          // The SDK event union is a structural superset of the subset the\n          // translator consumes; unknown event types match no translator\n          // branch and are ignored.\n          options.onEvent(event as OpencodeEvent)\n        }\n      } catch (error) {\n        if (!lifecycle.disposed) options.onError?.(error)\n      }\n    })()\n\n    return {\n      sessionId: resolvedSessionId,\n      resumed,\n      prompt: async (text: string) => {\n        const result = await client.session.prompt({\n          path: { id: resolvedSessionId },\n          query: dirQuery,\n          body: {\n            model: { providerID: options.providerID, modelID: options.modelID },\n            parts: [{ type: 'text', text }],\n          },\n          throwOnError: true,\n        })\n        const data = result.data\n        const message = data.info as OpencodeAssistantMessage\n        const responseText = data.parts\n          .filter(\n            (part): part is Extract<Part, { type: 'text' }> =>\n              part.type === 'text',\n          )\n          .map((part) => part.text)\n          .join('')\n        return { message, text: responseText }\n      },\n      abort: async () => {\n        try {\n          await client.session.abort({\n            path: { id: resolvedSessionId },\n            query: dirQuery,\n          })\n        } catch {\n          // Best-effort: the turn may already be finishing.\n        }\n      },\n      dispose: async () => {\n        lifecycle.disposed = true\n        try {\n          await stream.return(undefined)\n        } catch {\n          // Ignore: stream may already be closed.\n        }\n        ownedServer?.close()\n      },\n    }\n  } catch (error) {\n    await teardown()\n    throw error\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/provider-options.d.ts

@@ -0,0 +1,18 @@
+import { OpencodePermissionMode } from './process/permissions.js';
+/**
+ * Per-call provider options for the OpenCode adapter, passed via
+ * `modelOptions` on `chat()`.
+ */
+export interface OpencodeTextProviderOptions {
+    /**
+     * Resume an existing OpenCode session. The adapter emits the session id of
+     * every fresh run via a CUSTOM `opencode.session-id` stream event; thread
+     * it back here to continue that session (only the latest user message is
+     * sent — the harness already holds the prior context).
+     */
+    sessionId?: string;
+    /** Per-call override of the configured permission mode. */
+    permissionMode?: OpencodePermissionMode;
+    /** Per-call override of the harness working directory. */
+    directory?: string;
+}

package/dist/esm/stream/queue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimal promise-based async queue bridging the OpenCode event
+ * subscription's callback-style notifications into the async-iterable world
+ * the stream translator consumes.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly values;
+    private readonly waiters;
+    private ended;
+    private error;
+    private failed;
+    push(value: T): void;
+    /** Signal normal completion; pending and future reads resolve as done. */
+    end(): void;
+    /** Signal failure; pending and future reads reject (after buffered values drain). */
+    fail(error: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/esm/stream/queue.js

@@ -0,0 +1,56 @@
+class AsyncQueue {
+  values = [];
+  waiters = [];
+  ended = false;
+  error = void 0;
+  failed = false;
+  push(value) {
+    if (this.ended || this.failed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ value, done: false });
+    } else {
+      this.values.push(value);
+    }
+  }
+  /** Signal normal completion; pending and future reads resolve as done. */
+  end() {
+    if (this.ended || this.failed) return;
+    this.ended = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  /** Signal failure; pending and future reads reject (after buffered values drain). */
+  fail(error) {
+    if (this.ended || this.failed) return;
+    this.failed = true;
+    this.error = error;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.reject(error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.values.length > 0) {
+          return Promise.resolve({
+            value: this.values.shift(),
+            done: false
+          });
+        }
+        if (this.failed) return Promise.reject(this.error);
+        if (this.ended) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          this.waiters.push({ resolve, reject });
+        });
+      }
+    };
+  }
+}
+export {
+  AsyncQueue
+};
+//# sourceMappingURL=queue.js.map

package/dist/esm/stream/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sources":["../../../src/stream/queue.ts"],"sourcesContent":["/**\n * Minimal promise-based async queue bridging the OpenCode event\n * subscription's callback-style notifications into the async-iterable world\n * the stream translator consumes.\n */\nexport class AsyncQueue<T> implements AsyncIterable<T> {\n  private readonly values: Array<T> = []\n  private readonly waiters: Array<{\n    resolve: (result: IteratorResult<T>) => void\n    reject: (error: unknown) => void\n  }> = []\n  private ended = false\n  private error: unknown = undefined\n  private failed = false\n\n  push(value: T): void {\n    if (this.ended || this.failed) return\n    const waiter = this.waiters.shift()\n    if (waiter) {\n      waiter.resolve({ value, done: false })\n    } else {\n      this.values.push(value)\n    }\n  }\n\n  /** Signal normal completion; pending and future reads resolve as done. */\n  end(): void {\n    if (this.ended || this.failed) return\n    this.ended = true\n    for (const waiter of this.waiters.splice(0)) {\n      waiter.resolve({ value: undefined, done: true })\n    }\n  }\n\n  /** Signal failure; pending and future reads reject (after buffered values drain). */\n  fail(error: unknown): void {\n    if (this.ended || this.failed) return\n    this.failed = true\n    this.error = error\n    for (const waiter of this.waiters.splice(0)) {\n      waiter.reject(error)\n    }\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return {\n      next: (): Promise<IteratorResult<T>> => {\n        if (this.values.length > 0) {\n          return Promise.resolve({\n            value: this.values.shift() as T,\n            done: false,\n          })\n        }\n        if (this.failed) return Promise.reject(this.error)\n        if (this.ended) {\n          return Promise.resolve({ value: undefined, done: true })\n        }\n        return new Promise((resolve, reject) => {\n          this.waiters.push({ resolve, reject })\n        })\n      },\n    }\n  }\n}\n"],"names":[],"mappings":"AAKO,MAAM,WAA0C;AAAA,EACpC,SAAmB,CAAA;AAAA,EACnB,UAGZ,CAAA;AAAA,EACG,QAAQ;AAAA,EACR,QAAiB;AAAA,EACjB,SAAS;AAAA,EAEjB,KAAK,OAAgB;AACnB,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,UAAM,SAAS,KAAK,QAAQ,MAAA;AAC5B,QAAI,QAAQ;AACV,aAAO,QAAQ,EAAE,OAAO,MAAM,OAAO;AAAA,IACvC,OAAO;AACL,WAAK,OAAO,KAAK,KAAK;AAAA,IACxB;AAAA,EACF;AAAA;AAAA,EAGA,MAAY;AACV,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,SAAK,QAAQ;AACb,eAAW,UAAU,KAAK,QAAQ,OAAO,CAAC,GAAG;AAC3C,aAAO,QAAQ,EAAE,OAAO,QAAW,MAAM,MAAM;AAAA,IACjD;AAAA,EACF;AAAA;AAAA,EAGA,KAAK,OAAsB;AACzB,QAAI,KAAK,SAAS,KAAK,OAAQ;AAC/B,SAAK,SAAS;AACd,SAAK,QAAQ;AACb,eAAW,UAAU,KAAK,QAAQ,OAAO,CAAC,GAAG;AAC3C,aAAO,OAAO,KAAK;AAAA,IACrB;AAAA,EACF;AAAA,EAEA,CAAC,OAAO,aAAa,IAAsB;AACzC,WAAO;AAAA,MACL,MAAM,MAAkC;AACtC,YAAI,KAAK,OAAO,SAAS,GAAG;AAC1B,iBAAO,QAAQ,QAAQ;AAAA,YACrB,OAAO,KAAK,OAAO,MAAA;AAAA,YACnB,MAAM;AAAA,UAAA,CACP;AAAA,QACH;AACA,YAAI,KAAK,OAAQ,QAAO,QAAQ,OAAO,KAAK,KAAK;AACjD,YAAI,KAAK,OAAO;AACd,iBAAO,QAAQ,QAAQ,EAAE,OAAO,QAAW,MAAM,MAAM;AAAA,QACzD;AACA,eAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,eAAK,QAAQ,KAAK,EAAE,SAAS,QAAQ;AAAA,QACvC,CAAC;AAAA,MACH;AAAA,IAAA;AAAA,EAEJ;AACF;"}