@tambo-ai/react 1.0.3 → 1.2.0

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

@@ -1,45 +0,0 @@
-/**
- * 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/v1/utils/stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../../src/v1/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/v1/utils/stream-handler.js

@@ -1,47 +0,0 @@
-"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
-            console.log("[StreamHandler] Event:", event);
-        }
-        // SDK events are compatible with AG-UI AGUIEvent discriminated union
-        yield event;
-    }
-}
-//# sourceMappingURL=stream-handler.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream-handler.js","sourceRoot":"","sources":["../../../src/v1/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,sCAAsC;YACtC,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\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/v1/utils/thread-utils.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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/v1/utils/thread-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread-utils.d.ts","sourceRoot":"","sources":["../../../src/v1/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/v1/utils/thread-utils.js

@@ -1,34 +0,0 @@
-"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/v1/utils/thread-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread-utils.js","sourceRoot":"","sources":["../../../src/v1/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/v1/utils/tool-call-tracker.d.ts

@@ -1,73 +0,0 @@
-/**
- * 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.
-     */
-    private unstrictify;
-}
-//# sourceMappingURL=tool-call-tracker.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool-call-tracker.d.ts","sourceRoot":"","sources":["../../../src/v1/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,gCAAgC,CAAC;AAEhE,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;;;OAGG;IACH,OAAO,CAAC,WAAW;CAQpB"}

package/dist/v1/utils/tool-call-tracker.js

@@ -1,180 +0,0 @@
-"use strict";
-/**
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolCallTracker = void 0;
-const core_1 = require("@ag-ui/core");
-const partial_json_1 = require("partial-json");
-const schema_1 = require("../../schema/schema");
-const unstrictify_1 = require("./unstrictify");
-/**
- * Build a tool-name → JSONSchema7 map from the tool registry.
- * Handles both modern `inputSchema` and deprecated `toolSchema` formats.
- * Tools whose schema can't be converted are silently skipped.
- * @param toolRegistry - Record of tool name → tool definition
- * @returns Map of tool name → JSON Schema
- */
-function buildToolSchemas(toolRegistry) {
-    const schemas = new Map();
-    for (const tool of Object.values(toolRegistry)) {
-        try {
-            if ("inputSchema" in tool && tool.inputSchema) {
-                schemas.set(tool.name, (0, schema_1.schemaToJsonSchema)(tool.inputSchema));
-            }
-            else if ("toolSchema" in tool && tool.toolSchema) {
-                schemas.set(tool.name, (0, schema_1.schemaToJsonSchema)(tool.toolSchema));
-            }
-        }
-        catch {
-            // Schema conversion failed — tool still works, just without unstrictification
-        }
-    }
-    return schemas;
-}
-/**
- * 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.
- */
-class ToolCallTracker {
-    pendingToolCalls = new Map();
-    accumulatingArgs = new Map();
-    _toolSchemas;
-    constructor(toolRegistry) {
-        this._toolSchemas = toolRegistry
-            ? buildToolSchemas(toolRegistry)
-            : new Map();
-    }
-    /**
-     * The tool-name → JSONSchema7 map, for passing to the reducer.
-     * @returns The tool schemas map
-     */
-    get toolSchemas() {
-        return this._toolSchemas;
-    }
-    /**
-     * 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) {
-        switch (event.type) {
-            case core_1.EventType.TOOL_CALL_START:
-                this.pendingToolCalls.set(event.toolCallId, {
-                    name: event.toolCallName,
-                    input: {},
-                });
-                this.accumulatingArgs.set(event.toolCallId, "");
-                break;
-            case core_1.EventType.TOOL_CALL_ARGS: {
-                const current = this.accumulatingArgs.get(event.toolCallId);
-                this.accumulatingArgs.set(event.toolCallId, (current ?? "") + event.delta);
-                break;
-            }
-            case core_1.EventType.TOOL_CALL_END: {
-                const jsonStr = this.accumulatingArgs.get(event.toolCallId);
-                const toolCall = this.pendingToolCalls.get(event.toolCallId);
-                if (toolCall && jsonStr) {
-                    let parsedInput;
-                    try {
-                        parsedInput = JSON.parse(jsonStr);
-                    }
-                    catch (error) {
-                        // Fail-fast: don't silently continue with empty input
-                        throw new Error(`Failed to parse tool call arguments for ${event.toolCallId}: ${error instanceof Error ? error.message : "Unknown error"}. JSON: ${jsonStr.slice(0, 100)}${jsonStr.length > 100 ? "..." : ""}`);
-                    }
-                    parsedInput = this.unstrictify(toolCall.name, parsedInput);
-                    toolCall.input = parsedInput;
-                }
-                break;
-            }
-            default:
-                // Other event types are ignored - only tool call events are tracked
-                break;
-        }
-    }
-    /**
-     * 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) {
-        const accToolCall = this.getAccumulatingToolCall(toolCallId);
-        if (!accToolCall)
-            return undefined;
-        try {
-            const parsed = (0, partial_json_1.parse)(accToolCall.accumulatedArgs);
-            if (typeof parsed === "object" &&
-                parsed !== null &&
-                !Array.isArray(parsed)) {
-                return this.unstrictify(accToolCall.name, parsed);
-            }
-        }
-        catch {
-            /* not parseable yet */
-        }
-        return 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) {
-        const toolCall = this.pendingToolCalls.get(toolCallId);
-        const args = this.accumulatingArgs.get(toolCallId);
-        if (!toolCall || args === undefined)
-            return undefined;
-        return { name: toolCall.name, accumulatedArgs: args };
-    }
-    /**
-     * 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) {
-        const result = new Map();
-        for (const id of toolCallIds) {
-            const toolCall = this.pendingToolCalls.get(id);
-            if (toolCall) {
-                result.set(id, toolCall);
-            }
-        }
-        return result;
-    }
-    /**
-     * Clears tracked tool calls for the given IDs.
-     * @param toolCallIds - IDs of tool calls to clear
-     */
-    clearToolCalls(toolCallIds) {
-        for (const id of toolCallIds) {
-            this.pendingToolCalls.delete(id);
-            this.accumulatingArgs.delete(id);
-        }
-    }
-    /**
-     * Unstrictify params using the schema for the given tool name.
-     * Returns params unchanged if no schema is available.
-     */
-    unstrictify(toolName, params) {
-        const schema = this._toolSchemas.get(toolName);
-        if (!schema)
-            return params;
-        return (0, unstrictify_1.unstrictifyToolCallParamsFromSchema)(schema, params);
-    }
-}
-exports.ToolCallTracker = ToolCallTracker;
-//# sourceMappingURL=tool-call-tracker.js.map

package/dist/v1/utils/tool-call-tracker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-call-tracker.js","sourceRoot":"","sources":["../../../src/v1/utils/tool-call-tracker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tool Call Tracker\n *\n * Tracks tool calls during streaming, accumulating arguments until complete.\n * Owns the tool name → JSON Schema mapping and handles unstrictification\n * so callers don't need to know about schema conversion.\n */\n\nimport { EventType, type AGUIEvent } from \"@ag-ui/core\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { parse as parsePartialJson } from \"partial-json\";\nimport type { TamboTool } from \"../../model/component-metadata\";\nimport { schemaToJsonSchema } from \"../../schema/schema\";\nimport type { PendingToolCall } from \"./tool-executor\";\nimport { unstrictifyToolCallParamsFromSchema } from \"./unstrictify\";\n\n/**\n * Build a tool-name → JSONSchema7 map from the tool registry.\n * Handles both modern `inputSchema` and deprecated `toolSchema` formats.\n * Tools whose schema can't be converted are silently skipped.\n * @param toolRegistry - Record of tool name → tool definition\n * @returns Map of tool name → JSON Schema\n */\nfunction buildToolSchemas(\n  toolRegistry: Record<string, TamboTool>,\n): Map<string, JSONSchema7> {\n  const schemas = new Map<string, JSONSchema7>();\n  for (const tool of Object.values(toolRegistry)) {\n    try {\n      if (\"inputSchema\" in tool && tool.inputSchema) {\n        schemas.set(tool.name, schemaToJsonSchema(tool.inputSchema));\n      } else if (\"toolSchema\" in tool && tool.toolSchema) {\n        schemas.set(tool.name, schemaToJsonSchema(tool.toolSchema));\n      }\n    } catch {\n      // Schema conversion failed — tool still works, just without unstrictification\n    }\n  }\n  return schemas;\n}\n\n/**\n * Tracks tool calls during streaming, accumulating arguments until complete.\n *\n * Tool calls arrive as a sequence of events:\n * 1. TOOL_CALL_START - initializes the tool call with name\n * 2. TOOL_CALL_ARGS (multiple) - streams JSON argument fragments\n * 3. TOOL_CALL_END - marks the tool call as complete, triggers JSON parsing\n *\n * When constructed with a tool registry, the tracker unstrictifies parsed\n * args (both partial and final) using the original JSON Schemas.\n */\nexport class ToolCallTracker {\n  private pendingToolCalls = new Map<string, PendingToolCall>();\n  private accumulatingArgs = new Map<string, string>();\n  private _toolSchemas: Map<string, JSONSchema7>;\n\n  constructor(toolRegistry?: Record<string, TamboTool>) {\n    this._toolSchemas = toolRegistry\n      ? buildToolSchemas(toolRegistry)\n      : new Map();\n  }\n\n  /**\n   * The tool-name → JSONSchema7 map, for passing to the reducer.\n   * @returns The tool schemas map\n   */\n  get toolSchemas(): Map<string, JSONSchema7> {\n    return this._toolSchemas;\n  }\n\n  /**\n   * Handles a streaming event, tracking tool call state as needed.\n   * @param event - The streaming event to process\n   * @throws {Error} If JSON parsing fails on TOOL_CALL_END (fail-fast, no silent fallback)\n   */\n  handleEvent(event: AGUIEvent): void {\n    switch (event.type) {\n      case EventType.TOOL_CALL_START:\n        this.pendingToolCalls.set(event.toolCallId, {\n          name: event.toolCallName,\n          input: {},\n        });\n        this.accumulatingArgs.set(event.toolCallId, \"\");\n        break;\n\n      case EventType.TOOL_CALL_ARGS: {\n        const current = this.accumulatingArgs.get(event.toolCallId);\n        this.accumulatingArgs.set(\n          event.toolCallId,\n          (current ?? \"\") + event.delta,\n        );\n        break;\n      }\n\n      case EventType.TOOL_CALL_END: {\n        const jsonStr = this.accumulatingArgs.get(event.toolCallId);\n        const toolCall = this.pendingToolCalls.get(event.toolCallId);\n        if (toolCall && jsonStr) {\n          let parsedInput: Record<string, unknown>;\n          try {\n            parsedInput = JSON.parse(jsonStr) as Record<string, unknown>;\n          } catch (error) {\n            // Fail-fast: don't silently continue with empty input\n            throw new Error(\n              `Failed to parse tool call arguments for ${event.toolCallId}: ${error instanceof Error ? error.message : \"Unknown error\"}. JSON: ${jsonStr.slice(0, 100)}${jsonStr.length > 100 ? \"...\" : \"\"}`,\n            );\n          }\n\n          parsedInput = this.unstrictify(toolCall.name, parsedInput);\n          toolCall.input = parsedInput;\n        }\n        break;\n      }\n\n      default:\n        // Other event types are ignored - only tool call events are tracked\n        break;\n    }\n  }\n\n  /**\n   * Parses partial JSON from the accumulated args for a tool call and\n   * unstrictifies the result. Used during streaming to get the current\n   * best-effort parsed args.\n   * @param toolCallId - ID of the tool call to parse\n   * @returns Parsed and unstrictified args, or undefined if not parseable yet\n   */\n  parsePartialArgs(toolCallId: string): Record<string, unknown> | undefined {\n    const accToolCall = this.getAccumulatingToolCall(toolCallId);\n    if (!accToolCall) return undefined;\n\n    try {\n      const parsed: unknown = parsePartialJson(accToolCall.accumulatedArgs);\n      if (\n        typeof parsed === \"object\" &&\n        parsed !== null &&\n        !Array.isArray(parsed)\n      ) {\n        return this.unstrictify(\n          accToolCall.name,\n          parsed as Record<string, unknown>,\n        );\n      }\n    } catch {\n      /* not parseable yet */\n    }\n    return undefined;\n  }\n\n  /**\n   * Gets the name and accumulated args for a tool call that is still accumulating.\n   * @param toolCallId - ID of the tool call to look up\n   * @returns The tool name and raw accumulated args string, or undefined if not found\n   */\n  getAccumulatingToolCall(\n    toolCallId: string,\n  ): { name: string; accumulatedArgs: string } | undefined {\n    const toolCall = this.pendingToolCalls.get(toolCallId);\n    const args = this.accumulatingArgs.get(toolCallId);\n    if (!toolCall || args === undefined) return undefined;\n    return { name: toolCall.name, accumulatedArgs: args };\n  }\n\n  /**\n   * Gets tool calls for the given IDs, filtered to only those that exist.\n   * @param toolCallIds - IDs of tool calls to retrieve\n   * @returns Map of tool call ID to pending tool call\n   */\n  getToolCallsById(toolCallIds: string[]): Map<string, PendingToolCall> {\n    const result = new Map<string, PendingToolCall>();\n    for (const id of toolCallIds) {\n      const toolCall = this.pendingToolCalls.get(id);\n      if (toolCall) {\n        result.set(id, toolCall);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Clears tracked tool calls for the given IDs.\n   * @param toolCallIds - IDs of tool calls to clear\n   */\n  clearToolCalls(toolCallIds: string[]): void {\n    for (const id of toolCallIds) {\n      this.pendingToolCalls.delete(id);\n      this.accumulatingArgs.delete(id);\n    }\n  }\n\n  /**\n   * Unstrictify params using the schema for the given tool name.\n   * Returns params unchanged if no schema is available.\n   */\n  private unstrictify(\n    toolName: string,\n    params: Record<string, unknown>,\n  ): Record<string, unknown> {\n    const schema = this._toolSchemas.get(toolName);\n    if (!schema) return params;\n    return unstrictifyToolCallParamsFromSchema(schema, params);\n  }\n}\n"]}

package/dist/v1/utils/tool-executor.d.ts

@@ -1,67 +0,0 @@
-/**
- * Tool Executor
- *
- * Handles automatic execution of client-side tools when the model
- * requests them via `tambo.run.awaiting_input` events.
- */
-import type { TamboTool } from "../../model/component-metadata";
-import type { ToolResultContent } from "@tambo-ai/typescript-sdk/resources/threads/threads";
-import type { ToolCallTracker } from "./tool-call-tracker";
-import { type KeyedThrottle } from "./keyed-throttle";
-/**
- * Pending tool call from the stream accumulator
- */
-export interface PendingToolCall {
-    name: string;
-    input: Record<string, unknown>;
-}
-/**
- * Execute a streamable tool call during streaming with pre-parsed partial args.
- *
- * Called on each TOOL_CALL_ARGS event for tools annotated with
- * `tamboStreamableHint: true`. Enables incremental UI updates while
- * the model is still generating arguments.
- *
- * Errors are caught silently — streaming tool execution is non-fatal since
- * the final execution via `awaiting_input` is what matters.
- * @param toolCallId - The tool call ID being accumulated
- * @param parsedArgs - Pre-parsed partial JSON args
- * @param toolTracker - Tracker holding pending tool call state
- * @param toolRegistry - Record of tool name to tool definition
- */
-export declare function executeStreamableToolCall(toolCallId: string, parsedArgs: Record<string, unknown>, toolTracker: ToolCallTracker, toolRegistry: Record<string, TamboTool>): Promise<void>;
-/**
- * Creates a throttled wrapper around executeStreamableToolCall.
- *
- * Each tool call ID gets its own independent leading+trailing throttle via
- * {@link createKeyedThrottle}. The first call for a tool ID fires immediately
- * (leading edge). Subsequent calls during the cooldown window update the
- * stored args. After `delay` ms, if new args arrived, the tool re-executes
- * with the latest args (trailing edge). This repeats as long as new args
- * keep arriving — roughly one execution per `delay` ms during streaming.
- *
- * Call `flush()` to force-execute all pending trailing calls and reset to idle.
- * @param toolTracker - Tracker holding pending tool call state
- * @param toolRegistry - Record of tool name to tool definition
- * @param delay - Throttle interval in milliseconds
- * @returns Keyed throttle controller (schedule / flush)
- */
-export declare function createThrottledStreamableExecutor(toolTracker: ToolCallTracker, toolRegistry: Record<string, TamboTool>, delay?: number): KeyedThrottle<Record<string, unknown>>;
-/**
- * Execute a single client-side tool and return the result.
- * @param tool - The tool definition from the registry
- * @param toolCallId - The ID of the tool call to respond to
- * @param args - The parsed arguments for the tool
- * @returns ToolResultContent with the execution result or error
- */
-export declare function executeClientTool(tool: TamboTool, toolCallId: string, args: Record<string, unknown>): Promise<ToolResultContent>;
-/**
- * Execute all pending tool calls and return their results.
- * Tools are executed sequentially to avoid race conditions when
- * tools may have side effects that depend on each other.
- * @param toolCalls - Map of tool call IDs to their call details
- * @param registry - Registry of tool names to their definitions (Map or Record)
- * @returns Array of ToolResultContent for all executed tools
- */
-export declare function executeAllPendingTools(toolCalls: Map<string, PendingToolCall>, registry: Map<string, TamboTool> | Record<string, TamboTool>): Promise<ToolResultContent[]>;
-//# sourceMappingURL=tool-executor.d.ts.map

package/dist/v1/utils/tool-executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-executor.d.ts","sourceRoot":"","sources":["../../../src/v1/utils/tool-executor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,oDAAoD,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,WAAW,EAAE,eAAe,EAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC,CAiBf;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,eAAe,EAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACvC,KAAK,SAAiC,GACrC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAIxC;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,iBAAiB,CAAC,CAiD5B;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,EACvC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC3D,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAiC9B"}