@tambo-ai/react 1.1.0 → 1.2.0

package/dist/model/mcp-server-info.d.ts

@@ -1,76 +0,0 @@
-/**
- * The transport protocol to use for MCP connections.
- */
-export declare enum MCPTransport {
-    SSE = "sse",
-    HTTP = "http"
-}
-/**
- * User-provided configuration for an MCP server.
- *
- * This is the type accepted by `TamboProvider` / `TamboRegistryProvider` in
- * the `mcpServers` prop.
- *
- * The `handlers` field is intentionally typed as `unknown` here so the core
- * SDK does not depend on the MCP subpackage. In the `@tambo-ai/react/mcp`
- * subpackage this is treated as `Partial<MCPHandlers>` (with
- * `elicitation` / `sampling` callbacks). The `@modelcontextprotocol/sdk` is
- * included automatically with `@tambo-ai/react`. See the React SDK README for
- * any additional optional peer dependencies needed for MCP features.
- */
-export interface McpServerInfo {
-    /** Optional name for the MCP server */
-    name?: string;
-    /** The URL of the MCP server to connect to */
-    url: string;
-    /** Optional description of the MCP server */
-    description?: string;
-    /** The transport type to use (SSE or HTTP). Defaults to HTTP for string URLs */
-    transport?: MCPTransport;
-    /** Optional custom headers to include in requests */
-    customHeaders?: Record<string, string>;
-    /**
-     * Optional short name for namespacing MCP resources, prompts, and tools.
-     * When multiple MCP servers are configured, this key is used to prefix:
-     * - prompts: `<serverKey>:<promptName>`
-     * - resources: `<serverKey>:<resourceUrl>`
-     * - tools: `<serverKey>__<toolName>`
-     *
-     * If not provided, a key will be derived from the URL hostname.
-     * For example, "https://mcp.linear.app/mcp" becomes "linear".
-     */
-    serverKey?: string;
-    /**
-     * Optional handlers for elicitation and sampling requests from the server.
-     *
-     * In the MCP subpackage this is interpreted as `Partial<MCPHandlers>`,
-     * i.e. `{ elicitation?: MCPElicitationHandler; sampling?: MCPSamplingHandler }`.
-     *
-     * Note: These callbacks should be stable (e.g., wrapped in useCallback or
-     * defined outside the component) to avoid constant re-registration of the
-     * MCP server on every render.
-     */
-    handlers?: unknown;
-}
-/**
- * Normalized MCP server metadata used internally by the registry and MCP
- * provider.
- *
- * This is equivalent to `McpServerInfo` except that:
- * - `serverKey` is guaranteed to be present
- * - `transport` is resolved to a concrete value (defaults to HTTP)
- */
-export interface NormalizedMcpServerInfo extends McpServerInfo {
-    transport: MCPTransport;
-    serverKey: string;
-}
-/**
- * Creates a stable identifier for an MCP server based on its connection properties.
- * Two servers with the same URL, transport, and headers will have the same key.
- *
- * This is used by both the registry and MCP provider to deduplicate servers,
- * so it lives alongside the shared server metadata type.
- * @returns A stable string key identifying the server
- */
-export declare function getMcpServerUniqueKey(serverInfo: Pick<McpServerInfo, "url" | "transport" | "customHeaders">): string;
-//# sourceMappingURL=mcp-server-info.d.ts.map

package/dist/model/mcp-server-info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-server-info.d.ts","sourceRoot":"","sources":["../../src/model/mcp-server-info.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,YAAY;IACtB,GAAG,QAAQ;IACX,IAAI,SAAS;CACd;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC5D,SAAS,EAAE,YAAY,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,WAAW,GAAG,eAAe,CAAC,GACrE,MAAM,CAUR"}

package/dist/model/mcp-server-info.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPTransport = void 0;
-exports.getMcpServerUniqueKey = getMcpServerUniqueKey;
-/**
- * The transport protocol to use for MCP connections.
- */
-var MCPTransport;
-(function (MCPTransport) {
-    MCPTransport["SSE"] = "sse";
-    MCPTransport["HTTP"] = "http";
-})(MCPTransport || (exports.MCPTransport = MCPTransport = {}));
-/**
- * Creates a stable identifier for an MCP server based on its connection properties.
- * Two servers with the same URL, transport, and headers will have the same key.
- *
- * This is used by both the registry and MCP provider to deduplicate servers,
- * so it lives alongside the shared server metadata type.
- * @returns A stable string key identifying the server
- */
-function getMcpServerUniqueKey(serverInfo) {
-    const headerStr = serverInfo.customHeaders
-        ? JSON.stringify(Object.entries(serverInfo.customHeaders)
-            .map(([k, v]) => [k.toLowerCase(), v])
-            .sort(([a], [b]) => a.localeCompare(b)))
-        : "";
-    return `${serverInfo.url}|${serverInfo.transport ?? MCPTransport.HTTP}|${headerStr}`;
-}
-//# sourceMappingURL=mcp-server-info.js.map

package/dist/model/mcp-server-info.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-server-info.js","sourceRoot":"","sources":["../../src/model/mcp-server-info.ts"],"names":[],"mappings":";;;AA6EA,sDAYC;AAzFD;;GAEG;AACH,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,2BAAW,CAAA;IACX,6BAAa,CAAA;AACf,CAAC,EAHW,YAAY,4BAAZ,YAAY,QAGvB;AA+DD;;;;;;;GAOG;AACH,SAAgB,qBAAqB,CACnC,UAAsE;IAEtE,MAAM,SAAS,GAAG,UAAU,CAAC,aAAa;QACxC,CAAC,CAAC,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC;aACrC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAU,CAAC;aAC9C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAC1C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO,GAAG,UAAU,CAAC,GAAG,IAAI,UAAU,CAAC,SAAS,IAAI,YAAY,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;AACvF,CAAC","sourcesContent":["/**\n * The transport protocol to use for MCP connections.\n */\nexport enum MCPTransport {\n  SSE = \"sse\",\n  HTTP = \"http\",\n}\n\n/**\n * User-provided configuration for an MCP server.\n *\n * This is the type accepted by `TamboProvider` / `TamboRegistryProvider` in\n * the `mcpServers` prop.\n *\n * The `handlers` field is intentionally typed as `unknown` here so the core\n * SDK does not depend on the MCP subpackage. In the `@tambo-ai/react/mcp`\n * subpackage this is treated as `Partial<MCPHandlers>` (with\n * `elicitation` / `sampling` callbacks). The `@modelcontextprotocol/sdk` is\n * included automatically with `@tambo-ai/react`. See the React SDK README for\n * any additional optional peer dependencies needed for MCP features.\n */\nexport interface McpServerInfo {\n  /** Optional name for the MCP server */\n  name?: string;\n  /** The URL of the MCP server to connect to */\n  url: string;\n  /** Optional description of the MCP server */\n  description?: string;\n  /** The transport type to use (SSE or HTTP). Defaults to HTTP for string URLs */\n  transport?: MCPTransport;\n  /** Optional custom headers to include in requests */\n  customHeaders?: Record<string, string>;\n  /**\n   * Optional short name for namespacing MCP resources, prompts, and tools.\n   * When multiple MCP servers are configured, this key is used to prefix:\n   * - prompts: `<serverKey>:<promptName>`\n   * - resources: `<serverKey>:<resourceUrl>`\n   * - tools: `<serverKey>__<toolName>`\n   *\n   * If not provided, a key will be derived from the URL hostname.\n   * For example, \"https://mcp.linear.app/mcp\" becomes \"linear\".\n   */\n  serverKey?: string;\n  /**\n   * Optional handlers for elicitation and sampling requests from the server.\n   *\n   * In the MCP subpackage this is interpreted as `Partial<MCPHandlers>`,\n   * i.e. `{ elicitation?: MCPElicitationHandler; sampling?: MCPSamplingHandler }`.\n   *\n   * Note: These callbacks should be stable (e.g., wrapped in useCallback or\n   * defined outside the component) to avoid constant re-registration of the\n   * MCP server on every render.\n   */\n  handlers?: unknown;\n}\n\n/**\n * Normalized MCP server metadata used internally by the registry and MCP\n * provider.\n *\n * This is equivalent to `McpServerInfo` except that:\n * - `serverKey` is guaranteed to be present\n * - `transport` is resolved to a concrete value (defaults to HTTP)\n */\nexport interface NormalizedMcpServerInfo extends McpServerInfo {\n  transport: MCPTransport;\n  serverKey: string;\n}\n\n/**\n * Creates a stable identifier for an MCP server based on its connection properties.\n * Two servers with the same URL, transport, and headers will have the same key.\n *\n * This is used by both the registry and MCP provider to deduplicate servers,\n * so it lives alongside the shared server metadata type.\n * @returns A stable string key identifying the server\n */\nexport function getMcpServerUniqueKey(\n  serverInfo: Pick<McpServerInfo, \"url\" | \"transport\" | \"customHeaders\">,\n): string {\n  const headerStr = serverInfo.customHeaders\n    ? JSON.stringify(\n        Object.entries(serverInfo.customHeaders)\n          .map(([k, v]) => [k.toLowerCase(), v] as const)\n          .sort(([a], [b]) => a.localeCompare(b)),\n      )\n    : \"\";\n\n  return `${serverInfo.url}|${serverInfo.transport ?? MCPTransport.HTTP}|${headerStr}`;\n}\n"]}

package/dist/schema/schema.d.ts

@@ -1,49 +0,0 @@
-/**
- * Schema utilities for working with Standard Schema and JSON Schema.
- *
- * This module provides a unified interface for handling different schema types
- * used in Tambo components and tools. It uses Standard Schema (https://standardschema.dev/)
- * as the primary interface, which is implemented by Zod 3.24+ and other validation libraries.
- *
- * JSON Schema conversion is handled by `@standard-community/standard-json`.
- * @module schema
- */
-import type { JSONSchema7 } from "json-schema";
-import { ParameterSpec, SupportedSchema, TamboTool } from "../model/component-metadata";
-/**
- * Converts a schema (Standard Schema or JSON Schema) to a JSON Schema object.
- *
- * If the schema is already a JSON Schema, it is returned as-is.
- * For Standard Schema validators (Zod 3.24+, etc.), uses
- * `@standard-community/standard-json` for conversion.
- * @param schema - The schema to convert
- * @returns The JSON Schema representation
- * @example
- * ```typescript
- * import { z } from "zod/v4";
- *
- * // Convert a Zod schema
- * const zodSchema = z.object({ name: z.string() });
- * const jsonSchema = schemaToJsonSchema(zodSchema);
- *
- * // Pass through a JSON Schema
- * const existingJsonSchema = { type: "object", properties: { name: { type: "string" } } };
- * schemaToJsonSchema(existingJsonSchema); // returns the same object
- * ```
- */
-export declare function schemaToJsonSchema(schema: SupportedSchema): JSONSchema7;
-/**
- * Safely converts a schema to JSON Schema, returning undefined for invalid inputs.
- * @param schema - The schema to convert (may be undefined)
- * @param onError - Optional callback invoked on conversion error
- * @returns The JSON Schema representation, or undefined if conversion fails
- */
-export declare function safeSchemaToJsonSchema(schema: SupportedSchema | undefined | null, onError?: (error: unknown) => void): JSONSchema7 | undefined;
-/**
- * Extracts parameter specifications from a tool's inputSchema.
- * @param tool - The tool containing the schema
- * @returns An array of parameter specifications
- */
-export declare function getParametersFromToolSchema(tool: TamboTool): ParameterSpec[];
-export type { SupportedSchema };
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,OAAO,EACL,aAAa,EACb,eAAe,EACf,SAAS,EACV,MAAM,6BAA6B,CAAC;AAuBrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CAOvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,EAC1C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,WAAW,GAAG,SAAS,CAYzB;AAoCD;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,SAAS,GAAG,aAAa,EAAE,CAe5E;AAED,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/schema/schema.js

@@ -1,129 +0,0 @@
-"use strict";
-/**
- * Schema utilities for working with Standard Schema and JSON Schema.
- *
- * This module provides a unified interface for handling different schema types
- * used in Tambo components and tools. It uses Standard Schema (https://standardschema.dev/)
- * as the primary interface, which is implemented by Zod 3.24+ and other validation libraries.
- *
- * JSON Schema conversion is handled by `@standard-community/standard-json`.
- * @module schema
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaToJsonSchema = schemaToJsonSchema;
-exports.safeSchemaToJsonSchema = safeSchemaToJsonSchema;
-exports.getParametersFromToolSchema = getParametersFromToolSchema;
-const standard_json_1 = require("@standard-community/standard-json");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const core_1 = require("zod/v4/core");
-const json_schema_1 = require("./json-schema");
-const standard_schema_1 = require("./standard-schema");
-/**
- * Register the zod vendor handler for synchronous JSON Schema conversion.
- * This uses Zod 4's native toJSONSchema for Zod 4.x schemas and zod-to-json-schema for Zod 3.x.
- */
-(0, standard_json_1.loadVendor)("zod", (schema) => {
-    // Check if this is a Zod 4 schema (has _zod property)
-    if (schema && typeof schema === "object" && "_zod" in schema) {
-        // Use Zod 4's native toJSONSchema from zod/v4/core
-        // Cast through unknown since the Zod 4 internal types don't match our detection pattern
-        return (0, core_1.toJSONSchema)(schema);
-    }
-    // Fall back to zod-to-json-schema for Zod 3.x
-    return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
-});
-/**
- * Converts a schema (Standard Schema or JSON Schema) to a JSON Schema object.
- *
- * If the schema is already a JSON Schema, it is returned as-is.
- * For Standard Schema validators (Zod 3.24+, etc.), uses
- * `@standard-community/standard-json` for conversion.
- * @param schema - The schema to convert
- * @returns The JSON Schema representation
- * @example
- * ```typescript
- * import { z } from "zod/v4";
- *
- * // Convert a Zod schema
- * const zodSchema = z.object({ name: z.string() });
- * const jsonSchema = schemaToJsonSchema(zodSchema);
- *
- * // Pass through a JSON Schema
- * const existingJsonSchema = { type: "object", properties: { name: { type: "string" } } };
- * schemaToJsonSchema(existingJsonSchema); // returns the same object
- * ```
- */
-function schemaToJsonSchema(schema) {
-    // Already a JSON Schema - return as-is
-    if (!(0, standard_schema_1.isStandardSchema)(schema)) {
-        return schema;
-    }
-    return standard_json_1.toJsonSchema.sync(schema);
-}
-/**
- * Safely converts a schema to JSON Schema, returning undefined for invalid inputs.
- * @param schema - The schema to convert (may be undefined)
- * @param onError - Optional callback invoked on conversion error
- * @returns The JSON Schema representation, or undefined if conversion fails
- */
-function safeSchemaToJsonSchema(schema, onError) {
-    if (!schema) {
-        return undefined;
-    }
-    try {
-        return schemaToJsonSchema(schema);
-    }
-    catch (error) {
-        console.error("Error converting schema to JSON Schema:", error);
-        onError?.(error);
-        return undefined;
-    }
-}
-/**
- * Creates parameter specs from an input schema.
- * The schema represents the shape of the single object argument to the tool function.
- * @param schema - The input schema (JSON Schema)
- * @returns An array of parameter specifications
- */
-function createParametersFromSchema(schema) {
-    const properties = schema.properties ?? {};
-    return Object.entries(properties).map(([key, propSchema]) => ({
-        name: key,
-        type: propSchema && typeof propSchema === "object" && "type" in propSchema
-            ? propSchema.type
-            : "object",
-        description: propSchema &&
-            typeof propSchema === "object" &&
-            "description" in propSchema
-            ? (propSchema.description ?? "")
-            : "",
-        isRequired: Array.isArray(schema.required)
-            ? schema.required.includes(key)
-            : false,
-        schema: typeof propSchema === "object" && propSchema !== null
-            ? propSchema
-            : {},
-    }));
-}
-/**
- * Extracts parameter specifications from a tool's inputSchema.
- * @param tool - The tool containing the schema
- * @returns An array of parameter specifications
- */
-function getParametersFromToolSchema(tool) {
-    const schema = tool.inputSchema;
-    // Convert to JSON Schema if needed
-    let jsonSchema;
-    if ((0, json_schema_1.looksLikeJSONSchema)(schema)) {
-        jsonSchema = schema;
-    }
-    else if ((0, standard_schema_1.isStandardSchema)(schema)) {
-        jsonSchema = schemaToJsonSchema(schema);
-    }
-    else {
-        console.warn("Unknown inputSchema type, returning empty parameters");
-        return [];
-    }
-    return createParametersFromSchema(jsonSchema);
-}
-//# sourceMappingURL=schema.js.map

package/dist/schema/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Schema utilities for working with Standard Schema and JSON Schema.\n *\n * This module provides a unified interface for handling different schema types\n * used in Tambo components and tools. It uses Standard Schema (https://standardschema.dev/)\n * as the primary interface, which is implemented by Zod 3.24+ and other validation libraries.\n *\n * JSON Schema conversion is handled by `@standard-community/standard-json`.\n * @module schema\n */\n\nimport { loadVendor, toJsonSchema } from \"@standard-community/standard-json\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\nimport { toJSONSchema as zod4ToJSONSchema } from \"zod/v4/core\";\nimport {\n  ParameterSpec,\n  SupportedSchema,\n  TamboTool,\n} from \"../model/component-metadata\";\nimport { looksLikeJSONSchema } from \"./json-schema\";\nimport { isStandardSchema } from \"./standard-schema\";\n\n/**\n * Register the zod vendor handler for synchronous JSON Schema conversion.\n * This uses Zod 4's native toJSONSchema for Zod 4.x schemas and zod-to-json-schema for Zod 3.x.\n */\nloadVendor(\"zod\", (schema: unknown): JSONSchema7 => {\n  // Check if this is a Zod 4 schema (has _zod property)\n  if (schema && typeof schema === \"object\" && \"_zod\" in schema) {\n    // Use Zod 4's native toJSONSchema from zod/v4/core\n    // Cast through unknown since the Zod 4 internal types don't match our detection pattern\n    return zod4ToJSONSchema(\n      schema as unknown as Parameters<typeof zod4ToJSONSchema>[0],\n    ) as JSONSchema7;\n  }\n  // Fall back to zod-to-json-schema for Zod 3.x\n  return zodToJsonSchema(\n    schema as Parameters<typeof zodToJsonSchema>[0],\n  ) as JSONSchema7;\n});\n\n/**\n * Converts a schema (Standard Schema or JSON Schema) to a JSON Schema object.\n *\n * If the schema is already a JSON Schema, it is returned as-is.\n * For Standard Schema validators (Zod 3.24+, etc.), uses\n * `@standard-community/standard-json` for conversion.\n * @param schema - The schema to convert\n * @returns The JSON Schema representation\n * @example\n * ```typescript\n * import { z } from \"zod/v4\";\n *\n * // Convert a Zod schema\n * const zodSchema = z.object({ name: z.string() });\n * const jsonSchema = schemaToJsonSchema(zodSchema);\n *\n * // Pass through a JSON Schema\n * const existingJsonSchema = { type: \"object\", properties: { name: { type: \"string\" } } };\n * schemaToJsonSchema(existingJsonSchema); // returns the same object\n * ```\n */\nexport function schemaToJsonSchema(schema: SupportedSchema): JSONSchema7 {\n  // Already a JSON Schema - return as-is\n  if (!isStandardSchema(schema)) {\n    return schema;\n  }\n\n  return toJsonSchema.sync(schema) as JSONSchema7;\n}\n\n/**\n * Safely converts a schema to JSON Schema, returning undefined for invalid inputs.\n * @param schema - The schema to convert (may be undefined)\n * @param onError - Optional callback invoked on conversion error\n * @returns The JSON Schema representation, or undefined if conversion fails\n */\nexport function safeSchemaToJsonSchema(\n  schema: SupportedSchema | undefined | null,\n  onError?: (error: unknown) => void,\n): JSONSchema7 | undefined {\n  if (!schema) {\n    return undefined;\n  }\n\n  try {\n    return schemaToJsonSchema(schema);\n  } catch (error) {\n    console.error(\"Error converting schema to JSON Schema:\", error);\n    onError?.(error);\n    return undefined;\n  }\n}\n\n/**\n * Creates parameter specs from an input schema.\n * The schema represents the shape of the single object argument to the tool function.\n * @param schema - The input schema (JSON Schema)\n * @returns An array of parameter specifications\n */\nfunction createParametersFromSchema(schema: JSONSchema7): ParameterSpec[] {\n  const properties = schema.properties ?? {};\n\n  return Object.entries(properties).map(\n    ([key, propSchema]) =>\n      ({\n        name: key,\n        type:\n          propSchema && typeof propSchema === \"object\" && \"type\" in propSchema\n            ? (propSchema.type as string)\n            : \"object\",\n        description:\n          propSchema &&\n          typeof propSchema === \"object\" &&\n          \"description\" in propSchema\n            ? (propSchema.description ?? \"\")\n            : \"\",\n        isRequired: Array.isArray(schema.required)\n          ? schema.required.includes(key)\n          : false,\n        schema:\n          typeof propSchema === \"object\" && propSchema !== null\n            ? propSchema\n            : {},\n      }) satisfies ParameterSpec,\n  );\n}\n\n/**\n * Extracts parameter specifications from a tool's inputSchema.\n * @param tool - The tool containing the schema\n * @returns An array of parameter specifications\n */\nexport function getParametersFromToolSchema(tool: TamboTool): ParameterSpec[] {\n  const schema = tool.inputSchema;\n\n  // Convert to JSON Schema if needed\n  let jsonSchema: JSONSchema7;\n  if (looksLikeJSONSchema(schema)) {\n    jsonSchema = schema;\n  } else if (isStandardSchema(schema)) {\n    jsonSchema = schemaToJsonSchema(schema);\n  } else {\n    console.warn(\"Unknown inputSchema type, returning empty parameters\");\n    return [];\n  }\n\n  return createParametersFromSchema(jsonSchema);\n}\n\nexport type { SupportedSchema };\n"]}

package/dist/schema/standard-schema.d.ts

@@ -1,22 +0,0 @@
-import { StandardSchemaV1 } from "@standard-schema/spec";
-/**
- * Type guard to check if an object implements the Standard Schema interface.
- *
- * Standard Schema compliant validators have a `~standard` property containing
- * metadata about the schema including version, vendor, and validate function.
- * Uses duck typing to avoid cross-version Zod compatibility issues.
- * @param obj - The object to check
- * @returns True if the object implements StandardSchemaV1
- * @example
- * ```typescript
- * import { z } from "zod/v4";
- *
- * const zodSchema = z.object({ name: z.string() });
- * isStandardSchema(zodSchema); // true
- *
- * const jsonSchema = { type: "object", properties: { name: { type: "string" } } };
- * isStandardSchema(jsonSchema); // false
- * ```
- */
-export declare function isStandardSchema(obj: unknown): obj is StandardSchemaV1;
-//# sourceMappingURL=standard-schema.d.ts.map

package/dist/schema/standard-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../../src/schema/standard-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,gBAAgB,CAuBtE"}

package/dist/schema/standard-schema.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStandardSchema = isStandardSchema;
-/**
- * Type guard to check if an object implements the Standard Schema interface.
- *
- * Standard Schema compliant validators have a `~standard` property containing
- * metadata about the schema including version, vendor, and validate function.
- * Uses duck typing to avoid cross-version Zod compatibility issues.
- * @param obj - The object to check
- * @returns True if the object implements StandardSchemaV1
- * @example
- * ```typescript
- * import { z } from "zod/v4";
- *
- * const zodSchema = z.object({ name: z.string() });
- * isStandardSchema(zodSchema); // true
- *
- * const jsonSchema = { type: "object", properties: { name: { type: "string" } } };
- * isStandardSchema(jsonSchema); // false
- * ```
- */
-function isStandardSchema(obj) {
-    if (typeof obj !== "object" || obj === null) {
-        return false;
-    }
-    if (!("~standard" in obj)) {
-        return false;
-    }
-    const standard = obj["~standard"];
-    if (typeof standard !== "object" || standard === null) {
-        return false;
-    }
-    // Check required Standard Schema v1 properties
-    return ("version" in standard &&
-        standard.version === 1 &&
-        "vendor" in standard &&
-        typeof standard.vendor === "string" &&
-        "validate" in standard &&
-        typeof standard.validate === "function");
-}
-//# sourceMappingURL=standard-schema.js.map

package/dist/schema/standard-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../src/schema/standard-schema.ts"],"names":[],"mappings":";;AAqBA,4CAuBC;AA1CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,gBAAgB,CAAC,GAAY;IAC3C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC,CAAC,WAAW,IAAI,GAAG,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC;IAClC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,+CAA+C;IAC/C,OAAO,CACL,SAAS,IAAI,QAAQ;QACrB,QAAQ,CAAC,OAAO,KAAK,CAAC;QACtB,QAAQ,IAAI,QAAQ;QACpB,OAAO,QAAQ,CAAC,MAAM,KAAK,QAAQ;QACnC,UAAU,IAAI,QAAQ;QACtB,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU,CACxC,CAAC;AACJ,CAAC","sourcesContent":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Type guard to check if an object implements the Standard Schema interface.\n *\n * Standard Schema compliant validators have a `~standard` property containing\n * metadata about the schema including version, vendor, and validate function.\n * Uses duck typing to avoid cross-version Zod compatibility issues.\n * @param obj - The object to check\n * @returns True if the object implements StandardSchemaV1\n * @example\n * ```typescript\n * import { z } from \"zod/v4\";\n *\n * const zodSchema = z.object({ name: z.string() });\n * isStandardSchema(zodSchema); // true\n *\n * const jsonSchema = { type: \"object\", properties: { name: { type: \"string\" } } };\n * isStandardSchema(jsonSchema); // false\n * ```\n */\nexport function isStandardSchema(obj: unknown): obj is StandardSchemaV1 {\n  if (typeof obj !== \"object\" || obj === null) {\n    return false;\n  }\n\n  if (!(\"~standard\" in obj)) {\n    return false;\n  }\n\n  const standard = obj[\"~standard\"];\n  if (typeof standard !== \"object\" || standard === null) {\n    return false;\n  }\n\n  // Check required Standard Schema v1 properties\n  return (\n    \"version\" in standard &&\n    standard.version === 1 &&\n    \"vendor\" in standard &&\n    typeof standard.vendor === \"string\" &&\n    \"validate\" in standard &&\n    typeof standard.validate === \"function\"\n  );\n}\n"]}

package/dist/schema/validate.d.ts

@@ -1,14 +0,0 @@
-/**
- * Asserts that a schema does not contain record types (objects with dynamic keys).
- * Records are not serializable to JSON Schema in a way that the Tambo backend
- * understands, so they are disallowed.
- *
- * This function accepts Standard Schema validators (Zod, Valibot, ArkType, etc.)
- * or JSON Schema objects. It converts them to JSON Schema and checks for record patterns.
- *
- * For tool schemas that are function types, this extracts and validates the input parameters.
- * @param schema - The schema to validate (Standard Schema or JSON Schema)
- * @param contextName - A human-readable label echoed in the error message
- */
-export declare function assertNoRecordSchema(schema: unknown, contextName?: string): void;
-//# sourceMappingURL=validate.d.ts.map

package/dist/schema/validate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/schema/validate.ts"],"names":[],"mappings":"AAuIA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,EACf,WAAW,SAAW,GACrB,IAAI,CAqCN"}

package/dist/schema/validate.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNoRecordSchema = assertNoRecordSchema;
-const schema_1 = require("./schema");
-const standard_schema_1 = require("./standard-schema");
-/*
- * Check if a JSON Schema represents a record type (map with dynamic keys).
- *
- * For our purposes, any `object` schema with `additionalProperties` defined
- * as a nested schema (not just `true`/`false`) is treated as a record, even
- * if it also declares some explicit `properties`.
- * @param schema - The JSON Schema to check
- * @returns True if the schema represents a record-like type
- */
-function isRecordJsonSchema(schema) {
-    return (schema.type === "object" &&
-        typeof schema.additionalProperties === "object" &&
-        schema.additionalProperties !== null);
-}
-/**
- * Recursively walks a JSON Schema and throws when it encounters a record type.
- * Records are not supported because they use dynamic keys which don't serialize
- * well for the Tambo backend.
- * @param schema - The JSON Schema to check
- * @param path - Current path in the schema (for error messages)
- * @param contextName - Human-readable context name for error messages
- */
-function assertNoRecordInJsonSchema(schema, path, contextName) {
-    if (isRecordJsonSchema(schema)) {
-        const joined = path.length ? path.join(".") : "(root)";
-        throw new Error(`Record types (objects with dynamic keys) are not supported in ${contextName}. ` +
-            `Found at path "${joined}". ` +
-            "Replace it with an object using explicit keys.");
-    }
-    if (schema.properties) {
-        for (const [key, propSchema] of Object.entries(schema.properties)) {
-            if (typeof propSchema === "object" && propSchema !== null) {
-                assertNoRecordInJsonSchema(propSchema, [...path, key], contextName);
-            }
-        }
-    }
-    if (typeof schema.additionalProperties === "object" &&
-        schema.additionalProperties !== null) {
-        assertNoRecordInJsonSchema(schema.additionalProperties, [...path, "[*]"], contextName);
-    }
-    if (schema.items) {
-        if (Array.isArray(schema.items)) {
-            // Tuple (JSON Schema draft-07): check each item schema
-            schema.items.forEach((itemSchema, index) => {
-                if (typeof itemSchema === "object" && itemSchema !== null) {
-                    assertNoRecordInJsonSchema(itemSchema, [...path, `${index}`], contextName);
-                }
-            });
-        }
-        else if (typeof schema.items === "object") {
-            // Array: check the item schema
-            assertNoRecordInJsonSchema(schema.items, [...path, "[]"], contextName);
-        }
-    }
-    const prefixItems = schema.prefixItems;
-    if (Array.isArray(prefixItems)) {
-        prefixItems.forEach((itemSchema, index) => {
-            if (typeof itemSchema === "object" && itemSchema !== null) {
-                assertNoRecordInJsonSchema(itemSchema, [...path, `${index}`], contextName);
-            }
-        });
-    }
-    if (schema.allOf) {
-        schema.allOf.forEach((subSchema, index) => {
-            if (typeof subSchema === "object" && subSchema !== null) {
-                assertNoRecordInJsonSchema(subSchema, [...path, `&${index}`], contextName);
-            }
-        });
-    }
-    if (schema.anyOf) {
-        schema.anyOf.forEach((subSchema, index) => {
-            if (typeof subSchema === "object" && subSchema !== null) {
-                assertNoRecordInJsonSchema(subSchema, [...path, `|${index}`], contextName);
-            }
-        });
-    }
-    if (schema.oneOf) {
-        schema.oneOf.forEach((subSchema, index) => {
-            if (typeof subSchema === "object" && subSchema !== null) {
-                assertNoRecordInJsonSchema(subSchema, [...path, `|${index}`], contextName);
-            }
-        });
-    }
-    if (typeof schema.not === "object" && schema.not !== null) {
-        assertNoRecordInJsonSchema(schema.not, [...path, "!"], contextName);
-    }
-    if (typeof schema.if === "object" && schema.if !== null) {
-        assertNoRecordInJsonSchema(schema.if, [...path, "if"], contextName);
-    }
-    if (typeof schema.then === "object" && schema.then !== null) {
-        assertNoRecordInJsonSchema(schema.then, [...path, "then"], contextName);
-    }
-    if (typeof schema.else === "object" && schema.else !== null) {
-        assertNoRecordInJsonSchema(schema.else, [...path, "else"], contextName);
-    }
-}
-/**
- * Asserts that a schema does not contain record types (objects with dynamic keys).
- * Records are not serializable to JSON Schema in a way that the Tambo backend
- * understands, so they are disallowed.
- *
- * This function accepts Standard Schema validators (Zod, Valibot, ArkType, etc.)
- * or JSON Schema objects. It converts them to JSON Schema and checks for record patterns.
- *
- * For tool schemas that are function types, this extracts and validates the input parameters.
- * @param schema - The schema to validate (Standard Schema or JSON Schema)
- * @param contextName - A human-readable label echoed in the error message
- */
-function assertNoRecordSchema(schema, contextName = "schema") {
-    if (!schema) {
-        return;
-    }
-    let jsonSchema;
-    try {
-        if ((0, standard_schema_1.isStandardSchema)(schema)) {
-            // Handle function schemas specially - extract input parameters
-            const converted = (0, schema_1.schemaToJsonSchema)(schema);
-            // If it's a function schema that couldn't be converted, the input params
-            // were extracted in registry.ts, so we can skip validation here
-            if (!converted || Object.keys(converted).length === 0) {
-                return;
-            }
-            jsonSchema = converted;
-        }
-        else if (typeof schema === "object" &&
-            schema !== null &&
-            "type" in schema) {
-            // Already JSON Schema
-            jsonSchema = schema;
-        }
-        else {
-            // Unknown schema type - skip validation
-            return;
-        }
-    }
-    catch {
-        // If schema conversion fails, skip validation
-        // This can happen for function schemas or other special types
-        return;
-    }
-    assertNoRecordInJsonSchema(jsonSchema, [], contextName);
-}
-//# sourceMappingURL=validate.js.map

package/dist/schema/validate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/schema/validate.ts"],"names":[],"mappings":"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","sourcesContent":["import type { JSONSchema7 } from \"json-schema\";\nimport { schemaToJsonSchema } from \"./schema\";\nimport { isStandardSchema } from \"./standard-schema\";\n\n/*\n * Check if a JSON Schema represents a record type (map with dynamic keys).\n *\n * For our purposes, any `object` schema with `additionalProperties` defined\n * as a nested schema (not just `true`/`false`) is treated as a record, even\n * if it also declares some explicit `properties`.\n * @param schema - The JSON Schema to check\n * @returns True if the schema represents a record-like type\n */\nfunction isRecordJsonSchema(schema: JSONSchema7): boolean {\n  return (\n    schema.type === \"object\" &&\n    typeof schema.additionalProperties === \"object\" &&\n    schema.additionalProperties !== null\n  );\n}\n\n/**\n * Recursively walks a JSON Schema and throws when it encounters a record type.\n * Records are not supported because they use dynamic keys which don't serialize\n * well for the Tambo backend.\n * @param schema - The JSON Schema to check\n * @param path - Current path in the schema (for error messages)\n * @param contextName - Human-readable context name for error messages\n */\nfunction assertNoRecordInJsonSchema(\n  schema: JSONSchema7,\n  path: string[],\n  contextName: string,\n): void {\n  if (isRecordJsonSchema(schema)) {\n    const joined = path.length ? path.join(\".\") : \"(root)\";\n    throw new Error(\n      `Record types (objects with dynamic keys) are not supported in ${contextName}. ` +\n        `Found at path \"${joined}\". ` +\n        \"Replace it with an object using explicit keys.\",\n    );\n  }\n  if (schema.properties) {\n    for (const [key, propSchema] of Object.entries(schema.properties)) {\n      if (typeof propSchema === \"object\" && propSchema !== null) {\n        assertNoRecordInJsonSchema(propSchema, [...path, key], contextName);\n      }\n    }\n  }\n  if (\n    typeof schema.additionalProperties === \"object\" &&\n    schema.additionalProperties !== null\n  ) {\n    assertNoRecordInJsonSchema(\n      schema.additionalProperties,\n      [...path, \"[*]\"],\n      contextName,\n    );\n  }\n  if (schema.items) {\n    if (Array.isArray(schema.items)) {\n      // Tuple (JSON Schema draft-07): check each item schema\n      schema.items.forEach((itemSchema, index) => {\n        if (typeof itemSchema === \"object\" && itemSchema !== null) {\n          assertNoRecordInJsonSchema(\n            itemSchema,\n            [...path, `${index}`],\n            contextName,\n          );\n        }\n      });\n    } else if (typeof schema.items === \"object\") {\n      // Array: check the item schema\n      assertNoRecordInJsonSchema(schema.items, [...path, \"[]\"], contextName);\n    }\n  }\n  const prefixItems = (schema as Record<string, unknown>).prefixItems;\n  if (Array.isArray(prefixItems)) {\n    prefixItems.forEach((itemSchema, index) => {\n      if (typeof itemSchema === \"object\" && itemSchema !== null) {\n        assertNoRecordInJsonSchema(\n          itemSchema as JSONSchema7,\n          [...path, `${index}`],\n          contextName,\n        );\n      }\n    });\n  }\n  if (schema.allOf) {\n    schema.allOf.forEach((subSchema, index) => {\n      if (typeof subSchema === \"object\" && subSchema !== null) {\n        assertNoRecordInJsonSchema(\n          subSchema,\n          [...path, `&${index}`],\n          contextName,\n        );\n      }\n    });\n  }\n  if (schema.anyOf) {\n    schema.anyOf.forEach((subSchema, index) => {\n      if (typeof subSchema === \"object\" && subSchema !== null) {\n        assertNoRecordInJsonSchema(\n          subSchema,\n          [...path, `|${index}`],\n          contextName,\n        );\n      }\n    });\n  }\n  if (schema.oneOf) {\n    schema.oneOf.forEach((subSchema, index) => {\n      if (typeof subSchema === \"object\" && subSchema !== null) {\n        assertNoRecordInJsonSchema(\n          subSchema,\n          [...path, `|${index}`],\n          contextName,\n        );\n      }\n    });\n  }\n  if (typeof schema.not === \"object\" && schema.not !== null) {\n    assertNoRecordInJsonSchema(schema.not, [...path, \"!\"], contextName);\n  }\n  if (typeof schema.if === \"object\" && schema.if !== null) {\n    assertNoRecordInJsonSchema(schema.if, [...path, \"if\"], contextName);\n  }\n  if (typeof schema.then === \"object\" && schema.then !== null) {\n    assertNoRecordInJsonSchema(schema.then, [...path, \"then\"], contextName);\n  }\n  if (typeof schema.else === \"object\" && schema.else !== null) {\n    assertNoRecordInJsonSchema(schema.else, [...path, \"else\"], contextName);\n  }\n}\n\n/**\n * Asserts that a schema does not contain record types (objects with dynamic keys).\n * Records are not serializable to JSON Schema in a way that the Tambo backend\n * understands, so they are disallowed.\n *\n * This function accepts Standard Schema validators (Zod, Valibot, ArkType, etc.)\n * or JSON Schema objects. It converts them to JSON Schema and checks for record patterns.\n *\n * For tool schemas that are function types, this extracts and validates the input parameters.\n * @param schema - The schema to validate (Standard Schema or JSON Schema)\n * @param contextName - A human-readable label echoed in the error message\n */\nexport function assertNoRecordSchema(\n  schema: unknown,\n  contextName = \"schema\",\n): void {\n  if (!schema) {\n    return;\n  }\n\n  let jsonSchema: JSONSchema7;\n\n  try {\n    if (isStandardSchema(schema)) {\n      // Handle function schemas specially - extract input parameters\n      const converted = schemaToJsonSchema(schema);\n\n      // If it's a function schema that couldn't be converted, the input params\n      // were extracted in registry.ts, so we can skip validation here\n      if (!converted || Object.keys(converted).length === 0) {\n        return;\n      }\n\n      jsonSchema = converted;\n    } else if (\n      typeof schema === \"object\" &&\n      schema !== null &&\n      \"type\" in schema\n    ) {\n      // Already JSON Schema\n      jsonSchema = schema as JSONSchema7;\n    } else {\n      // Unknown schema type - skip validation\n      return;\n    }\n  } catch {\n    // If schema conversion fails, skip validation\n    // This can happen for function schemas or other special types\n    return;\n  }\n\n  assertNoRecordInJsonSchema(jsonSchema, [], contextName);\n}\n"]}

package/dist/v1/types/auth.d.ts

@@ -1,24 +0,0 @@
-/**
- * Authentication state for the SDK.
- *
- * Discriminated union tracking the current auth lifecycle:
- * - `identified`: ready to make API calls (via userKey or successful token exchange)
- * - `exchanging`: userToken provided, exchange in-flight
- * - `error`: token exchange failed
- * - `invalid`: both userKey AND userToken provided (must choose one)
- * - `unauthenticated`: neither userKey nor userToken provided
- */
-export type TamboAuthState = {
-    status: "identified";
-    source: "userKey" | "tokenExchange";
-} | {
-    status: "exchanging";
-} | {
-    status: "error";
-    error: Error;
-} | {
-    status: "invalid";
-} | {
-    status: "unauthenticated";
-};
-//# sourceMappingURL=auth.d.ts.map

package/dist/v1/types/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/v1/types/auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,SAAS,GAAG,eAAe,CAAA;CAAE,GAC7D;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,GACxB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GACjC;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,iBAAiB,CAAA;CAAE,CAAC"}

package/dist/v1/types/auth.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=auth.js.map

package/dist/v1/types/auth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/v1/types/auth.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Authentication state for the SDK.\n *\n * Discriminated union tracking the current auth lifecycle:\n * - `identified`: ready to make API calls (via userKey or successful token exchange)\n * - `exchanging`: userToken provided, exchange in-flight\n * - `error`: token exchange failed\n * - `invalid`: both userKey AND userToken provided (must choose one)\n * - `unauthenticated`: neither userKey nor userToken provided\n */\nexport type TamboAuthState =\n  | { status: \"identified\"; source: \"userKey\" | \"tokenExchange\" }\n  | { status: \"exchanging\" }\n  | { status: \"error\"; error: Error }\n  | { status: \"invalid\" }\n  | { status: \"unauthenticated\" };\n"]}