@tambo-ai/react 0.69.1 → 0.71.0

package/esm/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}

package/esm/schema/index.js

@@ -1,6 +1,5 @@
 export { looksLikeJSONSchema, makeJsonSchemaPartial } from "./json-schema";
-export { getParametersFromToolSchema, hasInputSchema, safeSchemaToJsonSchema, schemaToJsonSchema, } from "./schema";
+export { getParametersFromToolSchema, safeSchemaToJsonSchema, schemaToJsonSchema, } from "./schema";
 export { isStandardSchema } from "./standard-schema";
 export { assertNoRecordSchema } from "./validate";
-export { getZodFunctionArgs, getZodFunctionReturns } from "./zod";
 //# sourceMappingURL=index.js.map

package/esm/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC","sourcesContent":["export { looksLikeJSONSchema, makeJsonSchemaPartial } from \"./json-schema\";\nexport {\n  getParametersFromToolSchema,\n  hasInputSchema,\n  safeSchemaToJsonSchema,\n  schemaToJsonSchema,\n  type SupportedSchema,\n} from \"./schema\";\nexport { isStandardSchema } from \"./standard-schema\";\nexport { assertNoRecordSchema } from \"./validate\";\nexport { getZodFunctionArgs, getZodFunctionReturns } from \"./zod\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC","sourcesContent":["export { looksLikeJSONSchema, makeJsonSchemaPartial } from \"./json-schema\";\nexport {\n  getParametersFromToolSchema,\n  safeSchemaToJsonSchema,\n  schemaToJsonSchema,\n  type SupportedSchema,\n} from \"./schema\";\nexport { isStandardSchema } from \"./standard-schema\";\nexport { assertNoRecordSchema } from \"./validate\";\n"]}

package/esm/schema/schema.d.ts

@@ -1,23 +1,20 @@
 /**
- * Schema utilities for working with Standard Schema, Zod, and JSON Schema.
+ * 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 and other validation libraries.
+ * 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`, with:
- * - Zod 4: Uses Zod's native toJSONSchema
- * - Zod 3: Requires optional peer dependency 'zod-to-json-schema'
- * - Other vendors: Handled by standard-json's built-in converters
+ * JSON Schema conversion is handled by `@standard-community/standard-json`.
  * @module schema
  */
 import type { JSONSchema7 } from "json-schema";
-import { ParameterSpec, SupportedSchema, TamboTool, TamboToolWithToolSchema } from "../model/component-metadata";
+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, Valibot, ArkType, etc.), uses
+ * 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
@@ -43,24 +40,10 @@ export declare function schemaToJsonSchema(schema: SupportedSchema): JSONSchema7
  */
 export declare function safeSchemaToJsonSchema(schema: SupportedSchema | undefined | null, onError?: (error: unknown) => void): JSONSchema7 | undefined;
 /**
- * Checks if a tool uses the new inputSchema interface (vs deprecated toolSchema).
- * @param tool - The Tambo tool to check
- * @returns True if the tool uses inputSchema
- */
-export declare function hasInputSchema(tool: TamboTool | TamboToolWithToolSchema): tool is TamboTool;
-/**
- * Extracts parameter specifications from a tool schema.
- *
- * For tools with **inputSchema** (new interface):
- * - Returns a single parameter named "input" representing the object schema
- * - The inputSchema defines the shape of the single object argument
- *
- * For tools with **toolSchema** (deprecated):
- * - Extracts positional parameters from tuple/function args
- * - Returns params named "param1", "param2", etc.
+ * Extracts parameter specifications from a tool's inputSchema.
  * @param tool - The tool containing the schema
  * @returns An array of parameter specifications
  */
-export declare const getParametersFromToolSchema: (tool: TamboTool | TamboToolWithToolSchema) => ParameterSpec[];
+export declare function getParametersFromToolSchema(tool: TamboTool): ParameterSpec[];
 export type { SupportedSchema };
 //# sourceMappingURL=schema.d.ts.map

package/esm/schema/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EACL,aAAa,EACb,eAAe,EACf,SAAS,EACT,uBAAuB,EACxB,MAAM,6BAA6B,CAAC;AAYrC;;;;;;;;;;;;;;;;;;;;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;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,GAAG,uBAAuB,GACxC,IAAI,IAAI,SAAS,CAEnB;AAwED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,SAAS,GAAG,uBAAuB,KACxC,aAAa,EAmDf,CAAC;AAEF,YAAY,EAAE,eAAe,EAAE,CAAC"}
+{"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/esm/schema/schema.js

@@ -1,27 +1,37 @@
 /**
- * Schema utilities for working with Standard Schema, Zod, and JSON Schema.
+ * 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 and other validation libraries.
+ * 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`, with:
- * - Zod 4: Uses Zod's native toJSONSchema
- * - Zod 3: Requires optional peer dependency 'zod-to-json-schema'
- * - Other vendors: Handled by standard-json's built-in converters
+ * JSON Schema conversion is handled by `@standard-community/standard-json`.
  * @module schema
  */
 import { loadVendor, toJsonSchema } from "@standard-community/standard-json";
-import { getJsonSchemaTupleItems, isJsonSchemaTuple, looksLikeJSONSchema, } from "./json-schema";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { toJSONSchema as zod4ToJSONSchema } from "zod/v4/core";
+import { looksLikeJSONSchema } from "./json-schema";
 import { isStandardSchema } from "./standard-schema";
-import { getZodFunctionArgs, handleZodSchemaToJson, isZodSchema } from "./zod";
-// Register the Zod vendor converter with standard-json
-loadVendor("zod", handleZodSchemaToJson);
+/**
+ * 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.
+ */
+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 zod4ToJSONSchema(schema);
+    }
+    // Fall back to zod-to-json-schema for Zod 3.x
+    return 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, Valibot, ArkType, etc.), uses
+ * 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
@@ -65,47 +75,10 @@ export function safeSchemaToJsonSchema(schema, onError) {
     }
 }
 /**
- * Checks if a tool uses the new inputSchema interface (vs deprecated toolSchema).
- * @param tool - The Tambo tool to check
- * @returns True if the tool uses inputSchema
- */
-export function hasInputSchema(tool) {
-    return "inputSchema" in tool && tool.inputSchema != null;
-}
-/**
- * Retrieves the input schema for a Tambo tool using the deprecated toolSchema.
- * For toolSchema, this extracts the args from the Zod function schema.
- * @param tool - The Tambo tool (potentially with toolSchema)
- * @returns The input schema (Standard Schema or JSON Schema), or undefined if not toolSchema
- */
-function getArgsFromToolSchema(tool) {
-    if (looksLikeJSONSchema(tool.toolSchema)) {
-        return tool.toolSchema;
-    }
-    return getZodFunctionArgs(tool.toolSchema);
-}
-/**
- * Extracts parameter specifications from JSON Schema tuple items.
- * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).
- * This is library-agnostic - works with Zod, Valibot, ArkType, etc.
- * @param tupleItems - The array of JSON Schema items
- * @returns An array of parameter specifications
- */
-function extractParamsFromJsonSchemaTuple(tupleItems) {
-    return tupleItems.map((item, index) => ({
-        name: `param${index + 1}`,
-        type: typeof item.type === "string" ? item.type : "object",
-        description: item.description ?? "",
-        isRequired: true, // tuple items are positional
-        schema: item,
-    }));
-}
-/**
- * Creates a single parameter spec from an input schema.
- * Used for the new inputSchema interface where the schema represents
- * the shape of the single object argument to the tool function.
+ * 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 A single parameter specification
+ * @returns An array of parameter specifications
  */
 function createParametersFromSchema(schema) {
     const properties = schema.properties ?? {};
@@ -128,66 +101,24 @@ function createParametersFromSchema(schema) {
     }));
 }
 /**
- * Extracts parameter specifications from a tool schema.
- *
- * For tools with **inputSchema** (new interface):
- * - Returns a single parameter named "input" representing the object schema
- * - The inputSchema defines the shape of the single object argument
- *
- * For tools with **toolSchema** (deprecated):
- * - Extracts positional parameters from tuple/function args
- * - Returns params named "param1", "param2", etc.
+ * Extracts parameter specifications from a tool's inputSchema.
  * @param tool - The tool containing the schema
  * @returns An array of parameter specifications
  */
-export const getParametersFromToolSchema = (tool) => {
-    // New interface: inputSchema represents the single object argument
-    if (hasInputSchema(tool)) {
-        const schema = tool.inputSchema;
-        // Convert to JSON Schema if needed
-        let jsonSchema;
-        if (looksLikeJSONSchema(schema)) {
-            jsonSchema = schema;
-        }
-        else if (isStandardSchema(schema)) {
-            jsonSchema = schemaToJsonSchema(schema);
-        }
-        else {
-            console.warn("Unknown inputSchema type, returning empty parameters");
-            return [];
-        }
-        return createParametersFromSchema(jsonSchema);
-    }
-    // Deprecated interface: toolSchema with positional tuple args
-    const argsSchema = getArgsFromToolSchema(tool);
-    if (!argsSchema) {
-        console.warn("No toolSchema found, returning empty parameters");
-        return [];
-    }
+export function getParametersFromToolSchema(tool) {
+    const schema = tool.inputSchema;
     // Convert to JSON Schema if needed
     let jsonSchema;
-    // zod 3 and 4 are both compatible with StandardSchema
-    if (isZodSchema(argsSchema)) {
-        jsonSchema = handleZodSchemaToJson(argsSchema);
+    if (looksLikeJSONSchema(schema)) {
+        jsonSchema = schema;
     }
-    else if (isStandardSchema(argsSchema)) {
-        // uses @standard-community/standard-json for conversion
-        jsonSchema = schemaToJsonSchema(argsSchema);
-    }
-    else if (looksLikeJSONSchema(argsSchema)) {
-        // already JSON Schema
-        jsonSchema = argsSchema;
+    else if (isStandardSchema(schema)) {
+        jsonSchema = schemaToJsonSchema(schema);
     }
     else {
-        console.warn("Unknown toolSchema args type, returning empty parameters");
+        console.warn("Unknown inputSchema type, returning empty parameters");
         return [];
     }
-    // Extract tuple items for positional params
-    if (isJsonSchemaTuple(jsonSchema)) {
-        const tupleItems = getJsonSchemaTupleItems(jsonSchema) ?? [];
-        return extractParamsFromJsonSchemaTuple(tupleItems);
-    }
-    // Fallback: wrap as single param (shouldn't normally happen for toolSchema)
-    return extractParamsFromJsonSchemaTuple([jsonSchema]);
-};
+    return createParametersFromSchema(jsonSchema);
+}
 //# sourceMappingURL=schema.js.map

package/esm/schema/schema.js.map

@@ -1 +1 @@
-{"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, Zod, 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 and other validation libraries.\n *\n * JSON Schema conversion is handled by `@standard-community/standard-json`, with:\n * - Zod 4: Uses Zod's native toJSONSchema\n * - Zod 3: Requires optional peer dependency 'zod-to-json-schema'\n * - Other vendors: Handled by standard-json's built-in converters\n * @module schema\n */\n\nimport { loadVendor, toJsonSchema } from \"@standard-community/standard-json\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport {\n  ParameterSpec,\n  SupportedSchema,\n  TamboTool,\n  TamboToolWithToolSchema,\n} from \"../model/component-metadata\";\nimport {\n  getJsonSchemaTupleItems,\n  isJsonSchemaTuple,\n  looksLikeJSONSchema,\n} from \"./json-schema\";\nimport { isStandardSchema } from \"./standard-schema\";\nimport { getZodFunctionArgs, handleZodSchemaToJson, isZodSchema } from \"./zod\";\n\n// Register the Zod vendor converter with standard-json\nloadVendor(\"zod\", handleZodSchemaToJson);\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, Valibot, ArkType, 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 * Checks if a tool uses the new inputSchema interface (vs deprecated toolSchema).\n * @param tool - The Tambo tool to check\n * @returns True if the tool uses inputSchema\n */\nexport function hasInputSchema(\n  tool: TamboTool | TamboToolWithToolSchema,\n): tool is TamboTool {\n  return \"inputSchema\" in tool && tool.inputSchema != null;\n}\n\n/**\n * Retrieves the input schema for a Tambo tool using the deprecated toolSchema.\n * For toolSchema, this extracts the args from the Zod function schema.\n * @param tool - The Tambo tool (potentially with toolSchema)\n * @returns The input schema (Standard Schema or JSON Schema), or undefined if not toolSchema\n */\nfunction getArgsFromToolSchema(\n  tool: TamboToolWithToolSchema,\n): StandardSchemaV1 | JSONSchema7 | undefined {\n  if (looksLikeJSONSchema(tool.toolSchema)) {\n    return tool.toolSchema;\n  }\n\n  return getZodFunctionArgs(tool.toolSchema);\n}\n\n/**\n * Extracts parameter specifications from JSON Schema tuple items.\n * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).\n * This is library-agnostic - works with Zod, Valibot, ArkType, etc.\n * @param tupleItems - The array of JSON Schema items\n * @returns An array of parameter specifications\n */\nfunction extractParamsFromJsonSchemaTuple(\n  tupleItems: JSONSchema7[],\n): ParameterSpec[] {\n  return tupleItems.map((item, index) => ({\n    name: `param${index + 1}`,\n    type: typeof item.type === \"string\" ? item.type : \"object\",\n    description: item.description ?? \"\",\n    isRequired: true, // tuple items are positional\n    schema: item,\n  }));\n}\n\n/**\n * Creates a single parameter spec from an input schema.\n * Used for the new inputSchema interface where the schema represents\n * the shape of the single object argument to the tool function.\n * @param schema - The input schema (JSON Schema)\n * @returns A single parameter specification\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 schema.\n *\n * For tools with **inputSchema** (new interface):\n * - Returns a single parameter named \"input\" representing the object schema\n * - The inputSchema defines the shape of the single object argument\n *\n * For tools with **toolSchema** (deprecated):\n * - Extracts positional parameters from tuple/function args\n * - Returns params named \"param1\", \"param2\", etc.\n * @param tool - The tool containing the schema\n * @returns An array of parameter specifications\n */\nexport const getParametersFromToolSchema = (\n  tool: TamboTool | TamboToolWithToolSchema,\n): ParameterSpec[] => {\n  // New interface: inputSchema represents the single object argument\n  if (hasInputSchema(tool)) {\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\n  // Deprecated interface: toolSchema with positional tuple args\n  const argsSchema = getArgsFromToolSchema(tool);\n\n  if (!argsSchema) {\n    console.warn(\"No toolSchema found, returning empty parameters\");\n    return [];\n  }\n\n  // Convert to JSON Schema if needed\n  let jsonSchema: JSONSchema7;\n  // zod 3 and 4 are both compatible with StandardSchema\n  if (isZodSchema(argsSchema)) {\n    jsonSchema = handleZodSchemaToJson(argsSchema);\n  } else if (isStandardSchema(argsSchema)) {\n    // uses @standard-community/standard-json for conversion\n    jsonSchema = schemaToJsonSchema(argsSchema);\n  } else if (looksLikeJSONSchema(argsSchema)) {\n    // already JSON Schema\n    jsonSchema = argsSchema;\n  } else {\n    console.warn(\"Unknown toolSchema args type, returning empty parameters\");\n    return [];\n  }\n\n  // Extract tuple items for positional params\n  if (isJsonSchemaTuple(jsonSchema)) {\n    const tupleItems = getJsonSchemaTupleItems(jsonSchema) ?? [];\n    return extractParamsFromJsonSchemaTuple(tupleItems);\n  }\n\n  // Fallback: wrap as single param (shouldn't normally happen for toolSchema)\n  return extractParamsFromJsonSchemaTuple([jsonSchema]);\n};\n\nexport type { SupportedSchema };\n"]}
+{"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/esm/schema/schema.test.js

@@ -1,7 +1,7 @@
 import * as z3 from "zod/v3";
 import * as z4 from "zod/v4";
 import { looksLikeJSONSchema } from "./json-schema";
-import { getParametersFromToolSchema, hasInputSchema, safeSchemaToJsonSchema, schemaToJsonSchema, } from "./schema";
+import { getParametersFromToolSchema, safeSchemaToJsonSchema, schemaToJsonSchema, } from "./schema";
 import { isStandardSchema } from "./standard-schema";
 describe("schema utilities", () => {
     describe("looksLikeJSONSchema", () => {
@@ -272,40 +272,6 @@ describe("schema utilities", () => {
                 expect(required2?.isRequired).toBe(true);
             });
         });
-        describe("deprecated toolSchema interface (tuple/positional args)", () => {
-            it("extracts positional parameters from Zod 3 function schema", () => {
-                const tool = {
-                    name: "test-tool",
-                    description: "Test tool",
-                    tool: jest.fn(),
-                    toolSchema: z3
-                        .function()
-                        .args(z3.string().describe("First arg"), z3.number().describe("Second arg"))
-                        .returns(z3.void()),
-                };
-                const params = getParametersFromToolSchema(tool);
-                // toolSchema uses positional params (param1, param2, etc.)
-                expect(params.length).toBeGreaterThanOrEqual(1);
-                expect(params[0].name).toBe("param1");
-            });
-            it("handles toolSchema with JSON Schema directly", () => {
-                const tool = {
-                    name: "test-tool",
-                    description: "Test tool",
-                    tool: jest.fn(),
-                    toolSchema: {
-                        type: "object",
-                        properties: {
-                            query: { type: "string", description: "Search query" },
-                        },
-                        required: ["query"],
-                    },
-                };
-                const params = getParametersFromToolSchema(tool);
-                // JSON Schema in toolSchema should return params wrapped
-                expect(params.length).toBeGreaterThanOrEqual(1);
-            });
-        });
         describe("edge cases and error handling", () => {
             it("returns empty params when inputSchema is unknown type", () => {
                 // Create a tool with an invalid inputSchema that isn't Standard Schema or JSON Schema
@@ -321,93 +287,60 @@ describe("schema utilities", () => {
                 consoleSpy.mockRestore();
                 expect(params).toEqual([]);
             });
-            it("throws when toolSchema is undefined", () => {
-                // Create a tool with toolSchema that has undefined toolSchema
-                const tool = {
-                    name: "test-tool",
-                    description: "Test tool",
-                    tool: jest.fn(),
-                    toolSchema: undefined,
-                };
-                expect(() => getParametersFromToolSchema(tool)).toThrow("Unable to determine parameters from zod function schema");
-            });
-            it("throws when toolSchema args are not recognized", () => {
-                // Create a tool with toolSchema that is not a function schema or JSON schema
-                // This causes getArgsFromToolSchema to attempt extraction but fail
-                const tool = {
-                    name: "test-tool",
-                    description: "Test tool",
-                    tool: jest.fn(),
-                    toolSchema: { notASchema: true },
-                };
-                // This throws because it's not a Zod function schema
-                expect(() => getParametersFromToolSchema(tool)).toThrow("Unable to determine parameters from zod function schema");
-            });
-        });
-        describe("toolSchema with JSON Schema tuple", () => {
-            it("handles toolSchema with JSON Schema array/tuple directly", () => {
+            it("handles JSON Schema with no properties field", () => {
+                // Test the fallback: const properties = schema.properties ?? {};
                 const tool = {
                     name: "test-tool",
                     description: "Test tool",
                     tool: jest.fn(),
-                    // JSON Schema tuple format
-                    toolSchema: {
-                        type: "array",
-                        items: [
-                            { type: "string", description: "First param" },
-                            { type: "number", description: "Second param" },
-                        ],
+                    inputSchema: {
+                        type: "object",
+                        // No properties field
                     },
+                    outputSchema: z4.void(),
                 };
                 const params = getParametersFromToolSchema(tool);
-                // JSON Schema tuples should be extracted as positional params
-                expect(params).toHaveLength(2);
-                expect(params[0].name).toBe("param1");
-                expect(params[0].type).toBe("string");
-                expect(params[0].description).toBe("First param");
-                expect(params[1].name).toBe("param2");
-                expect(params[1].type).toBe("number");
+                expect(params).toEqual([]);
             });
-            it("handles toolSchema with JSON Schema prefixItems (2020-12 format)", () => {
+            it("handles JSON Schema properties without descriptions", () => {
+                // Test the fallback: propSchema.description ?? ""
                 const tool = {
                     name: "test-tool",
                     description: "Test tool",
                     tool: jest.fn(),
-                    // JSON Schema 2020-12 tuple format
-                    toolSchema: {
-                        type: "array",
-                        prefixItems: [
-                            { type: "boolean", description: "Flag" },
-                            { type: "string" },
-                        ],
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" }, // No description
+                            age: { type: "number" }, // No description
+                        },
                     },
+                    outputSchema: z4.void(),
                 };
                 const params = getParametersFromToolSchema(tool);
                 expect(params).toHaveLength(2);
-                expect(params[0].name).toBe("param1");
-                expect(params[0].type).toBe("boolean");
-                expect(params[0].description).toBe("Flag");
-                expect(params[1].name).toBe("param2");
-                expect(params[1].type).toBe("string");
+                expect(params[0].description).toBe("");
+                expect(params[1].description).toBe("");
             });
-            it("handles toolSchema with non-tuple JSON Schema (fallback)", () => {
+            it("handles JSON Schema with non-object property values", () => {
+                // Test the fallback: typeof propSchema === "object" && propSchema !== null ? propSchema : {}
                 const tool = {
                     name: "test-tool",
                     description: "Test tool",
                     tool: jest.fn(),
-                    // Non-tuple JSON Schema - should be wrapped as single param
-                    toolSchema: {
+                    inputSchema: {
                         type: "object",
                         properties: {
-                            name: { type: "string" },
+                            // Properties can technically be boolean (for schema composition)
+                            weird: true,
                         },
                     },
+                    outputSchema: z4.void(),
                 };
                 const params = getParametersFromToolSchema(tool);
-                // Non-tuple schemas should be wrapped as a single param
                 expect(params).toHaveLength(1);
-                expect(params[0].name).toBe("param1");
-                expect(params[0].type).toBe("object");
+                expect(params[0].name).toBe("weird");
+                expect(params[0].schema).toEqual({});
             });
         });
     });
@@ -496,36 +429,5 @@ describe("schema utilities", () => {
             consoleSpy.mockRestore();
         });
     });
-    describe("hasInputSchema", () => {
-        it("returns true for tool with inputSchema", () => {
-            const tool = {
-                name: "test",
-                description: "test",
-                tool: jest.fn(),
-                inputSchema: z4.object({ a: z4.string() }),
-                outputSchema: z4.void(),
-            };
-            expect(hasInputSchema(tool)).toBe(true);
-        });
-        it("returns false for tool with toolSchema (deprecated)", () => {
-            const tool = {
-                name: "test",
-                description: "test",
-                tool: jest.fn(),
-                toolSchema: z3.function().args(z3.string()).returns(z3.void()),
-            };
-            expect(hasInputSchema(tool)).toBe(false);
-        });
-        it("returns false for tool with null inputSchema", () => {
-            const tool = {
-                name: "test",
-                description: "test",
-                tool: jest.fn(),
-                inputSchema: null,
-                outputSchema: z4.void(),
-            };
-            expect(hasInputSchema(tool)).toBe(false);
-        });
-    });
 });
 //# sourceMappingURL=schema.test.js.map