@tambo-ai/react 1.1.0 → 1.2.0

package/dist/v1/utils/tool-executor.js

@@ -1,160 +0,0 @@
-"use strict";
-/**
- * Tool Executor
- *
- * Handles automatic execution of client-side tools when the model
- * requests them via `tambo.run.awaiting_input` events.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeStreamableToolCall = executeStreamableToolCall;
-exports.createThrottledStreamableExecutor = createThrottledStreamableExecutor;
-exports.executeClientTool = executeClientTool;
-exports.executeAllPendingTools = executeAllPendingTools;
-const keyed_throttle_1 = require("./keyed-throttle");
-/**
- * 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
- */
-async function executeStreamableToolCall(toolCallId, parsedArgs, toolTracker, toolRegistry) {
-    const accumulating = toolTracker.getAccumulatingToolCall(toolCallId);
-    if (!accumulating)
-        return;
-    const tool = toolRegistry[accumulating.name];
-    if (!tool?.annotations?.tamboStreamableHint)
-        return;
-    try {
-        await tool.tool(parsedArgs);
-    }
-    catch (error) {
-        console.warn(`[ToolExecutor] Non-fatal error in streamable tool "${accumulating.name}" ` +
-            `(toolCallId: ${toolCallId}). This likely indicates a bug in the tool ` +
-            `implementation; fix the tool to avoid repeated warnings.`, error);
-    }
-}
-const DEFAULT_STREAMABLE_THROTTLE_MS = 100;
-/**
- * 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)
- */
-function createThrottledStreamableExecutor(toolTracker, toolRegistry, delay = DEFAULT_STREAMABLE_THROTTLE_MS) {
-    return (0, keyed_throttle_1.createKeyedThrottle)((toolCallId, args) => {
-        void executeStreamableToolCall(toolCallId, args, toolTracker, toolRegistry);
-    }, delay);
-}
-/**
- * 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
- */
-async function executeClientTool(tool, toolCallId, args) {
-    try {
-        const result = await tool.tool(args);
-        // Transform result to content if transformer provided
-        let content;
-        if (tool.transformToContent) {
-            // transformToContent may return content parts in beta format
-            // Convert to content format (TextContent | ResourceContent)
-            const transformed = await tool.transformToContent(result);
-            content = transformed.map((part) => {
-                if (part.type === "text" && "text" in part && part.text) {
-                    return { type: "text", text: part.text };
-                }
-                // For other types, stringify as text
-                return {
-                    type: "text",
-                    text: JSON.stringify(part),
-                };
-            });
-        }
-        else {
-            // Default: stringify result as text
-            content = [
-                {
-                    type: "text",
-                    text: typeof result === "string" ? result : JSON.stringify(result),
-                },
-            ];
-        }
-        return {
-            type: "tool_result",
-            toolUseId: toolCallId,
-            content,
-        };
-    }
-    catch (error) {
-        return {
-            type: "tool_result",
-            toolUseId: toolCallId,
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: error instanceof Error ? error.message : "Tool execution failed",
-                },
-            ],
-        };
-    }
-}
-/**
- * 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
- */
-async function executeAllPendingTools(toolCalls, registry) {
-    const results = [];
-    // Normalize registry to allow lookup regardless of Map or Record
-    const getTool = (name) => {
-        if (registry instanceof Map) {
-            return registry.get(name);
-        }
-        return registry[name];
-    };
-    for (const [toolCallId, { name, input }] of toolCalls) {
-        const tool = getTool(name);
-        if (!tool) {
-            results.push({
-                type: "tool_result",
-                toolUseId: toolCallId,
-                isError: true,
-                content: [
-                    {
-                        type: "text",
-                        text: `Tool "${name}" not found in registry`,
-                    },
-                ],
-            });
-            continue;
-        }
-        const result = await executeClientTool(tool, toolCallId, input);
-        results.push(result);
-    }
-    return results;
-}
-//# sourceMappingURL=tool-executor.js.map

package/dist/v1/utils/tool-executor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-executor.js","sourceRoot":"","sources":["../../../src/v1/utils/tool-executor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tool Executor\n *\n * Handles automatic execution of client-side tools when the model\n * requests them via `tambo.run.awaiting_input` events.\n */\n\nimport type { TamboTool } from \"../../model/component-metadata\";\nimport type {\n  ToolResultContent,\n  TextContent,\n  ResourceContent,\n} from \"@tambo-ai/typescript-sdk/resources/threads/threads\";\nimport type { ToolCallTracker } from \"./tool-call-tracker\";\nimport { createKeyedThrottle, type KeyedThrottle } from \"./keyed-throttle\";\n\n/**\n * Pending tool call from the stream accumulator\n */\nexport interface PendingToolCall {\n  name: string;\n  input: Record<string, unknown>;\n}\n\n/**\n * Execute a streamable tool call during streaming with pre-parsed partial args.\n *\n * Called on each TOOL_CALL_ARGS event for tools annotated with\n * `tamboStreamableHint: true`. Enables incremental UI updates while\n * the model is still generating arguments.\n *\n * Errors are caught silently — streaming tool execution is non-fatal since\n * the final execution via `awaiting_input` is what matters.\n * @param toolCallId - The tool call ID being accumulated\n * @param parsedArgs - Pre-parsed partial JSON args\n * @param toolTracker - Tracker holding pending tool call state\n * @param toolRegistry - Record of tool name to tool definition\n */\nexport async function executeStreamableToolCall(\n  toolCallId: string,\n  parsedArgs: Record<string, unknown>,\n  toolTracker: ToolCallTracker,\n  toolRegistry: Record<string, TamboTool>,\n): Promise<void> {\n  const accumulating = toolTracker.getAccumulatingToolCall(toolCallId);\n  if (!accumulating) return;\n\n  const tool = toolRegistry[accumulating.name];\n  if (!tool?.annotations?.tamboStreamableHint) return;\n\n  try {\n    await tool.tool(parsedArgs);\n  } catch (error) {\n    console.warn(\n      `[ToolExecutor] Non-fatal error in streamable tool \"${accumulating.name}\" ` +\n        `(toolCallId: ${toolCallId}). This likely indicates a bug in the tool ` +\n        `implementation; fix the tool to avoid repeated warnings.`,\n      error,\n    );\n  }\n}\n\nconst DEFAULT_STREAMABLE_THROTTLE_MS = 100;\n\n/**\n * Creates a throttled wrapper around executeStreamableToolCall.\n *\n * Each tool call ID gets its own independent leading+trailing throttle via\n * {@link createKeyedThrottle}. The first call for a tool ID fires immediately\n * (leading edge). Subsequent calls during the cooldown window update the\n * stored args. After `delay` ms, if new args arrived, the tool re-executes\n * with the latest args (trailing edge). This repeats as long as new args\n * keep arriving — roughly one execution per `delay` ms during streaming.\n *\n * Call `flush()` to force-execute all pending trailing calls and reset to idle.\n * @param toolTracker - Tracker holding pending tool call state\n * @param toolRegistry - Record of tool name to tool definition\n * @param delay - Throttle interval in milliseconds\n * @returns Keyed throttle controller (schedule / flush)\n */\nexport function createThrottledStreamableExecutor(\n  toolTracker: ToolCallTracker,\n  toolRegistry: Record<string, TamboTool>,\n  delay = DEFAULT_STREAMABLE_THROTTLE_MS,\n): KeyedThrottle<Record<string, unknown>> {\n  return createKeyedThrottle<Record<string, unknown>>((toolCallId, args) => {\n    void executeStreamableToolCall(toolCallId, args, toolTracker, toolRegistry);\n  }, delay);\n}\n\n/**\n * Execute a single client-side tool and return the result.\n * @param tool - The tool definition from the registry\n * @param toolCallId - The ID of the tool call to respond to\n * @param args - The parsed arguments for the tool\n * @returns ToolResultContent with the execution result or error\n */\nexport async function executeClientTool(\n  tool: TamboTool,\n  toolCallId: string,\n  args: Record<string, unknown>,\n): Promise<ToolResultContent> {\n  try {\n    const result = await tool.tool(args);\n\n    // Transform result to content if transformer provided\n    let content: (TextContent | ResourceContent)[];\n    if (tool.transformToContent) {\n      // transformToContent may return content parts in beta format\n      // Convert to content format (TextContent | ResourceContent)\n      const transformed = await tool.transformToContent(result);\n      content = transformed.map((part) => {\n        if (part.type === \"text\" && \"text\" in part && part.text) {\n          return { type: \"text\" as const, text: part.text };\n        }\n        // For other types, stringify as text\n        return {\n          type: \"text\" as const,\n          text: JSON.stringify(part),\n        };\n      });\n    } else {\n      // Default: stringify result as text\n      content = [\n        {\n          type: \"text\" as const,\n          text: typeof result === \"string\" ? result : JSON.stringify(result),\n        },\n      ];\n    }\n\n    return {\n      type: \"tool_result\",\n      toolUseId: toolCallId,\n      content,\n    };\n  } catch (error) {\n    return {\n      type: \"tool_result\",\n      toolUseId: toolCallId,\n      isError: true,\n      content: [\n        {\n          type: \"text\" as const,\n          text:\n            error instanceof Error ? error.message : \"Tool execution failed\",\n        },\n      ],\n    };\n  }\n}\n\n/**\n * Execute all pending tool calls and return their results.\n * Tools are executed sequentially to avoid race conditions when\n * tools may have side effects that depend on each other.\n * @param toolCalls - Map of tool call IDs to their call details\n * @param registry - Registry of tool names to their definitions (Map or Record)\n * @returns Array of ToolResultContent for all executed tools\n */\nexport async function executeAllPendingTools(\n  toolCalls: Map<string, PendingToolCall>,\n  registry: Map<string, TamboTool> | Record<string, TamboTool>,\n): Promise<ToolResultContent[]> {\n  const results: ToolResultContent[] = [];\n\n  // Normalize registry to allow lookup regardless of Map or Record\n  const getTool = (name: string): TamboTool | undefined => {\n    if (registry instanceof Map) {\n      return registry.get(name);\n    }\n    return registry[name];\n  };\n\n  for (const [toolCallId, { name, input }] of toolCalls) {\n    const tool = getTool(name);\n    if (!tool) {\n      results.push({\n        type: \"tool_result\",\n        toolUseId: toolCallId,\n        isError: true,\n        content: [\n          {\n            type: \"text\" as const,\n            text: `Tool \"${name}\" not found in registry`,\n          },\n        ],\n      });\n      continue;\n    }\n\n    const result = await executeClientTool(tool, toolCallId, input);\n    results.push(result);\n  }\n\n  return results;\n}\n"]}

package/dist/v1/utils/unstrictify.d.ts

@@ -1,32 +0,0 @@
-/**
- * Unstrictify tool call parameters using the original JSON Schema.
- *
- * When OpenAI's structured outputs mode is enabled, all optional parameters
- * become required-and-nullable. The LLM then sends `null` for parameters the
- * user didn't specify. This module reverses that transformation by comparing
- * the LLM's output against the original schema and stripping nulls for
- * parameters that were originally optional and non-nullable.
- *
- * Copied from packages/core/src/strictness/tool-call-strict.ts (minus the
- * OpenAI-specific `unstrictifyToolCallRequest` wrapper).
- */
-import type { JSONSchema7, JSONSchema7Definition } from "json-schema";
-/**
- * Unstrictify tool call params using the original JSON Schema.
- *
- * Unlike the private `unstrictifyToolCallParams` which throws on unknown params,
- * this function separates params into schema-defined vs `_tambo_*` pass-through
- * (server-injected params not in the original schema), unstrictifies only the
- * schema-defined ones, and merges pass-through params back. Unknown keys that
- * aren't in the schema and don't have the `_tambo_` prefix are dropped.
- * @returns The params with strictification-induced nulls stripped for optional
- * non-nullable properties, and pass-through params preserved as-is.
- */
-export declare function unstrictifyToolCallParamsFromSchema(originalSchema: JSONSchema7, params: Record<string, unknown>): Record<string, unknown>;
-/**
- * Check if a JSON Schema definition allows null values.
- * @param originalSchema - The schema definition to check
- * @returns True if the schema allows null values
- */
-export declare function canBeNull(originalSchema: JSONSchema7Definition): boolean;
-//# sourceMappingURL=unstrictify.d.ts.map

package/dist/v1/utils/unstrictify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unstrictify.d.ts","sourceRoot":"","sources":["../../../src/v1/utils/unstrictify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAsItE;;;;;;;;;;GAUG;AACH,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,WAAW,EAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,cAAc,EAAE,qBAAqB,GAAG,OAAO,CAaxE"}

package/dist/v1/utils/unstrictify.js

@@ -1,159 +0,0 @@
-"use strict";
-/**
- * Unstrictify tool call parameters using the original JSON Schema.
- *
- * When OpenAI's structured outputs mode is enabled, all optional parameters
- * become required-and-nullable. The LLM then sends `null` for parameters the
- * user didn't specify. This module reverses that transformation by comparing
- * the LLM's output against the original schema and stripping nulls for
- * parameters that were originally optional and non-nullable.
- *
- * Copied from packages/core/src/strictness/tool-call-strict.ts (minus the
- * OpenAI-specific `unstrictifyToolCallRequest` wrapper).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unstrictifyToolCallParamsFromSchema = unstrictifyToolCallParamsFromSchema;
-exports.canBeNull = canBeNull;
-/**
- * Unstrictify the parameters of a tool call request.
- *
- * This effectively reverses the process of strictifyToolCallParams, for a
- * tool call request that was built from a strict JSON Schema, by returning a
- * updated tool call request with the parameter values unstrictified.
- */
-function unstrictifyToolCallParams(originalToolParamSchema, toolCallRequestParams) {
-    if (originalToolParamSchema.type !== "object") {
-        throw new Error(`tool call parameter schema must be an object, instead got ${originalToolParamSchema.type} / ${typeof originalToolParamSchema}`);
-    }
-    const newParams = Object.entries(toolCallRequestParams)
-        .map(([parameterName, parameterValue]) => {
-        const isRequired = originalToolParamSchema.required?.includes(parameterName);
-        // find the param in the original tool schema
-        const originalParamSchema = parameterName in (originalToolParamSchema.properties ?? {})
-            ? originalToolParamSchema.properties?.[parameterName]
-            : undefined;
-        // This should never happen, because the strict schema was derived from
-        // the original schema, so the parameter should always be present.
-        if (!originalParamSchema) {
-            throw new Error(`Tool call request parameter ${parameterName} not found in original tool`);
-        }
-        if (parameterValue === null &&
-            !canBeNull(originalParamSchema) &&
-            !isRequired) {
-            // This is the meat of this function. In the strict schema, this is
-            // "required and can be null", but in the original schema, the param was
-            // not required.
-            if (typeof originalParamSchema === "object" &&
-                "default" in originalParamSchema) {
-                return [parameterName, originalParamSchema.default];
-            }
-            return undefined;
-        }
-        // recurse into arrays
-        if (typeof originalParamSchema === "object" &&
-            originalParamSchema.type === "array") {
-            const arrayValue = parameterValue;
-            const itemSchema = originalParamSchema.items;
-            if (Array.isArray(arrayValue) &&
-                itemSchema &&
-                typeof itemSchema === "object" &&
-                !Array.isArray(itemSchema)) {
-                const newArrayValue = arrayValue.map((item) => {
-                    if (itemSchema.type === "object" &&
-                        typeof item === "object" &&
-                        item !== null) {
-                        // recurse into each object in the array
-                        return unstrictifyToolCallParams(itemSchema, item);
-                    }
-                    return item;
-                });
-                return [parameterName, newArrayValue];
-            }
-            return [parameterName, parameterValue];
-        }
-        // recurse into the parameter value, passing along the matching original schema
-        if (typeof originalParamSchema === "object" &&
-            originalParamSchema.type === "object") {
-            // If the LLM sent a JSON string instead of an object (common with z.any() schemas),
-            // try to parse it
-            let objectValue = parameterValue;
-            if (typeof parameterValue === "string") {
-                try {
-                    const parsed = JSON.parse(parameterValue);
-                    if (typeof parsed === "object" && parsed !== null) {
-                        objectValue = parsed;
-                    }
-                }
-                catch {
-                    // Not valid JSON, keep original value
-                }
-            }
-            // Only recurse if we have an actual object AND the schema has properties defined.
-            // If the schema has no properties (e.g., z.any() which produces {type: 'object', anyOf: [...]}),
-            // just return the value as-is without recursing.
-            const hasProperties = originalParamSchema.properties &&
-                Object.keys(originalParamSchema.properties).length > 0;
-            if (hasProperties &&
-                typeof objectValue === "object" &&
-                objectValue !== null &&
-                !Array.isArray(objectValue)) {
-                const newParamValue = unstrictifyToolCallParams(originalParamSchema, objectValue);
-                return [parameterName, newParamValue];
-            }
-            // Return the (possibly parsed) object value without recursing
-            return [parameterName, objectValue];
-        }
-        return [parameterName, parameterValue];
-    })
-        .filter((param) => param !== undefined);
-    return Object.fromEntries(newParams);
-}
-/**
- * Unstrictify tool call params using the original JSON Schema.
- *
- * Unlike the private `unstrictifyToolCallParams` which throws on unknown params,
- * this function separates params into schema-defined vs `_tambo_*` pass-through
- * (server-injected params not in the original schema), unstrictifies only the
- * schema-defined ones, and merges pass-through params back. Unknown keys that
- * aren't in the schema and don't have the `_tambo_` prefix are dropped.
- * @returns The params with strictification-induced nulls stripped for optional
- * non-nullable properties, and pass-through params preserved as-is.
- */
-function unstrictifyToolCallParamsFromSchema(originalSchema, params) {
-    if (originalSchema.type !== "object") {
-        return params;
-    }
-    const schemaProperties = originalSchema.properties ?? {};
-    const schemaDefinedParams = {};
-    const passThroughParams = {};
-    for (const [key, value] of Object.entries(params)) {
-        if (key in schemaProperties) {
-            schemaDefinedParams[key] = value;
-        }
-        else if (key.startsWith("_tambo_")) {
-            passThroughParams[key] = value;
-        }
-        // Unknown keys not in schema and not _tambo_* are dropped —
-        // they're likely hallucinated by the model.
-    }
-    const unstrictified = unstrictifyToolCallParams(originalSchema, schemaDefinedParams);
-    return { ...unstrictified, ...passThroughParams };
-}
-/**
- * Check if a JSON Schema definition allows null values.
- * @param originalSchema - The schema definition to check
- * @returns True if the schema allows null values
- */
-function canBeNull(originalSchema) {
-    if (typeof originalSchema !== "object") {
-        return false;
-    }
-    if (originalSchema.type === "null") {
-        return true;
-    }
-    if (originalSchema.anyOf?.some((anyOf) => canBeNull(anyOf))) {
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=unstrictify.js.map

package/dist/v1/utils/unstrictify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unstrictify.js","sourceRoot":"","sources":["../../../src/v1/utils/unstrictify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unstrictify tool call parameters using the original JSON Schema.\n *\n * When OpenAI's structured outputs mode is enabled, all optional parameters\n * become required-and-nullable. The LLM then sends `null` for parameters the\n * user didn't specify. This module reverses that transformation by comparing\n * the LLM's output against the original schema and stripping nulls for\n * parameters that were originally optional and non-nullable.\n *\n * Copied from packages/core/src/strictness/tool-call-strict.ts (minus the\n * OpenAI-specific `unstrictifyToolCallRequest` wrapper).\n */\n\nimport type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\n\n/**\n * Unstrictify the parameters of a tool call request.\n *\n * This effectively reverses the process of strictifyToolCallParams, for a\n * tool call request that was built from a strict JSON Schema, by returning a\n * updated tool call request with the parameter values unstrictified.\n */\nfunction unstrictifyToolCallParams(\n  originalToolParamSchema: JSONSchema7,\n  toolCallRequestParams: Record<string, unknown>,\n): Record<string, unknown> {\n  if (originalToolParamSchema.type !== \"object\") {\n    throw new Error(\n      `tool call parameter schema must be an object, instead got ${originalToolParamSchema.type} / ${typeof originalToolParamSchema}`,\n    );\n  }\n  const newParams = Object.entries(toolCallRequestParams)\n    .map(([parameterName, parameterValue]) => {\n      const isRequired =\n        originalToolParamSchema.required?.includes(parameterName);\n      // find the param in the original tool schema\n      const originalParamSchema =\n        parameterName in (originalToolParamSchema.properties ?? {})\n          ? originalToolParamSchema.properties?.[parameterName]\n          : undefined;\n\n      // This should never happen, because the strict schema was derived from\n      // the original schema, so the parameter should always be present.\n      if (!originalParamSchema) {\n        throw new Error(\n          `Tool call request parameter ${parameterName} not found in original tool`,\n        );\n      }\n\n      if (\n        parameterValue === null &&\n        !canBeNull(originalParamSchema) &&\n        !isRequired\n      ) {\n        // This is the meat of this function. In the strict schema, this is\n        // \"required and can be null\", but in the original schema, the param was\n        // not required.\n        if (\n          typeof originalParamSchema === \"object\" &&\n          \"default\" in originalParamSchema\n        ) {\n          return [parameterName, originalParamSchema.default] as const;\n        }\n        return undefined;\n      }\n\n      // recurse into arrays\n      if (\n        typeof originalParamSchema === \"object\" &&\n        originalParamSchema.type === \"array\"\n      ) {\n        const arrayValue = parameterValue as unknown[];\n        const itemSchema = originalParamSchema.items;\n        if (\n          Array.isArray(arrayValue) &&\n          itemSchema &&\n          typeof itemSchema === \"object\" &&\n          !Array.isArray(itemSchema)\n        ) {\n          const newArrayValue = arrayValue.map((item) => {\n            if (\n              itemSchema.type === \"object\" &&\n              typeof item === \"object\" &&\n              item !== null\n            ) {\n              // recurse into each object in the array\n              return unstrictifyToolCallParams(\n                itemSchema,\n                item as Record<string, unknown>,\n              );\n            }\n            return item;\n          });\n          return [parameterName, newArrayValue] as const;\n        }\n        return [parameterName, parameterValue] as const;\n      }\n\n      // recurse into the parameter value, passing along the matching original schema\n      if (\n        typeof originalParamSchema === \"object\" &&\n        originalParamSchema.type === \"object\"\n      ) {\n        // If the LLM sent a JSON string instead of an object (common with z.any() schemas),\n        // try to parse it\n        let objectValue = parameterValue;\n        if (typeof parameterValue === \"string\") {\n          try {\n            const parsed = JSON.parse(parameterValue);\n            if (typeof parsed === \"object\" && parsed !== null) {\n              objectValue = parsed;\n            }\n          } catch {\n            // Not valid JSON, keep original value\n          }\n        }\n\n        // Only recurse if we have an actual object AND the schema has properties defined.\n        // If the schema has no properties (e.g., z.any() which produces {type: 'object', anyOf: [...]}),\n        // just return the value as-is without recursing.\n        const hasProperties =\n          originalParamSchema.properties &&\n          Object.keys(originalParamSchema.properties).length > 0;\n\n        if (\n          hasProperties &&\n          typeof objectValue === \"object\" &&\n          objectValue !== null &&\n          !Array.isArray(objectValue)\n        ) {\n          const newParamValue = unstrictifyToolCallParams(\n            originalParamSchema,\n            objectValue as Record<string, unknown>,\n          );\n          return [parameterName, newParamValue] as const;\n        }\n\n        // Return the (possibly parsed) object value without recursing\n        return [parameterName, objectValue] as const;\n      }\n\n      return [parameterName, parameterValue] as const;\n    })\n    .filter((param) => param !== undefined);\n  return Object.fromEntries(newParams);\n}\n\n/**\n * Unstrictify tool call params using the original JSON Schema.\n *\n * Unlike the private `unstrictifyToolCallParams` which throws on unknown params,\n * this function separates params into schema-defined vs `_tambo_*` pass-through\n * (server-injected params not in the original schema), unstrictifies only the\n * schema-defined ones, and merges pass-through params back. Unknown keys that\n * aren't in the schema and don't have the `_tambo_` prefix are dropped.\n * @returns The params with strictification-induced nulls stripped for optional\n * non-nullable properties, and pass-through params preserved as-is.\n */\nexport function unstrictifyToolCallParamsFromSchema(\n  originalSchema: JSONSchema7,\n  params: Record<string, unknown>,\n): Record<string, unknown> {\n  if (originalSchema.type !== \"object\") {\n    return params;\n  }\n\n  const schemaProperties = originalSchema.properties ?? {};\n  const schemaDefinedParams: Record<string, unknown> = {};\n  const passThroughParams: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(params)) {\n    if (key in schemaProperties) {\n      schemaDefinedParams[key] = value;\n    } else if (key.startsWith(\"_tambo_\")) {\n      passThroughParams[key] = value;\n    }\n    // Unknown keys not in schema and not _tambo_* are dropped —\n    // they're likely hallucinated by the model.\n  }\n\n  const unstrictified = unstrictifyToolCallParams(\n    originalSchema,\n    schemaDefinedParams,\n  );\n\n  return { ...unstrictified, ...passThroughParams };\n}\n\n/**\n * Check if a JSON Schema definition allows null values.\n * @param originalSchema - The schema definition to check\n * @returns True if the schema allows null values\n */\nexport function canBeNull(originalSchema: JSONSchema7Definition): boolean {\n  if (typeof originalSchema !== \"object\") {\n    return false;\n  }\n\n  if (originalSchema.type === \"null\") {\n    return true;\n  }\n\n  if (originalSchema.anyOf?.some((anyOf) => canBeNull(anyOf))) {\n    return true;\n  }\n  return false;\n}\n"]}

package/esm/mcp/mcp-client.d.ts

@@ -1,185 +0,0 @@
-import { type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { ClientNotification, ClientRequest, CreateMessageRequest, CreateMessageResult, ElicitRequest, ElicitResult } from "@modelcontextprotocol/sdk/types.js";
-import { JSONSchema7 } from "json-schema";
-import { MCPTransport } from "../model/mcp-server-info.js";
-export { MCPTransport };
-/**
- * Handler for MCP elicitation requests.
- * Receives the elicit request and a RequestHandlerExtra containing an AbortSignal that fires when the request is cancelled.
- * @param request - The elicitation request from the server
- * @param extra - Additional context including AbortSignal for cancellation
- * @returns Promise resolving to the elicitation result
- * @example
- * ```typescript
- * const handler: MCPElicitationHandler = async (request, extra) => {
- *   // Listen for cancellation
- *   extra.signal.addEventListener('abort', () => {
- *     console.log('Request cancelled');
- *   });
- *
- *   // Return user's response
- *   return {
- *     action: 'accept',
- *     content: { name: 'John' }
- *   };
- * };
- * ```
- */
-export type MCPElicitationHandler = (e: ElicitRequest, extra: RequestHandlerExtra<ClientRequest, ClientNotification>) => Promise<ElicitResult>;
-/**
- * Handler for MCP sampling requests (create_message).
- * Receives the sampling request and a RequestHandlerExtra containing an AbortSignal that fires when the request is cancelled.
- * @param request - The sampling/create_message request from the server
- * @param extra - Additional context including AbortSignal for cancellation
- * @returns Promise resolving to the sampling result
- */
-export type MCPSamplingHandler = (e: CreateMessageRequest, extra: RequestHandlerExtra<ClientRequest, ClientNotification>) => Promise<CreateMessageResult>;
-/**
- * Handlers for MCP requests - these are only used if the server supports the corresponding capabilities
- * @param elicitation - Handler for elicitation requests (receives request and RequestHandlerExtra with AbortSignal)
- * @param sampling - Handler for sampling requests (receives request and RequestHandlerExtra with AbortSignal)
- * @example
- * ```typescript
- * const mcp = await MCPClient.create(
- *     'https://api.example.com/mcp',
- *     MCPTransport.HTTP,
- *     {},
- *     undefined,
- *     undefined,
- *     {
- *       elicitation: (e, extra) => Promise.resolve({...}),
- *     },
- * );
- * ```
- */
-export interface MCPHandlers {
-    elicitation: MCPElicitationHandler;
-    sampling: MCPSamplingHandler;
-}
-/**
- * A client for interacting with MCP (Model Context Protocol) servers.
- * Provides a simple interface for listing and calling tools exposed by the server.
- * @example
- * ```typescript
- * const mcp = await MCPClient.create('https://api.example.com/mcp');
- * const tools = await mcp.listTools();
- * const result = await mcp.callTool('toolName', { arg1: 'value1' });
- * ```
- */
-export declare class MCPClient {
-    /**
-     * The underlying MCP client
-     *
-     * Be careful not to mutate the client directly, use the methods provided instead.
-     */
-    client: Client;
-    private transport;
-    private transportType;
-    sessionId?: string;
-    private endpoint;
-    private headers;
-    private authProvider?;
-    private handlers;
-    /**
-     * Private constructor to enforce using the static create method.
-     * @param endpoint - The URL of the MCP server to connect to
-     * @param transportType - The transport to use for the MCP client
-     * @param headers - Optional custom headers to include in requests
-     */
-    private constructor();
-    /**
-     * Creates and initializes a new MCPClient instance. This is the recommended
-     * way to create an MCPClient as it handles both instantiation and connection
-     * setup.
-     * @param endpoint - The URL of the MCP server to connect to
-     * @param transportType - The transport type to use for the MCP client. Defaults to HTTP.
-     * @param headers - Optional custom headers to include in requests
-     * @param authProvider - Optional auth provider to use for authentication
-     * @param sessionId - Optional session id to use for the MCP client - if not
-     *   provided, a new session will be created
-     * @returns A connected MCPClient instance ready for use
-     * @throws {Error} Will throw an error if connection fails
-     */
-    static create(endpoint: string, transportType: MCPTransport | undefined, headers: Record<string, string> | undefined, authProvider: OAuthClientProvider | undefined, sessionId: string | undefined, handlers?: Partial<MCPHandlers>): Promise<MCPClient>;
-    private initializeTransport;
-    /**
-     * Initializes the MCP client with the appropriate capabilities and handlers
-     * @returns The initialized MCP client
-     */
-    private initializeClient;
-    /**
-     * Retrieves a complete list of all available tools from the MCP server.
-     * Handles pagination automatically by following cursors until all tools are fetched.
-     * @returns A complete list of all available tools and their descriptions
-     * @throws {Error} Will throw an error if any server request fails during pagination
-     */
-    listTools(): Promise<MCPToolSpec[]>;
-    getServerCapabilities(): {
-        experimental?: {
-            [x: string]: object;
-        } | undefined;
-        logging?: object | undefined;
-        completions?: object | undefined;
-        prompts?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        resources?: {
-            subscribe?: boolean | undefined;
-            listChanged?: boolean | undefined;
-        } | undefined;
-        tools?: {
-            listChanged?: boolean | undefined;
-        } | undefined;
-        tasks?: {
-            [x: string]: unknown;
-            list?: object | undefined;
-            cancel?: object | undefined;
-            requests?: {
-                [x: string]: unknown;
-                tools?: {
-                    [x: string]: unknown;
-                    call?: object | undefined;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    } | undefined;
-    getServerVersion(): {
-        version: string;
-        name: string;
-        websiteUrl?: string | undefined;
-        description?: string | undefined;
-        icons?: {
-            src: string;
-            mimeType?: string | undefined;
-            sizes?: string[] | undefined;
-            theme?: "light" | "dark" | undefined;
-        }[] | undefined;
-        title?: string | undefined;
-    } | undefined;
-    getInstructions(): string | undefined;
-    /**
-     * Calls a specific tool on the MCP server with the provided arguments.
-     * @param name - The name of the tool to call
-     * @param args - Arguments to pass to the tool, must match the tool's expected schema
-     * @returns The result from the tool execution
-     * @throws {Error} Will throw an error if the tool call fails or if arguments are invalid
-     */
-    callTool(name: string, args: Record<string, unknown>, _meta?: Record<string, unknown>): Promise<MCPToolCallResult>;
-    updateElicitationHandler(handler: MCPElicitationHandler | undefined): void;
-    updateSamplingHandler(handler: MCPSamplingHandler | undefined): void;
-    close(): Promise<void>;
-}
-/**
- * The result of a tool call.
- * This is the same as the result of a tool call in the OpenAI SDK, but is reified here
- */
-export type MCPToolCallResult = Awaited<ReturnType<typeof Client.prototype.callTool>>;
-export interface MCPToolSpec {
-    name: string;
-    description?: string;
-    inputSchema?: JSONSchema7;
-    maxCalls?: number;
-}
-//# sourceMappingURL=mcp-client.d.ts.map

package/esm/mcp/mcp-client.d.ts.map

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