@tanstack/ai-opencode 0.1.0

package/dist/esm/stream/sdk-types.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Structural subset of the `@opencode-ai/sdk` event types that the stream
+ * translator consumes.
+ *
+ * These are intentionally defined structurally (rather than imported from the
+ * OpenCode SDK) so the translator stays a pure, fixture-testable state machine
+ * and the package's public types don't depend on the SDK's generated schema
+ * types. Unknown part or event types fall through every branch at runtime.
+ */
+export interface OpencodeTokens {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cache?: {
+        read?: number;
+        write?: number;
+    };
+}
+/** Error payload attached to a failed assistant message. */
+export interface OpencodeMessageError {
+    name: string;
+    data?: {
+        message?: string;
+    };
+}
+/**
+ * The final assistant message of a turn, returned by the blocking prompt
+ * call. Carries the finish reason, token usage, and any fatal error.
+ */
+export interface OpencodeAssistantMessage {
+    id: string;
+    role: 'assistant';
+    finish?: string;
+    error?: OpencodeMessageError;
+    tokens?: OpencodeTokens;
+    cost?: number;
+}
+export type OpencodeToolState = {
+    status: 'pending';
+    input?: Record<string, unknown>;
+} | {
+    status: 'running';
+    input?: Record<string, unknown>;
+    title?: string;
+} | {
+    status: 'completed';
+    input?: Record<string, unknown>;
+    output: string;
+    title?: string;
+} | {
+    status: 'error';
+    input?: Record<string, unknown>;
+    error: string;
+};
+/**
+ * The OpenCode message-part kinds the translator understands. The trailing
+ * catch-all member keeps the union open to other kinds (file, step-start,
+ * step-finish, snapshot, patch, agent, ...); the translator dispatches via
+ * the `is*Part` type guards, so those kinds simply match no guard.
+ */
+export type OpencodePart = {
+    id: string;
+    sessionID?: string;
+    type: 'text';
+    text: string;
+} | {
+    id: string;
+    sessionID?: string;
+    type: 'reasoning';
+    text: string;
+} | {
+    id: string;
+    sessionID?: string;
+    type: 'tool';
+    callID: string;
+    tool: string;
+    state: OpencodeToolState;
+} | {
+    id: string;
+    sessionID?: string;
+    type: string;
+};
+/**
+ * The OpenCode events the translator understands. This is a closed
+ * discriminated union (so `event.type` narrows cleanly); the server forwards
+ * raw SDK events cast to this type, and any event whose `type` isn't listed
+ * here simply matches no branch and is ignored at runtime.
+ */
+export type OpencodeEvent = {
+    type: 'message.part.updated';
+    properties: {
+        part: OpencodePart;
+        delta?: string;
+    };
+} | {
+    type: 'message.updated';
+    properties: {
+        info: {
+            sessionID?: string;
+        };
+    };
+} | {
+    type: 'session.idle';
+    properties: {
+        sessionID: string;
+    };
+} | {
+    type: 'session.error';
+    properties: {
+        sessionID?: string;
+        error?: OpencodeMessageError;
+    };
+} | {
+    type: 'todo.updated';
+    properties: {
+        sessionID: string;
+        todos: Array<unknown>;
+    };
+};
+/**
+ * Events fed to the translator: the session id once established, every
+ * session-scoped OpenCode event, and a terminal `done` carrying the final
+ * assistant message (the adapter's async queue produces these).
+ */
+export type OpencodeStreamEvent = {
+    kind: 'session';
+    sessionId: string;
+} | {
+    kind: 'event';
+    event: OpencodeEvent;
+} | {
+    kind: 'done';
+    message: OpencodeAssistantMessage;
+};

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

@@ -0,0 +1,51 @@
+import { StreamChunk } from '@tanstack/ai';
+import { OpencodeStreamEvent } from './sdk-types.js';
+/** Name of the CUSTOM event carrying the OpenCode session id. */
+export declare const SESSION_ID_EVENT = "opencode.session-id";
+/** Name of the CUSTOM event carrying the harness's todo list updates. */
+export declare const TODO_EVENT = "opencode.todo";
+/** Server name used for bridged TanStack tools. */
+export declare const BRIDGED_MCP_SERVER_NAME = "tanstack";
+export interface TranslateContext {
+    model: string;
+    runId: string;
+    threadId: string;
+    parentRunId?: string;
+    genId: () => string;
+    /**
+     * Names of bridged TanStack tools, used to surface the harness's MCP tool
+     * calls under the names the application registered.
+     */
+    bridgedToolNames?: ReadonlySet<string>;
+    /** Called for each raw stream event, for logging. */
+    onStreamEvent?: (event: OpencodeStreamEvent) => void;
+}
+/**
+ * Resolve the AG-UI tool-call name for an OpenCode tool part. OpenCode names
+ * MCP tools `<server>_<tool>`, so bridged TanStack tools arrive as
+ * `tanstack_<tool>` and are surfaced under the names the application
+ * registered; everything else (built-in `read`, `edit`, `bash`, ... and
+ * foreign MCP tools) uses the harness tool name verbatim.
+ */
+export declare function resolveToolName(tool: string, bridgedToolNames: ReadonlySet<string> | undefined): string;
+/**
+ * Translate an OpenCode event stream into AG-UI StreamChunk events.
+ *
+ * The harness runs its own agent loop and executes its own tools, so the
+ * translation always ends with `finishReason: 'stop'` (or `'length'` /
+ * RUN_ERROR) — never `'tool_calls'`. Harness tool activity is emitted as
+ * already-resolved TOOL_CALL_START/ARGS/END + TOOL_CALL_RESULT sequences so
+ * UIs can render it, while the TanStack engine never tries to execute them.
+ *
+ * OpenCode delivers true token-level deltas for both assistant text and
+ * reasoning via `message.part.updated` events (a `delta` string when
+ * incremental, otherwise the full part text, from which the delta is
+ * derived). The final assistant message — finish reason, token usage, and any
+ * fatal error — arrives as the terminal `done` event.
+ *
+ * Invariant: every TOOL_CALL_START is eventually paired with a
+ * TOOL_CALL_RESULT (synthesized as `{"status":"interrupted"}` when the run
+ * ends or aborts before the harness reported one) so the engine's
+ * pending-tool-call scan on the next request never force-executes them.
+ */
+export declare function translateOpencodeStream(events: AsyncIterable<OpencodeStreamEvent>, ctx: TranslateContext): AsyncIterable<StreamChunk>;

package/dist/esm/stream/translate.js

@@ -0,0 +1,305 @@
+import { EventType, buildBaseUsage } from "@tanstack/ai";
+const SESSION_ID_EVENT = "opencode.session-id";
+const TODO_EVENT = "opencode.todo";
+const BRIDGED_MCP_SERVER_NAME = "tanstack";
+function resolveToolName(tool, bridgedToolNames) {
+  if (!bridgedToolNames || bridgedToolNames.size === 0) return tool;
+  if (bridgedToolNames.has(tool)) return tool;
+  if (tool.startsWith("tanstack_") && bridgedToolNames.has(tool.slice(9))) {
+    return tool.slice(9);
+  }
+  return tool;
+}
+function buildUsage(tokens) {
+  if (!tokens) return void 0;
+  const promptTokens = tokens.input ?? 0;
+  const completionTokens = tokens.output ?? 0;
+  const result = buildBaseUsage({
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
+  });
+  if (tokens.cache?.read) {
+    result.promptTokensDetails = { cachedTokens: tokens.cache.read };
+  }
+  if (tokens.reasoning) {
+    result.completionTokensDetails = { reasoningTokens: tokens.reasoning };
+  }
+  return result;
+}
+const isTextPart = (part) => part.type === "text";
+const isReasoningPart = (part) => part.type === "reasoning";
+const isToolPart = (part) => part.type === "tool";
+function messageError(message) {
+  if (!message.error) return void 0;
+  return { message: message.error.data?.message ?? message.error.name };
+}
+async function* translateOpencodeStream(events, ctx) {
+  const { model, runId, threadId, genId } = ctx;
+  const now = () => Date.now();
+  let runStarted = false;
+  const unresolvedToolCalls = /* @__PURE__ */ new Set();
+  const openedToolCalls = /* @__PURE__ */ new Set();
+  const resolvedToolCalls = /* @__PURE__ */ new Set();
+  const textAccumulators = /* @__PURE__ */ new Map();
+  let openTextId = null;
+  let openReasoningId = null;
+  function* startRun() {
+    if (runStarted) return;
+    runStarted = true;
+    yield {
+      type: EventType.RUN_STARTED,
+      runId,
+      threadId,
+      model,
+      timestamp: now(),
+      ...ctx.parentRunId !== void 0 && { parentRunId: ctx.parentRunId }
+    };
+  }
+  function* closeText() {
+    if (openTextId !== null) {
+      yield {
+        type: EventType.TEXT_MESSAGE_END,
+        messageId: openTextId,
+        model,
+        timestamp: now()
+      };
+      openTextId = null;
+    }
+  }
+  function* closeReasoning() {
+    if (openReasoningId !== null) {
+      yield {
+        type: EventType.REASONING_MESSAGE_END,
+        messageId: openReasoningId,
+        model,
+        timestamp: now()
+      };
+      yield {
+        type: EventType.REASONING_END,
+        messageId: openReasoningId,
+        model,
+        timestamp: now()
+      };
+      openReasoningId = null;
+    }
+  }
+  function* synthesizeUnresolvedResults() {
+    for (const toolCallId of unresolvedToolCalls) {
+      yield {
+        type: EventType.TOOL_CALL_RESULT,
+        toolCallId,
+        messageId: genId(),
+        model,
+        timestamp: now(),
+        content: JSON.stringify({ status: "interrupted" })
+      };
+    }
+    unresolvedToolCalls.clear();
+  }
+  function* handleTextPart(part, delta) {
+    yield* closeReasoning();
+    const prev = textAccumulators.get(part.id) ?? "";
+    let deltaText;
+    if (typeof delta === "string" && delta !== "") {
+      deltaText = delta;
+      textAccumulators.set(part.id, prev + delta);
+    } else {
+      const full = part.text;
+      deltaText = full.startsWith(prev) ? full.slice(prev.length) : full;
+      textAccumulators.set(part.id, full);
+    }
+    if (deltaText === "") return;
+    if (openTextId !== part.id) {
+      yield* closeText();
+      openTextId = part.id;
+      yield {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId: part.id,
+        model,
+        timestamp: now(),
+        role: "assistant"
+      };
+    }
+    yield {
+      type: EventType.TEXT_MESSAGE_CONTENT,
+      messageId: part.id,
+      model,
+      timestamp: now(),
+      delta: deltaText,
+      content: textAccumulators.get(part.id) ?? deltaText
+    };
+  }
+  function* handleReasoningPart(part, delta) {
+    yield* closeText();
+    const prev = textAccumulators.get(part.id) ?? "";
+    let deltaText;
+    if (typeof delta === "string" && delta !== "") {
+      deltaText = delta;
+      textAccumulators.set(part.id, prev + delta);
+    } else {
+      const full = part.text;
+      deltaText = full.startsWith(prev) ? full.slice(prev.length) : full;
+      textAccumulators.set(part.id, full);
+    }
+    if (deltaText === "") return;
+    if (openReasoningId !== part.id) {
+      yield* closeReasoning();
+      openReasoningId = part.id;
+      yield {
+        type: EventType.REASONING_START,
+        messageId: part.id,
+        model,
+        timestamp: now()
+      };
+      yield {
+        type: EventType.REASONING_MESSAGE_START,
+        messageId: part.id,
+        role: "reasoning",
+        model,
+        timestamp: now()
+      };
+    }
+    yield {
+      type: EventType.REASONING_MESSAGE_CONTENT,
+      messageId: part.id,
+      delta: deltaText,
+      model,
+      timestamp: now()
+    };
+  }
+  function* openToolCall(part) {
+    if (openedToolCalls.has(part.callID)) return;
+    openedToolCalls.add(part.callID);
+    const toolCallName = resolveToolName(part.tool, ctx.bridgedToolNames);
+    const input = part.state.input ?? {};
+    const args = JSON.stringify(input);
+    yield {
+      type: EventType.TOOL_CALL_START,
+      toolCallId: part.callID,
+      toolCallName,
+      toolName: toolCallName,
+      model,
+      timestamp: now()
+    };
+    yield {
+      type: EventType.TOOL_CALL_ARGS,
+      toolCallId: part.callID,
+      model,
+      timestamp: now(),
+      delta: args,
+      args
+    };
+    yield {
+      type: EventType.TOOL_CALL_END,
+      toolCallId: part.callID,
+      toolCallName,
+      toolName: toolCallName,
+      model,
+      timestamp: now(),
+      input
+    };
+    unresolvedToolCalls.add(part.callID);
+  }
+  function* handleToolPart(part) {
+    yield* closeText();
+    yield* closeReasoning();
+    yield* openToolCall(part);
+    const state = part.state;
+    if (state.status !== "completed" && state.status !== "error") return;
+    if (resolvedToolCalls.has(part.callID)) return;
+    resolvedToolCalls.add(part.callID);
+    unresolvedToolCalls.delete(part.callID);
+    const isError = state.status === "error";
+    yield {
+      type: EventType.TOOL_CALL_RESULT,
+      toolCallId: part.callID,
+      messageId: genId(),
+      model,
+      timestamp: now(),
+      content: isError ? state.error : state.output,
+      ...isError && { state: "output-error" }
+    };
+  }
+  function* handleEvent(event) {
+    if (event.type === "message.part.updated") {
+      const { part, delta } = event.properties;
+      if (isTextPart(part)) {
+        yield* handleTextPart(part, delta);
+      } else if (isReasoningPart(part)) {
+        yield* handleReasoningPart(part, delta);
+      } else if (isToolPart(part)) {
+        yield* handleToolPart(part);
+      }
+    } else if (event.type === "todo.updated") {
+      yield {
+        type: EventType.CUSTOM,
+        model,
+        timestamp: now(),
+        name: TODO_EVENT,
+        value: { todos: event.properties.todos }
+      };
+    }
+  }
+  function* finish(message) {
+    yield* startRun();
+    yield* closeText();
+    yield* closeReasoning();
+    yield* synthesizeUnresolvedResults();
+    const error = messageError(message);
+    if (error) {
+      yield {
+        type: EventType.RUN_ERROR,
+        model,
+        timestamp: now(),
+        message: error.message,
+        error
+      };
+      return;
+    }
+    const usage = buildUsage(message.tokens);
+    const finishReason = message.finish === "length" ? "length" : "stop";
+    yield {
+      type: EventType.RUN_FINISHED,
+      runId,
+      threadId,
+      model,
+      timestamp: now(),
+      finishReason,
+      ...usage !== void 0 && { usage }
+    };
+  }
+  try {
+    for await (const streamEvent of events) {
+      ctx.onStreamEvent?.(streamEvent);
+      if (streamEvent.kind === "session") {
+        yield* startRun();
+        yield {
+          type: EventType.CUSTOM,
+          model,
+          timestamp: now(),
+          name: SESSION_ID_EVENT,
+          value: { sessionId: streamEvent.sessionId }
+        };
+      } else if (streamEvent.kind === "event") {
+        yield* startRun();
+        yield* handleEvent(streamEvent.event);
+      } else {
+        yield* finish(streamEvent.message);
+      }
+    }
+  } catch (error) {
+    yield* closeText();
+    yield* closeReasoning();
+    yield* synthesizeUnresolvedResults();
+    throw error;
+  }
+}
+export {
+  BRIDGED_MCP_SERVER_NAME,
+  SESSION_ID_EVENT,
+  TODO_EVENT,
+  resolveToolName,
+  translateOpencodeStream
+};
+//# sourceMappingURL=translate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"translate.js","sources":["../../../src/stream/translate.ts"],"sourcesContent":["import { EventType, buildBaseUsage } from '@tanstack/ai'\nimport type { StreamChunk, TokenUsage } from '@tanstack/ai'\nimport type {\n  OpencodeAssistantMessage,\n  OpencodeEvent,\n  OpencodePart,\n  OpencodeStreamEvent,\n  OpencodeTokens,\n} from './sdk-types'\n\n/** Name of the CUSTOM event carrying the OpenCode session id. */\nexport const SESSION_ID_EVENT = 'opencode.session-id'\n\n/** Name of the CUSTOM event carrying the harness's todo list updates. */\nexport const TODO_EVENT = 'opencode.todo'\n\n/** Server name used for bridged TanStack tools. */\nexport const BRIDGED_MCP_SERVER_NAME = 'tanstack'\n\nexport interface TranslateContext {\n  model: string\n  runId: string\n  threadId: string\n  parentRunId?: string\n  genId: () => string\n  /**\n   * Names of bridged TanStack tools, used to surface the harness's MCP tool\n   * calls under the names the application registered.\n   */\n  bridgedToolNames?: ReadonlySet<string>\n  /** Called for each raw stream event, for logging. */\n  onStreamEvent?: (event: OpencodeStreamEvent) => void\n}\n\n/**\n * Resolve the AG-UI tool-call name for an OpenCode tool part. OpenCode names\n * MCP tools `<server>_<tool>`, so bridged TanStack tools arrive as\n * `tanstack_<tool>` and are surfaced under the names the application\n * registered; everything else (built-in `read`, `edit`, `bash`, ... and\n * foreign MCP tools) uses the harness tool name verbatim.\n */\nexport function resolveToolName(\n  tool: string,\n  bridgedToolNames: ReadonlySet<string> | undefined,\n): string {\n  if (!bridgedToolNames || bridgedToolNames.size === 0) return tool\n  if (bridgedToolNames.has(tool)) return tool\n  if (tool.startsWith('tanstack_') && bridgedToolNames.has(tool.slice(9))) {\n    return tool.slice(9)\n  }\n  return tool\n}\n\nfunction buildUsage(\n  tokens: OpencodeTokens | undefined,\n): TokenUsage | undefined {\n  if (!tokens) return undefined\n  const promptTokens = tokens.input ?? 0\n  const completionTokens = tokens.output ?? 0\n  const result = buildBaseUsage({\n    promptTokens,\n    completionTokens,\n    totalTokens: promptTokens + completionTokens,\n  })\n  if (tokens.cache?.read) {\n    result.promptTokensDetails = { cachedTokens: tokens.cache.read }\n  }\n  if (tokens.reasoning) {\n    result.completionTokensDetails = { reasoningTokens: tokens.reasoning }\n  }\n  return result\n}\n\ntype TextPart = Extract<OpencodePart, { type: 'text' }>\ntype ReasoningPart = Extract<OpencodePart, { type: 'reasoning' }>\ntype ToolPart = Extract<OpencodePart, { type: 'tool' }>\n\nconst isTextPart = (part: OpencodePart): part is TextPart =>\n  part.type === 'text'\nconst isReasoningPart = (part: OpencodePart): part is ReasoningPart =>\n  part.type === 'reasoning'\nconst isToolPart = (part: OpencodePart): part is ToolPart =>\n  part.type === 'tool'\n\nfunction messageError(\n  message: OpencodeAssistantMessage,\n): { message: string } | undefined {\n  if (!message.error) return undefined\n  return { message: message.error.data?.message ?? message.error.name }\n}\n\n/**\n * Translate an OpenCode event stream into AG-UI StreamChunk events.\n *\n * The harness runs its own agent loop and executes its own tools, so the\n * translation always ends with `finishReason: 'stop'` (or `'length'` /\n * RUN_ERROR) — never `'tool_calls'`. Harness tool activity is emitted as\n * already-resolved TOOL_CALL_START/ARGS/END + TOOL_CALL_RESULT sequences so\n * UIs can render it, while the TanStack engine never tries to execute them.\n *\n * OpenCode delivers true token-level deltas for both assistant text and\n * reasoning via `message.part.updated` events (a `delta` string when\n * incremental, otherwise the full part text, from which the delta is\n * derived). The final assistant message — finish reason, token usage, and any\n * fatal error — arrives as the terminal `done` event.\n *\n * Invariant: every TOOL_CALL_START is eventually paired with a\n * TOOL_CALL_RESULT (synthesized as `{\"status\":\"interrupted\"}` when the run\n * ends or aborts before the harness reported one) so the engine's\n * pending-tool-call scan on the next request never force-executes them.\n */\nexport async function* translateOpencodeStream(\n  events: AsyncIterable<OpencodeStreamEvent>,\n  ctx: TranslateContext,\n): AsyncIterable<StreamChunk> {\n  const { model, runId, threadId, genId } = ctx\n  const now = () => Date.now()\n\n  let runStarted = false\n  /** Tool calls started but with no result yet, keyed by callID. */\n  const unresolvedToolCalls = new Set<string>()\n  /** Tool call ids that already emitted TOOL_CALL_START/ARGS/END. */\n  const openedToolCalls = new Set<string>()\n  /** Tool call ids that already emitted a TOOL_CALL_RESULT. */\n  const resolvedToolCalls = new Set<string>()\n\n  /** Accumulated text per text-part id, for delta derivation. */\n  const textAccumulators = new Map<string, string>()\n  let openTextId: string | null = null\n  let openReasoningId: string | null = null\n\n  function* startRun(): Generator<StreamChunk> {\n    if (runStarted) return\n    runStarted = true\n    yield {\n      type: EventType.RUN_STARTED,\n      runId,\n      threadId,\n      model,\n      timestamp: now(),\n      ...(ctx.parentRunId !== undefined && { parentRunId: ctx.parentRunId }),\n    }\n  }\n\n  function* closeText(): Generator<StreamChunk> {\n    if (openTextId !== null) {\n      yield {\n        type: EventType.TEXT_MESSAGE_END,\n        messageId: openTextId,\n        model,\n        timestamp: now(),\n      }\n      openTextId = null\n    }\n  }\n\n  function* closeReasoning(): Generator<StreamChunk> {\n    if (openReasoningId !== null) {\n      yield {\n        type: EventType.REASONING_MESSAGE_END,\n        messageId: openReasoningId,\n        model,\n        timestamp: now(),\n      }\n      yield {\n        type: EventType.REASONING_END,\n        messageId: openReasoningId,\n        model,\n        timestamp: now(),\n      }\n      openReasoningId = null\n    }\n  }\n\n  function* synthesizeUnresolvedResults(): Generator<StreamChunk> {\n    for (const toolCallId of unresolvedToolCalls) {\n      yield {\n        type: EventType.TOOL_CALL_RESULT,\n        toolCallId,\n        messageId: genId(),\n        model,\n        timestamp: now(),\n        content: JSON.stringify({ status: 'interrupted' }),\n      }\n    }\n    unresolvedToolCalls.clear()\n  }\n\n  function* handleTextPart(\n    part: Extract<OpencodePart, { type: 'text' }>,\n    delta: string | undefined,\n  ): Generator<StreamChunk> {\n    yield* closeReasoning()\n\n    const prev = textAccumulators.get(part.id) ?? ''\n    let deltaText: string\n    if (typeof delta === 'string' && delta !== '') {\n      deltaText = delta\n      textAccumulators.set(part.id, prev + delta)\n    } else {\n      const full = part.text\n      deltaText = full.startsWith(prev) ? full.slice(prev.length) : full\n      textAccumulators.set(part.id, full)\n    }\n    if (deltaText === '') return\n\n    if (openTextId !== part.id) {\n      yield* closeText()\n      openTextId = part.id\n      yield {\n        type: EventType.TEXT_MESSAGE_START,\n        messageId: part.id,\n        model,\n        timestamp: now(),\n        role: 'assistant',\n      }\n    }\n    yield {\n      type: EventType.TEXT_MESSAGE_CONTENT,\n      messageId: part.id,\n      model,\n      timestamp: now(),\n      delta: deltaText,\n      content: textAccumulators.get(part.id) ?? deltaText,\n    }\n  }\n\n  function* handleReasoningPart(\n    part: Extract<OpencodePart, { type: 'reasoning' }>,\n    delta: string | undefined,\n  ): Generator<StreamChunk> {\n    yield* closeText()\n\n    const prev = textAccumulators.get(part.id) ?? ''\n    let deltaText: string\n    if (typeof delta === 'string' && delta !== '') {\n      deltaText = delta\n      textAccumulators.set(part.id, prev + delta)\n    } else {\n      const full = part.text\n      deltaText = full.startsWith(prev) ? full.slice(prev.length) : full\n      textAccumulators.set(part.id, full)\n    }\n    if (deltaText === '') return\n\n    if (openReasoningId !== part.id) {\n      yield* closeReasoning()\n      openReasoningId = part.id\n      yield {\n        type: EventType.REASONING_START,\n        messageId: part.id,\n        model,\n        timestamp: now(),\n      }\n      yield {\n        type: EventType.REASONING_MESSAGE_START,\n        messageId: part.id,\n        role: 'reasoning' as const,\n        model,\n        timestamp: now(),\n      }\n    }\n    yield {\n      type: EventType.REASONING_MESSAGE_CONTENT,\n      messageId: part.id,\n      delta: deltaText,\n      model,\n      timestamp: now(),\n    }\n  }\n\n  function* openToolCall(\n    part: Extract<OpencodePart, { type: 'tool' }>,\n  ): Generator<StreamChunk> {\n    if (openedToolCalls.has(part.callID)) return\n    openedToolCalls.add(part.callID)\n    const toolCallName = resolveToolName(part.tool, ctx.bridgedToolNames)\n    const input = part.state.input ?? {}\n    const args = JSON.stringify(input)\n    yield {\n      type: EventType.TOOL_CALL_START,\n      toolCallId: part.callID,\n      toolCallName,\n      toolName: toolCallName,\n      model,\n      timestamp: now(),\n    }\n    yield {\n      type: EventType.TOOL_CALL_ARGS,\n      toolCallId: part.callID,\n      model,\n      timestamp: now(),\n      delta: args,\n      args,\n    }\n    yield {\n      type: EventType.TOOL_CALL_END,\n      toolCallId: part.callID,\n      toolCallName,\n      toolName: toolCallName,\n      model,\n      timestamp: now(),\n      input,\n    }\n    unresolvedToolCalls.add(part.callID)\n  }\n\n  function* handleToolPart(\n    part: Extract<OpencodePart, { type: 'tool' }>,\n  ): Generator<StreamChunk> {\n    yield* closeText()\n    yield* closeReasoning()\n    yield* openToolCall(part)\n\n    const state = part.state\n    if (state.status !== 'completed' && state.status !== 'error') return\n    if (resolvedToolCalls.has(part.callID)) return\n    resolvedToolCalls.add(part.callID)\n    unresolvedToolCalls.delete(part.callID)\n\n    const isError = state.status === 'error'\n    yield {\n      type: EventType.TOOL_CALL_RESULT,\n      toolCallId: part.callID,\n      messageId: genId(),\n      model,\n      timestamp: now(),\n      content: isError ? state.error : state.output,\n      ...(isError && { state: 'output-error' as const }),\n    }\n  }\n\n  function* handleEvent(event: OpencodeEvent): Generator<StreamChunk> {\n    if (event.type === 'message.part.updated') {\n      const { part, delta } = event.properties\n      if (isTextPart(part)) {\n        yield* handleTextPart(part, delta)\n      } else if (isReasoningPart(part)) {\n        yield* handleReasoningPart(part, delta)\n      } else if (isToolPart(part)) {\n        yield* handleToolPart(part)\n      }\n      // Other part kinds (file, step-start/finish, snapshot, ...) carry no\n      // state the chunk stream needs.\n    } else if (event.type === 'todo.updated') {\n      yield {\n        type: EventType.CUSTOM,\n        model,\n        timestamp: now(),\n        name: TODO_EVENT,\n        value: { todos: event.properties.todos },\n      }\n    }\n    // session.idle / session.status / message.updated are redundant with the\n    // terminal `done` event and are ignored.\n  }\n\n  function* finish(message: OpencodeAssistantMessage): Generator<StreamChunk> {\n    yield* startRun()\n    yield* closeText()\n    yield* closeReasoning()\n    yield* synthesizeUnresolvedResults()\n\n    const error = messageError(message)\n    if (error) {\n      yield {\n        type: EventType.RUN_ERROR,\n        model,\n        timestamp: now(),\n        message: error.message,\n        error,\n      }\n      return\n    }\n\n    const usage = buildUsage(message.tokens)\n    const finishReason = message.finish === 'length' ? 'length' : 'stop'\n    yield {\n      type: EventType.RUN_FINISHED,\n      runId,\n      threadId,\n      model,\n      timestamp: now(),\n      finishReason,\n      ...(usage !== undefined && { usage }),\n    }\n  }\n\n  try {\n    for await (const streamEvent of events) {\n      ctx.onStreamEvent?.(streamEvent)\n\n      if (streamEvent.kind === 'session') {\n        yield* startRun()\n        yield {\n          type: EventType.CUSTOM,\n          model,\n          timestamp: now(),\n          name: SESSION_ID_EVENT,\n          value: { sessionId: streamEvent.sessionId },\n        }\n      } else if (streamEvent.kind === 'event') {\n        yield* startRun()\n        yield* handleEvent(streamEvent.event)\n      } else {\n        yield* finish(streamEvent.message)\n      }\n    }\n  } catch (error) {\n    // The run is dying (abort, server exit, or connection failure). Close any\n    // open message and pair started tool calls with a synthetic result first\n    // so the next request's pending-tool-call scan doesn't try to execute\n    // them, then let the adapter surface the error as RUN_ERROR.\n    yield* closeText()\n    yield* closeReasoning()\n    yield* synthesizeUnresolvedResults()\n    throw error\n  }\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tanstack/ai-opencode",
+  "version": "0.1.0",
+  "description": "OpenCode harness adapter for TanStack AI — run OpenCode as a chat backend with local tool execution and stateful sessions.",
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/ai.git",
+    "directory": "packages/ai-opencode"
+  },
+  "keywords": [
+    "ai",
+    "ai-sdk",
+    "typescript",
+    "tanstack",
+    "opencode",
+    "harness",
+    "agent",
+    "adapter",
+    "chat",
+    "tool-calling"
+  ],
+  "type": "module",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "clean": "premove ./build ./dist",
+    "lint:fix": "eslint ./src --fix",
+    "test:build": "publint --strict",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vitest",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "tsc"
+  },
+  "dependencies": {
+    "@opencode-ai/sdk": "^1.17.4"
+  },
+  "peerDependencies": {
+    "@tanstack/ai": "workspace:^",
+    "@tanstack/ai-sandbox": "workspace:^"
+  },
+  "devDependencies": {
+    "@tanstack/ai": "workspace:*",
+    "@tanstack/ai-sandbox": "workspace:*",
+    "@vitest/coverage-v8": "4.0.14"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}