@tanstack/ai-opencode 0.2.2 → 0.2.4

package/dist/esm/stream/translate.js

@@ -1,305 +1,320 @@
 import { EventType, buildBaseUsage } from "@tanstack/ai";
-const SESSION_ID_EVENT = "opencode.session-id";
-const TODO_EVENT = "opencode.todo";
-const BRIDGED_MCP_SERVER_NAME = "tanstack";
+//#region src/stream/translate.ts
+/** Name of the CUSTOM event carrying the OpenCode session id. */
+var SESSION_ID_EVENT = "opencode.session-id";
+/** Name of the CUSTOM event carrying the harness's todo list updates. */
+var TODO_EVENT = "opencode.todo";
+/** Server name used for bridged TanStack tools. */
+var BRIDGED_MCP_SERVER_NAME = "tanstack";
+/**
+* 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.
+*/
 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;
+	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;
+	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";
+var isTextPart = (part) => part.type === "text";
+var isReasoningPart = (part) => part.type === "reasoning";
+var isToolPart = (part) => part.type === "tool";
 function messageError(message) {
-  if (!message.error) return void 0;
-  return { message: message.error.data?.message ?? message.error.name };
+	if (!message.error) return void 0;
+	return { message: message.error.data?.message ?? message.error.name };
 }
+/**
+* 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.
+*/
 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;
-  }
+	const { model, runId, threadId, genId } = ctx;
+	const now = () => Date.now();
+	let runStarted = false;
+	/** Tool calls started but with no result yet, keyed by callID. */
+	const unresolvedToolCalls = /* @__PURE__ */ new Set();
+	/** Tool call ids that already emitted TOOL_CALL_START/ARGS/END. */
+	const openedToolCalls = /* @__PURE__ */ new Set();
+	/** Tool call ids that already emitted a TOOL_CALL_RESULT. */
+	const resolvedToolCalls = /* @__PURE__ */ new Set();
+	/** Accumulated text per text-part id, for delta derivation. */
+	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
+//#endregion
+export { BRIDGED_MCP_SERVER_NAME, SESSION_ID_EVENT, TODO_EVENT, resolveToolName, translateOpencodeStream };
+
+//# sourceMappingURL=translate.js.map