@tambo-ai/client 0.0.1

package/dist/utils/send-message.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Send Message Utilities
+ *
+ * Framework-agnostic functions for sending messages and handling streaming
+ * responses. Extracted from the React SDK's useTamboSendMessage hook to enable
+ * reuse across different UI frameworks.
+ */
+import type TamboAI from "@tambo-ai/typescript-sdk";
+import type { Stream } from "@tambo-ai/typescript-sdk/core/streaming";
+import type { ToolResultContent } from "@tambo-ai/typescript-sdk/resources/threads/threads";
+import type { RunAwaitingInputEvent } from "../types/event";
+import type { InitialInputMessage, InputMessage } from "../types/message";
+import type { ToolChoice } from "../types/tool-choice";
+import type { StreamAction } from "./event-accumulator";
+import type { ComponentRegistry, TamboToolRegistry } from "../model/component-metadata";
+import type { ToolCallTracker } from "./tool-call-tracker";
+/**
+ * Stream type for run responses on an existing thread.
+ */
+export type RunStream = Stream<TamboAI.Threads.Runs.RunRunResponse>;
+/**
+ * Stream type for creating a new thread with a run.
+ */
+export type CreateStream = Stream<TamboAI.Threads.Runs.RunCreateResponse>;
+/**
+ * Options for sending a message.
+ */
+export interface SendMessageOptions {
+    /** The message to send. */
+    message: InputMessage;
+    /**
+     * User message text for optimistic display.
+     * If provided, synthetic AG-UI events will be dispatched to show
+     * the user message in the thread immediately after getting the threadId.
+     */
+    userMessageText?: string;
+    /** Enable debug logging for the stream. */
+    debug?: boolean;
+    /**
+     * How the model should use tools. Defaults to "auto".
+     * - "auto": Model decides whether to use tools
+     * - "required": Model must use at least one tool
+     * - "none": Model cannot use tools
+     * - { name: "toolName" }: Model must use the specified tool
+     */
+    toolChoice?: ToolChoice;
+}
+/**
+ * Parameters for creating a run stream.
+ */
+export interface CreateRunStreamParams {
+    client: TamboAI;
+    threadId: string | undefined;
+    message: InputMessage;
+    componentList: ComponentRegistry;
+    toolRegistry: TamboToolRegistry;
+    userKey: string | undefined;
+    /**
+     * Previous run ID for continuing a thread with existing messages.
+     * Required when threadId is provided and the thread has previous runs.
+     */
+    previousRunId: string | undefined;
+    /**
+     * Additional context gathered from context helpers (including interactables).
+     * Merged into the message's additionalContext before sending.
+     */
+    additionalContext?: Record<string, unknown>;
+    /** How the model should use tools. */
+    toolChoice?: ToolChoice;
+    /**
+     * Initial messages to seed the thread with when creating a new thread.
+     * Only used when threadId is undefined (new thread creation).
+     */
+    initialMessages?: InitialInputMessage[];
+}
+/**
+ * Result from creating a run stream.
+ */
+export interface CreateRunStreamResult {
+    stream: RunStream | CreateStream;
+    initialThreadId: string | undefined;
+}
+/**
+ * Parameters for executing tools and continuing the run.
+ */
+export interface ExecuteToolsParams {
+    event: RunAwaitingInputEvent;
+    toolTracker: ToolCallTracker;
+    toolRegistry: TamboToolRegistry;
+    componentList: ComponentRegistry;
+    client: TamboAI;
+    threadId: string;
+    runId: string;
+    userKey: string | undefined;
+    additionalContext?: Record<string, unknown>;
+    toolChoice?: ToolChoice;
+}
+/**
+ * Result from executing tools and continuing the run.
+ */
+export interface ExecuteToolsResult {
+    stream: RunStream;
+    toolResults: ToolResultContent[];
+}
+/**
+ * Dispatches synthetic AG-UI events to show a user message in the thread.
+ * @param dispatch - Stream state dispatcher
+ * @param targetThreadId - Thread to add the message to
+ * @param messageId - Stable ID for the user message
+ * @param messageText - Text content of the message
+ */
+export declare function dispatchUserMessage(dispatch: (action: StreamAction) => void, targetThreadId: string, messageId: string, messageText: string): void;
+/**
+ * Dispatches synthetic events for tool results as optimistic local state.
+ * The server doesn't echo these back for client-side tools.
+ * @param dispatch - Stream state dispatcher
+ * @param targetThreadId - Thread to add results to
+ * @param toolResults - Tool execution results to dispatch
+ */
+export declare function dispatchToolResults(dispatch: (action: StreamAction) => void, targetThreadId: string, toolResults: ToolResultContent[]): void;
+/**
+ * Creates a run stream by calling the appropriate API method.
+ *
+ * If threadId is provided, runs on existing thread via client.threads.runs.run().
+ * If no threadId, creates new thread via client.threads.runs.create().
+ * @param params - The parameters for creating the run stream
+ * @returns The stream and initial thread ID (undefined if creating new thread)
+ */
+export declare function createRunStream(params: CreateRunStreamParams): Promise<CreateRunStreamResult>;
+/**
+ * Executes pending tools and returns a continuation stream.
+ *
+ * This function does NOT process the continuation stream - it just executes
+ * the tools and returns the new stream for the caller to process. This enables
+ * the flat loop pattern that correctly handles multi-round tool execution.
+ * @param params - The parameters for tool execution
+ * @returns The continuation stream and tool results for optimistic local state updates
+ */
+export declare function executeToolsAndContinue(params: ExecuteToolsParams): Promise<ExecuteToolsResult>;
+//# sourceMappingURL=send-message.d.ts.map

package/dist/utils/send-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../src/utils/send-message.ts"],"names":[],"mappings":"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"}

package/dist/utils/send-message.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Send Message Utilities
+ *
+ * Framework-agnostic functions for sending messages and handling streaming
+ * responses. Extracted from the React SDK's useTamboSendMessage hook to enable
+ * reuse across different UI frameworks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchUserMessage = dispatchUserMessage;
+exports.dispatchToolResults = dispatchToolResults;
+exports.createRunStream = createRunStream;
+exports.executeToolsAndContinue = executeToolsAndContinue;
+const core_1 = require("@ag-ui/core");
+const registry_conversion_1 = require("./registry-conversion");
+const tool_executor_1 = require("./tool-executor");
+/**
+ * Dispatches synthetic AG-UI events to show a user message in the thread.
+ * @param dispatch - Stream state dispatcher
+ * @param targetThreadId - Thread to add the message to
+ * @param messageId - Stable ID for the user message
+ * @param messageText - Text content of the message
+ */
+function dispatchUserMessage(dispatch, targetThreadId, messageId, messageText) {
+    dispatch({
+        type: "EVENT",
+        threadId: targetThreadId,
+        event: {
+            type: core_1.EventType.TEXT_MESSAGE_START,
+            messageId,
+            role: "user",
+        },
+    });
+    dispatch({
+        type: "EVENT",
+        threadId: targetThreadId,
+        event: {
+            type: core_1.EventType.TEXT_MESSAGE_CONTENT,
+            messageId,
+            delta: messageText,
+        },
+    });
+    dispatch({
+        type: "EVENT",
+        threadId: targetThreadId,
+        event: {
+            type: core_1.EventType.TEXT_MESSAGE_END,
+            messageId,
+        },
+    });
+}
+/**
+ * Dispatches synthetic events for tool results as optimistic local state.
+ * The server doesn't echo these back for client-side tools.
+ * @param dispatch - Stream state dispatcher
+ * @param targetThreadId - Thread to add results to
+ * @param toolResults - Tool execution results to dispatch
+ */
+function dispatchToolResults(dispatch, targetThreadId, toolResults) {
+    if (toolResults.length === 0)
+        return;
+    const toolResultMessageId = `msg_tool_result_${Date.now()}`;
+    dispatch({
+        type: "EVENT",
+        threadId: targetThreadId,
+        event: {
+            type: core_1.EventType.TEXT_MESSAGE_START,
+            messageId: toolResultMessageId,
+            role: "user",
+        },
+    });
+    for (const result of toolResults) {
+        dispatch({
+            type: "EVENT",
+            threadId: targetThreadId,
+            event: {
+                type: core_1.EventType.TOOL_CALL_RESULT,
+                toolCallId: result.toolUseId,
+                messageId: toolResultMessageId,
+                content: result.content
+                    .filter((c) => c.type === "text")
+                    .map((c) => c.text)
+                    .join("") || JSON.stringify(result.content),
+            },
+        });
+    }
+    dispatch({
+        type: "EVENT",
+        threadId: targetThreadId,
+        event: {
+            type: core_1.EventType.TEXT_MESSAGE_END,
+            messageId: toolResultMessageId,
+        },
+    });
+}
+/**
+ * Creates a run stream by calling the appropriate API method.
+ *
+ * If threadId is provided, runs on existing thread via client.threads.runs.run().
+ * If no threadId, creates new thread via client.threads.runs.create().
+ * @param params - The parameters for creating the run stream
+ * @returns The stream and initial thread ID (undefined if creating new thread)
+ */
+async function createRunStream(params) {
+    const { client, threadId, message, componentList, toolRegistry, userKey, previousRunId, additionalContext, toolChoice, initialMessages, } = params;
+    // Merge helper context with any caller-provided additionalContext on the message
+    const mergedContext = additionalContext || message.additionalContext
+        ? {
+            ...(message.additionalContext ?? {}),
+            ...additionalContext,
+        }
+        : undefined;
+    const messageWithContext = mergedContext
+        ? { ...message, additionalContext: mergedContext }
+        : message;
+    // Convert registry components/tools to API format
+    const availableComponents = (0, registry_conversion_1.toAvailableComponents)(componentList);
+    const availableTools = (0, registry_conversion_1.toAvailableTools)(toolRegistry);
+    if (threadId) {
+        // Run on existing thread
+        const stream = await client.threads.runs.run(threadId, {
+            message: messageWithContext,
+            availableComponents,
+            tools: availableTools,
+            userKey,
+            previousRunId,
+            toolChoice,
+        });
+        return { stream, initialThreadId: threadId };
+    }
+    else {
+        // Create new thread - include initialMessages if provided
+        const threadConfig = {};
+        if (userKey) {
+            threadConfig.userKey = userKey;
+        }
+        if (initialMessages?.length) {
+            threadConfig.initialMessages = initialMessages;
+        }
+        const stream = await client.threads.runs.create({
+            message: messageWithContext,
+            availableComponents,
+            tools: availableTools,
+            thread: Object.keys(threadConfig).length > 0 ? threadConfig : undefined,
+            toolChoice,
+        });
+        // threadId will be extracted from first event (RUN_STARTED)
+        return { stream, initialThreadId: undefined };
+    }
+}
+/**
+ * Executes pending tools and returns a continuation stream.
+ *
+ * This function does NOT process the continuation stream - it just executes
+ * the tools and returns the new stream for the caller to process. This enables
+ * the flat loop pattern that correctly handles multi-round tool execution.
+ * @param params - The parameters for tool execution
+ * @returns The continuation stream and tool results for optimistic local state updates
+ */
+async function executeToolsAndContinue(params) {
+    const { event, toolTracker, toolRegistry, componentList, client, threadId, runId, userKey, additionalContext, toolChoice, } = params;
+    const pendingToolCallIds = event.value.pendingToolCalls.map((tc) => tc.toolCallId);
+    const toolCallsToExecute = toolTracker.getToolCallsById(pendingToolCallIds);
+    // Execute tools
+    const toolResults = await (0, tool_executor_1.executeAllPendingTools)(toolCallsToExecute, toolRegistry);
+    // Clear executed tool calls before continuing
+    toolTracker.clearToolCalls(pendingToolCallIds);
+    // Return the continuation stream and tool results
+    const stream = await client.threads.runs.run(threadId, {
+        message: {
+            role: "user",
+            content: toolResults,
+            additionalContext,
+        },
+        previousRunId: runId,
+        availableComponents: (0, registry_conversion_1.toAvailableComponents)(componentList),
+        tools: (0, registry_conversion_1.toAvailableTools)(toolRegistry),
+        userKey,
+        toolChoice,
+    });
+    return { stream, toolResults };
+}
+//# sourceMappingURL=send-message.js.map

package/dist/utils/send-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-message.js","sourceRoot":"","sources":["../../src/utils/send-message.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Send Message Utilities\n *\n * Framework-agnostic functions for sending messages and handling streaming\n * responses. Extracted from the React SDK's useTamboSendMessage hook to enable\n * reuse across different UI frameworks.\n */\n\nimport { EventType } from \"@ag-ui/core\";\nimport type TamboAI from \"@tambo-ai/typescript-sdk\";\nimport type { Stream } from \"@tambo-ai/typescript-sdk/core/streaming\";\nimport type { ToolResultContent } from \"@tambo-ai/typescript-sdk/resources/threads/threads\";\nimport type { RunCreateParams } from \"@tambo-ai/typescript-sdk/resources/threads/runs\";\n\nimport type { RunAwaitingInputEvent } from \"../types/event\";\nimport type { InitialInputMessage, InputMessage } from \"../types/message\";\nimport type { ToolChoice } from \"../types/tool-choice\";\nimport type { StreamAction } from \"./event-accumulator\";\nimport type {\n  ComponentRegistry,\n  TamboToolRegistry,\n} from \"../model/component-metadata\";\nimport { toAvailableComponents, toAvailableTools } from \"./registry-conversion\";\nimport { executeAllPendingTools } from \"./tool-executor\";\nimport type { ToolCallTracker } from \"./tool-call-tracker\";\n\n/**\n * Stream type for run responses on an existing thread.\n */\nexport type RunStream = Stream<TamboAI.Threads.Runs.RunRunResponse>;\n\n/**\n * Stream type for creating a new thread with a run.\n */\nexport type CreateStream = Stream<TamboAI.Threads.Runs.RunCreateResponse>;\n\n/**\n * Options for sending a message.\n */\nexport interface SendMessageOptions {\n  /** The message to send. */\n  message: InputMessage;\n\n  /**\n   * User message text for optimistic display.\n   * If provided, synthetic AG-UI events will be dispatched to show\n   * the user message in the thread immediately after getting the threadId.\n   */\n  userMessageText?: string;\n\n  /** Enable debug logging for the stream. */\n  debug?: boolean;\n\n  /**\n   * How the model should use tools. Defaults to \"auto\".\n   * - \"auto\": Model decides whether to use tools\n   * - \"required\": Model must use at least one tool\n   * - \"none\": Model cannot use tools\n   * - { name: \"toolName\" }: Model must use the specified tool\n   */\n  toolChoice?: ToolChoice;\n}\n\n/**\n * Parameters for creating a run stream.\n */\nexport interface CreateRunStreamParams {\n  client: TamboAI;\n  threadId: string | undefined;\n  message: InputMessage;\n  componentList: ComponentRegistry;\n  toolRegistry: TamboToolRegistry;\n  userKey: string | undefined;\n  /**\n   * Previous run ID for continuing a thread with existing messages.\n   * Required when threadId is provided and the thread has previous runs.\n   */\n  previousRunId: string | undefined;\n  /**\n   * Additional context gathered from context helpers (including interactables).\n   * Merged into the message's additionalContext before sending.\n   */\n  additionalContext?: Record<string, unknown>;\n  /** How the model should use tools. */\n  toolChoice?: ToolChoice;\n  /**\n   * Initial messages to seed the thread with when creating a new thread.\n   * Only used when threadId is undefined (new thread creation).\n   */\n  initialMessages?: InitialInputMessage[];\n}\n\n/**\n * Result from creating a run stream.\n */\nexport interface CreateRunStreamResult {\n  stream: RunStream | CreateStream;\n  initialThreadId: string | undefined;\n}\n\n/**\n * Parameters for executing tools and continuing the run.\n */\nexport interface ExecuteToolsParams {\n  event: RunAwaitingInputEvent;\n  toolTracker: ToolCallTracker;\n  toolRegistry: TamboToolRegistry;\n  componentList: ComponentRegistry;\n  client: TamboAI;\n  threadId: string;\n  runId: string;\n  userKey: string | undefined;\n  additionalContext?: Record<string, unknown>;\n  toolChoice?: ToolChoice;\n}\n\n/**\n * Result from executing tools and continuing the run.\n */\nexport interface ExecuteToolsResult {\n  stream: RunStream;\n  toolResults: ToolResultContent[];\n}\n\n/**\n * Dispatches synthetic AG-UI events to show a user message in the thread.\n * @param dispatch - Stream state dispatcher\n * @param targetThreadId - Thread to add the message to\n * @param messageId - Stable ID for the user message\n * @param messageText - Text content of the message\n */\nexport function dispatchUserMessage(\n  dispatch: (action: StreamAction) => void,\n  targetThreadId: string,\n  messageId: string,\n  messageText: string,\n): void {\n  dispatch({\n    type: \"EVENT\",\n    threadId: targetThreadId,\n    event: {\n      type: EventType.TEXT_MESSAGE_START,\n      messageId,\n      role: \"user\" as const,\n    },\n  });\n\n  dispatch({\n    type: \"EVENT\",\n    threadId: targetThreadId,\n    event: {\n      type: EventType.TEXT_MESSAGE_CONTENT,\n      messageId,\n      delta: messageText,\n    },\n  });\n\n  dispatch({\n    type: \"EVENT\",\n    threadId: targetThreadId,\n    event: {\n      type: EventType.TEXT_MESSAGE_END,\n      messageId,\n    },\n  });\n}\n\n/**\n * Dispatches synthetic events for tool results as optimistic local state.\n * The server doesn't echo these back for client-side tools.\n * @param dispatch - Stream state dispatcher\n * @param targetThreadId - Thread to add results to\n * @param toolResults - Tool execution results to dispatch\n */\nexport function dispatchToolResults(\n  dispatch: (action: StreamAction) => void,\n  targetThreadId: string,\n  toolResults: ToolResultContent[],\n): void {\n  if (toolResults.length === 0) return;\n\n  const toolResultMessageId = `msg_tool_result_${Date.now()}`;\n\n  dispatch({\n    type: \"EVENT\",\n    threadId: targetThreadId,\n    event: {\n      type: EventType.TEXT_MESSAGE_START,\n      messageId: toolResultMessageId,\n      role: \"user\" as const,\n    },\n  });\n\n  for (const result of toolResults) {\n    dispatch({\n      type: \"EVENT\",\n      threadId: targetThreadId,\n      event: {\n        type: EventType.TOOL_CALL_RESULT,\n        toolCallId: result.toolUseId,\n        messageId: toolResultMessageId,\n        content:\n          result.content\n            .filter((c) => c.type === \"text\")\n            .map((c) => (c as { type: \"text\"; text: string }).text)\n            .join(\"\") || JSON.stringify(result.content),\n      },\n    });\n  }\n\n  dispatch({\n    type: \"EVENT\",\n    threadId: targetThreadId,\n    event: {\n      type: EventType.TEXT_MESSAGE_END,\n      messageId: toolResultMessageId,\n    },\n  });\n}\n\n/**\n * Creates a run stream by calling the appropriate API method.\n *\n * If threadId is provided, runs on existing thread via client.threads.runs.run().\n * If no threadId, creates new thread via client.threads.runs.create().\n * @param params - The parameters for creating the run stream\n * @returns The stream and initial thread ID (undefined if creating new thread)\n */\nexport async function createRunStream(\n  params: CreateRunStreamParams,\n): Promise<CreateRunStreamResult> {\n  const {\n    client,\n    threadId,\n    message,\n    componentList,\n    toolRegistry,\n    userKey,\n    previousRunId,\n    additionalContext,\n    toolChoice,\n    initialMessages,\n  } = params;\n\n  // Merge helper context with any caller-provided additionalContext on the message\n  const mergedContext =\n    additionalContext || message.additionalContext\n      ? {\n          ...((message.additionalContext as Record<string, unknown>) ?? {}),\n          ...additionalContext,\n        }\n      : undefined;\n  const messageWithContext: InputMessage = mergedContext\n    ? { ...message, additionalContext: mergedContext }\n    : message;\n\n  // Convert registry components/tools to API format\n  const availableComponents = toAvailableComponents(componentList);\n  const availableTools = toAvailableTools(toolRegistry);\n\n  if (threadId) {\n    // Run on existing thread\n    const stream = await client.threads.runs.run(threadId, {\n      message: messageWithContext,\n      availableComponents,\n      tools: availableTools,\n      userKey,\n      previousRunId,\n      toolChoice,\n    });\n    return { stream, initialThreadId: threadId };\n  } else {\n    // Create new thread - include initialMessages if provided\n    const threadConfig: RunCreateParams.Thread = {};\n    if (userKey) {\n      threadConfig.userKey = userKey;\n    }\n    if (initialMessages?.length) {\n      threadConfig.initialMessages = initialMessages;\n    }\n\n    const stream = await client.threads.runs.create({\n      message: messageWithContext,\n      availableComponents,\n      tools: availableTools,\n      thread: Object.keys(threadConfig).length > 0 ? threadConfig : undefined,\n      toolChoice,\n    });\n    // threadId will be extracted from first event (RUN_STARTED)\n    return { stream, initialThreadId: undefined };\n  }\n}\n\n/**\n * Executes pending tools and returns a continuation stream.\n *\n * This function does NOT process the continuation stream - it just executes\n * the tools and returns the new stream for the caller to process. This enables\n * the flat loop pattern that correctly handles multi-round tool execution.\n * @param params - The parameters for tool execution\n * @returns The continuation stream and tool results for optimistic local state updates\n */\nexport async function executeToolsAndContinue(\n  params: ExecuteToolsParams,\n): Promise<ExecuteToolsResult> {\n  const {\n    event,\n    toolTracker,\n    toolRegistry,\n    componentList,\n    client,\n    threadId,\n    runId,\n    userKey,\n    additionalContext,\n    toolChoice,\n  } = params;\n\n  const pendingToolCallIds = event.value.pendingToolCalls.map(\n    (tc) => tc.toolCallId,\n  );\n  const toolCallsToExecute = toolTracker.getToolCallsById(pendingToolCallIds);\n\n  // Execute tools\n  const toolResults = await executeAllPendingTools(\n    toolCallsToExecute,\n    toolRegistry,\n  );\n\n  // Clear executed tool calls before continuing\n  toolTracker.clearToolCalls(pendingToolCallIds);\n\n  // Return the continuation stream and tool results\n  const stream = await client.threads.runs.run(threadId, {\n    message: {\n      role: \"user\",\n      content: toolResults,\n      additionalContext,\n    },\n    previousRunId: runId,\n    availableComponents: toAvailableComponents(componentList),\n    tools: toAvailableTools(toolRegistry),\n    userKey,\n    toolChoice,\n  });\n\n  return { stream, toolResults };\n}\n"]}

package/dist/utils/stream-handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Stream Handler for Streaming API
+ *
+ * Provides utilities for handling event streams from the TypeScript SDK.
+ * The SDK's client.threads.runs.run() already returns an async iterable,
+ * so this module just adds optional debug logging.
+ */
+import type { AGUIEvent } from "@ag-ui/core";
+/**
+ * Options for stream handling.
+ */
+export interface StreamHandlerOptions {
+    /**
+     * Enable debug logging (development mode only).
+     * Logs all events to console.
+     */
+    debug?: boolean;
+}
+/**
+ * Handle an event stream from the TypeScript SDK and yield AG-UI event types.
+ *
+ * The TypeScript SDK's client.threads.runs.run() and client.threads.runs.create()
+ * return async iterables that yield events compatible with AG-UI's AGUIEvent.
+ * This function wraps the stream to add optional debug logging and ensures
+ * proper typing.
+ *
+ * Note: SDK events have `type: string` rather than `type: EventType` enum,
+ * but the values are compatible with AG-UI event types.
+ * @param stream - Async iterable of events from SDK
+ * @param options - Optional configuration for stream handling
+ * @yields {AGUIEvent} AG-UI event types from the stream
+ * @returns Async iterable of AG-UI event types
+ * @example
+ * ```typescript
+ * const stream = await client.threads.runs.run(threadId, {
+ *   message: { role: "user", content: [{ type: "text", text: "hello" }] },
+ * });
+ *
+ * for await (const event of handleEventStream(stream, { debug: true })) {
+ *   dispatch({ type: 'EVENT', event }); // Send to reducer
+ * }
+ * ```
+ */
+export declare function handleEventStream(stream: AsyncIterable<unknown>, options?: StreamHandlerOptions): AsyncIterable<AGUIEvent>;
+//# sourceMappingURL=stream-handler.d.ts.map

package/dist/utils/stream-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../src/utils/stream-handler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAuB,iBAAiB,CACtC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,SAAS,CAAC,CAY1B"}

package/dist/utils/stream-handler.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Stream Handler for Streaming API
+ *
+ * Provides utilities for handling event streams from the TypeScript SDK.
+ * The SDK's client.threads.runs.run() already returns an async iterable,
+ * so this module just adds optional debug logging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEventStream = handleEventStream;
+/**
+ * Handle an event stream from the TypeScript SDK and yield AG-UI event types.
+ *
+ * The TypeScript SDK's client.threads.runs.run() and client.threads.runs.create()
+ * return async iterables that yield events compatible with AG-UI's AGUIEvent.
+ * This function wraps the stream to add optional debug logging and ensures
+ * proper typing.
+ *
+ * Note: SDK events have `type: string` rather than `type: EventType` enum,
+ * but the values are compatible with AG-UI event types.
+ * @param stream - Async iterable of events from SDK
+ * @param options - Optional configuration for stream handling
+ * @yields {AGUIEvent} AG-UI event types from the stream
+ * @returns Async iterable of AG-UI event types
+ * @example
+ * ```typescript
+ * const stream = await client.threads.runs.run(threadId, {
+ *   message: { role: "user", content: [{ type: "text", text: "hello" }] },
+ * });
+ *
+ * for await (const event of handleEventStream(stream, { debug: true })) {
+ *   dispatch({ type: 'EVENT', event }); // Send to reducer
+ * }
+ * ```
+ */
+async function* handleEventStream(stream, options) {
+    const { debug = false } = options ?? {};
+    for await (const event of stream) {
+        if (debug && process.env.NODE_ENV !== "production") {
+            // eslint-disable-next-line no-console -- debug logging behind flag
+            console.log("[StreamHandler] Event:", event);
+        }
+        // SDK events are compatible with AG-UI AGUIEvent discriminated union
+        yield event;
+    }
+}
+//# sourceMappingURL=stream-handler.js.map

package/dist/utils/stream-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-handler.js","sourceRoot":"","sources":["../../src/utils/stream-handler.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAwCH,8CAeC;AAxCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACI,KAAK,SAAS,CAAC,CAAC,iBAAiB,CACtC,MAA8B,EAC9B,OAA8B;IAE9B,MAAM,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,OAAO,IAAI,EAAE,CAAC;IAExC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,IAAI,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE,CAAC;YACnD,mEAAmE;YACnE,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;QAED,qEAAqE;QACrE,MAAM,KAAkB,CAAC;IAC3B,CAAC;AACH,CAAC","sourcesContent":["/**\n * Stream Handler for Streaming API\n *\n * Provides utilities for handling event streams from the TypeScript SDK.\n * The SDK's client.threads.runs.run() already returns an async iterable,\n * so this module just adds optional debug logging.\n */\n\nimport type { AGUIEvent } from \"@ag-ui/core\";\n\n/**\n * Options for stream handling.\n */\nexport interface StreamHandlerOptions {\n  /**\n   * Enable debug logging (development mode only).\n   * Logs all events to console.\n   */\n  debug?: boolean;\n}\n\n/**\n * Handle an event stream from the TypeScript SDK and yield AG-UI event types.\n *\n * The TypeScript SDK's client.threads.runs.run() and client.threads.runs.create()\n * return async iterables that yield events compatible with AG-UI's AGUIEvent.\n * This function wraps the stream to add optional debug logging and ensures\n * proper typing.\n *\n * Note: SDK events have `type: string` rather than `type: EventType` enum,\n * but the values are compatible with AG-UI event types.\n * @param stream - Async iterable of events from SDK\n * @param options - Optional configuration for stream handling\n * @yields {AGUIEvent} AG-UI event types from the stream\n * @returns Async iterable of AG-UI event types\n * @example\n * ```typescript\n * const stream = await client.threads.runs.run(threadId, {\n *   message: { role: \"user\", content: [{ type: \"text\", text: \"hello\" }] },\n * });\n *\n * for await (const event of handleEventStream(stream, { debug: true })) {\n *   dispatch({ type: 'EVENT', event }); // Send to reducer\n * }\n * ```\n */\nexport async function* handleEventStream(\n  stream: AsyncIterable<unknown>,\n  options?: StreamHandlerOptions,\n): AsyncIterable<AGUIEvent> {\n  const { debug = false } = options ?? {};\n\n  for await (const event of stream) {\n    if (debug && process.env.NODE_ENV !== \"production\") {\n      // eslint-disable-next-line no-console -- debug logging behind flag\n      console.log(\"[StreamHandler] Event:\", event);\n    }\n\n    // SDK events are compatible with AG-UI AGUIEvent discriminated union\n    yield event as AGUIEvent;\n  }\n}\n"]}

package/dist/utils/thread-utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Thread utility functions for searching and accessing thread content.
+ */
+import type { StreamState } from "./event-accumulator";
+import type { TamboComponentContent } from "../types/message";
+/**
+ * Find a component content block by ID in a specific thread.
+ * Searches from most recent messages first since active components are likely near the tail.
+ * Only searches the specified thread to prevent cross-thread data access.
+ * @param streamState - The current stream state containing thread data
+ * @param threadId - The thread ID to search in
+ * @param componentId - The component ID to find
+ * @returns The component content block, or undefined if not found
+ */
+export declare function findComponentContent(streamState: StreamState, threadId: string, componentId: string): TamboComponentContent | undefined;
+//# sourceMappingURL=thread-utils.d.ts.map

package/dist/utils/thread-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-utils.d.ts","sourceRoot":"","sources":["../../src/utils/thread-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CAkBnC"}

package/dist/utils/thread-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Thread utility functions for searching and accessing thread content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findComponentContent = findComponentContent;
+/**
+ * Find a component content block by ID in a specific thread.
+ * Searches from most recent messages first since active components are likely near the tail.
+ * Only searches the specified thread to prevent cross-thread data access.
+ * @param streamState - The current stream state containing thread data
+ * @param threadId - The thread ID to search in
+ * @param componentId - The component ID to find
+ * @returns The component content block, or undefined if not found
+ */
+function findComponentContent(streamState, threadId, componentId) {
+    const threadState = streamState.threadMap[threadId];
+    if (!threadState) {
+        return undefined;
+    }
+    // Search from most recent messages first for better performance
+    const messages = threadState.thread.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const content = messages[i].content;
+        for (let j = content.length - 1; j >= 0; j--) {
+            const block = content[j];
+            if (block.type === "component" && block.id === componentId) {
+                return block;
+            }
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=thread-utils.js.map

package/dist/utils/thread-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-utils.js","sourceRoot":"","sources":["../../src/utils/thread-utils.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAcH,oDAsBC;AA/BD;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAClC,WAAwB,EACxB,QAAgB,EAChB,WAAmB;IAEnB,MAAM,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACpD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,gEAAgE;IAChE,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QACpC,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,IAAI,KAAK,CAAC,EAAE,KAAK,WAAW,EAAE,CAAC;gBAC3D,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n * Thread utility functions for searching and accessing thread content.\n */\n\nimport type { StreamState } from \"./event-accumulator\";\nimport type { TamboComponentContent } from \"../types/message\";\n\n/**\n * Find a component content block by ID in a specific thread.\n * Searches from most recent messages first since active components are likely near the tail.\n * Only searches the specified thread to prevent cross-thread data access.\n * @param streamState - The current stream state containing thread data\n * @param threadId - The thread ID to search in\n * @param componentId - The component ID to find\n * @returns The component content block, or undefined if not found\n */\nexport function findComponentContent(\n  streamState: StreamState,\n  threadId: string,\n  componentId: string,\n): TamboComponentContent | undefined {\n  const threadState = streamState.threadMap[threadId];\n  if (!threadState) {\n    return undefined;\n  }\n\n  // Search from most recent messages first for better performance\n  const messages = threadState.thread.messages;\n  for (let i = messages.length - 1; i >= 0; i--) {\n    const content = messages[i].content;\n    for (let j = content.length - 1; j >= 0; j--) {\n      const block = content[j];\n      if (block.type === \"component\" && block.id === componentId) {\n        return block;\n      }\n    }\n  }\n  return undefined;\n}\n"]}

package/dist/utils/tool-call-tracker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Tool Call Tracker
+ *
+ * Tracks tool calls during streaming, accumulating arguments until complete.
+ * Owns the tool name → JSON Schema mapping and handles unstrictification
+ * so callers don't need to know about schema conversion.
+ */
+import { type AGUIEvent } from "@ag-ui/core";
+import type { JSONSchema7 } from "json-schema";
+import type { TamboTool } from "../model/component-metadata";
+import type { PendingToolCall } from "./tool-executor";
+/**
+ * Tracks tool calls during streaming, accumulating arguments until complete.
+ *
+ * Tool calls arrive as a sequence of events:
+ * 1. TOOL_CALL_START - initializes the tool call with name
+ * 2. TOOL_CALL_ARGS (multiple) - streams JSON argument fragments
+ * 3. TOOL_CALL_END - marks the tool call as complete, triggers JSON parsing
+ *
+ * When constructed with a tool registry, the tracker unstrictifies parsed
+ * args (both partial and final) using the original JSON Schemas.
+ */
+export declare class ToolCallTracker {
+    private pendingToolCalls;
+    private accumulatingArgs;
+    private _toolSchemas;
+    constructor(toolRegistry?: Record<string, TamboTool>);
+    /**
+     * The tool-name → JSONSchema7 map, for passing to the reducer.
+     * @returns The tool schemas map
+     */
+    get toolSchemas(): Map<string, JSONSchema7>;
+    /**
+     * Handles a streaming event, tracking tool call state as needed.
+     * @param event - The streaming event to process
+     * @throws {Error} If JSON parsing fails on TOOL_CALL_END (fail-fast, no silent fallback)
+     */
+    handleEvent(event: AGUIEvent): void;
+    /**
+     * Parses partial JSON from the accumulated args for a tool call and
+     * unstrictifies the result. Used during streaming to get the current
+     * best-effort parsed args.
+     * @param toolCallId - ID of the tool call to parse
+     * @returns Parsed and unstrictified args, or undefined if not parseable yet
+     */
+    parsePartialArgs(toolCallId: string): Record<string, unknown> | undefined;
+    /**
+     * Gets the name and accumulated args for a tool call that is still accumulating.
+     * @param toolCallId - ID of the tool call to look up
+     * @returns The tool name and raw accumulated args string, or undefined if not found
+     */
+    getAccumulatingToolCall(toolCallId: string): {
+        name: string;
+        accumulatedArgs: string;
+    } | undefined;
+    /**
+     * Gets tool calls for the given IDs, filtered to only those that exist.
+     * @param toolCallIds - IDs of tool calls to retrieve
+     * @returns Map of tool call ID to pending tool call
+     */
+    getToolCallsById(toolCallIds: string[]): Map<string, PendingToolCall>;
+    /**
+     * Clears tracked tool calls for the given IDs.
+     * @param toolCallIds - IDs of tool calls to clear
+     */
+    clearToolCalls(toolCallIds: string[]): void;
+    /**
+     * Unstrictify params using the schema for the given tool name.
+     * Returns params unchanged if no schema is available.
+     * @returns The unstrictified params.
+     */
+    private unstrictify;
+}
+//# sourceMappingURL=tool-call-tracker.d.ts.map

package/dist/utils/tool-call-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-tracker.d.ts","sourceRoot":"","sources":["../../src/utils/tool-call-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AA4BvD;;;;;;;;;;GAUG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,YAAY,CAA2B;gBAEnC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAMpD;;;OAGG;IACH,IAAI,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAE1C;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IA6CnC;;;;;;OAMG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAsBzE;;;;OAIG;IACH,uBAAuB,CACrB,UAAU,EAAE,MAAM,GACjB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAOxD;;;;OAIG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC;IAWrE;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,IAAI;IAO3C;;;;OAIG;IACH,OAAO,CAAC,WAAW;CAQpB"}