@tambo-ai/react 0.65.2 → 0.66.0

package/dist/schema/schema.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Schema utilities for working with Standard Schema, Zod, 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.
+ *
+ * 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
+ * @module schema
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParametersFromToolSchema = void 0;
+exports.schemaToJsonSchema = schemaToJsonSchema;
+exports.safeSchemaToJsonSchema = safeSchemaToJsonSchema;
+exports.hasInputSchema = hasInputSchema;
+const standard_json_1 = require("@standard-community/standard-json");
+const json_schema_1 = require("./json-schema");
+const standard_schema_1 = require("./standard-schema");
+const zod_1 = require("./zod");
+// Register the Zod vendor converter with standard-json
+(0, standard_json_1.loadVendor)("zod", zod_1.handleZodSchemaToJson);
+/**
+ * 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
+ * `@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;
+    }
+}
+/**
+ * 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
+ */
+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 (!("toolSchema" in tool) || !tool.toolSchema) {
+        return undefined;
+    }
+    if ((0, json_schema_1.looksLikeJSONSchema)(tool.toolSchema)) {
+        return tool.toolSchema;
+    }
+    return (0, zod_1.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.
+ * @param schema - The input schema (JSON Schema)
+ * @returns A single parameter specification
+ */
+function createInputParameter(schema) {
+    return {
+        name: "input",
+        type: typeof schema.type === "string" ? schema.type : "object",
+        description: schema.description ?? "",
+        isRequired: true,
+        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.
+ * @param tool - The tool containing the schema
+ * @returns An array of parameter specifications
+ */
+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 ((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 [createInputParameter(jsonSchema)];
+    }
+    // Deprecated interface: toolSchema with positional tuple args
+    const argsSchema = getArgsFromToolSchema(tool);
+    if (!argsSchema) {
+        console.warn("No toolSchema found, returning empty parameters");
+        return [];
+    }
+    // Convert to JSON Schema if needed
+    // For toolSchema, the args are typically a Zod tuple from z.function().args(...)
+    // We use direct Zod conversion to ensure proper tuple handling
+    let jsonSchema;
+    if ((0, json_schema_1.looksLikeJSONSchema)(argsSchema)) {
+        jsonSchema = argsSchema;
+    }
+    else if ((0, zod_1.isZodSchema)(argsSchema)) {
+        // Use direct Zod conversion for more reliable tuple handling
+        jsonSchema = (0, zod_1.handleZodSchemaToJson)(argsSchema);
+    }
+    else if ((0, standard_schema_1.isStandardSchema)(argsSchema)) {
+        jsonSchema = schemaToJsonSchema(argsSchema);
+    }
+    else {
+        console.warn("Unknown toolSchema args type, returning empty parameters");
+        return [];
+    }
+    // Extract tuple items for positional params
+    if ((0, json_schema_1.isJsonSchemaTuple)(jsonSchema)) {
+        const tupleItems = (0, json_schema_1.getJsonSchemaTupleItems)(jsonSchema) ?? [];
+        return extractParamsFromJsonSchemaTuple(tupleItems);
+    }
+    // Fallback: wrap as single param (shouldn't normally happen for toolSchema)
+    return extractParamsFromJsonSchemaTuple([jsonSchema]);
+};
+exports.getParametersFromToolSchema = getParametersFromToolSchema;
+//# sourceMappingURL=schema.js.map

package/dist/schema/schema.js.map

@@ -0,0 +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: TamboTool | TamboToolWithToolSchema,\n): StandardSchemaV1 | JSONSchema7 | undefined {\n  if (!(\"toolSchema\" in tool) || !tool.toolSchema) {\n    return undefined;\n  }\n\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 createInputParameter(schema: JSONSchema7): ParameterSpec {\n  return {\n    name: \"input\",\n    type: typeof schema.type === \"string\" ? schema.type : \"object\",\n    description: schema.description ?? \"\",\n    isRequired: true,\n    schema,\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 [createInputParameter(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  // For toolSchema, the args are typically a Zod tuple from z.function().args(...)\n  // We use direct Zod conversion to ensure proper tuple handling\n  let jsonSchema: JSONSchema7;\n  if (looksLikeJSONSchema(argsSchema)) {\n    jsonSchema = argsSchema;\n  } else if (isZodSchema(argsSchema)) {\n    // Use direct Zod conversion for more reliable tuple handling\n    jsonSchema = handleZodSchemaToJson(argsSchema) as JSONSchema7;\n  } else if (isStandardSchema(argsSchema)) {\n    jsonSchema = schemaToJsonSchema(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"]}

package/dist/schema/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../src/schema/schema.test.ts"],"names":[],"mappings":""}

package/dist/schema/schema.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zodInternalAlias_1 = require("zodInternalAlias");
+const json_schema_1 = require("./json-schema");
+const standard_schema_1 = require("./standard-schema");
+describe("schema utilities", () => {
+    describe("looksLikeJSONSchema", () => {
+        it("returns true for a basic JSON Schema object", () => {
+            const jsonSchema = {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "integer" },
+                },
+                required: ["name"],
+            };
+            expect((0, json_schema_1.looksLikeJSONSchema)(jsonSchema)).toBe(true);
+        });
+        it("returns true for a union type JSON Schema", () => {
+            const jsonSchema = {
+                type: ["string", "null"],
+            };
+            expect((0, json_schema_1.looksLikeJSONSchema)(jsonSchema)).toBe(true);
+        });
+        it("returns false for Standard Schema validators", () => {
+            const zodSchema = zodInternalAlias_1.z.object({
+                name: zodInternalAlias_1.z.string(),
+            });
+            expect((0, standard_schema_1.isStandardSchema)(zodSchema)).toBe(true);
+            expect((0, json_schema_1.looksLikeJSONSchema)(zodSchema)).toBe(false);
+        });
+        it("returns false for arbitrary objects that do not resemble JSON Schema", () => {
+            const notSchema = {
+                type: "foo",
+                other: "bar",
+            };
+            expect((0, json_schema_1.looksLikeJSONSchema)(notSchema)).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=schema.test.js.map

package/dist/schema/schema.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.js","sourceRoot":"","sources":["../../src/schema/schema.test.ts"],"names":[],"mappings":";;AACA,uDAAqC;AACrC,+CAAoD;AACpD,uDAAqD;AAErD,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACnC,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,MAAM,UAAU,GAAgB;gBAC9B,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBACxB,GAAG,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;iBACzB;gBACD,QAAQ,EAAE,CAAC,MAAM,CAAC;aACnB,CAAC;YAEF,MAAM,CAAC,IAAA,iCAAmB,EAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;YACnD,MAAM,UAAU,GAAgB;gBAC9B,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;aACzB,CAAC;YAEF,MAAM,CAAC,IAAA,iCAAmB,EAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;YACtD,MAAM,SAAS,GAAG,oBAAC,CAAC,MAAM,CAAC;gBACzB,IAAI,EAAE,oBAAC,CAAC,MAAM,EAAE;aACjB,CAAC,CAAC;YAEH,MAAM,CAAC,IAAA,kCAAgB,EAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC/C,MAAM,CAAC,IAAA,iCAAmB,EAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sEAAsE,EAAE,GAAG,EAAE;YAC9E,MAAM,SAAS,GAAG;gBAChB,IAAI,EAAE,KAAK;gBACX,KAAK,EAAE,KAAK;aACb,CAAC;YAEF,MAAM,CAAC,IAAA,iCAAmB,EAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import type { JSONSchema7 } from \"json-schema\";\nimport { z } from \"zodInternalAlias\";\nimport { looksLikeJSONSchema } from \"./json-schema\";\nimport { isStandardSchema } from \"./standard-schema\";\n\ndescribe(\"schema utilities\", () => {\n  describe(\"looksLikeJSONSchema\", () => {\n    it(\"returns true for a basic JSON Schema object\", () => {\n      const jsonSchema: JSONSchema7 = {\n        type: \"object\",\n        properties: {\n          name: { type: \"string\" },\n          age: { type: \"integer\" },\n        },\n        required: [\"name\"],\n      };\n\n      expect(looksLikeJSONSchema(jsonSchema)).toBe(true);\n    });\n\n    it(\"returns true for a union type JSON Schema\", () => {\n      const jsonSchema: JSONSchema7 = {\n        type: [\"string\", \"null\"],\n      };\n\n      expect(looksLikeJSONSchema(jsonSchema)).toBe(true);\n    });\n\n    it(\"returns false for Standard Schema validators\", () => {\n      const zodSchema = z.object({\n        name: z.string(),\n      });\n\n      expect(isStandardSchema(zodSchema)).toBe(true);\n      expect(looksLikeJSONSchema(zodSchema)).toBe(false);\n    });\n\n    it(\"returns false for arbitrary objects that do not resemble JSON Schema\", () => {\n      const notSchema = {\n        type: \"foo\",\n        other: \"bar\",\n      };\n\n      expect(looksLikeJSONSchema(notSchema)).toBe(false);\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,21 @@
+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.
+ * @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

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

package/dist/schema/standard-schema.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStandardSchema = isStandardSchema;
+const zodInternalAlias_1 = require("zodInternalAlias");
+const standardSchemaProps = zodInternalAlias_1.z.object({
+    version: zodInternalAlias_1.z.literal(1),
+    vendor: zodInternalAlias_1.z.string(),
+    validate: zodInternalAlias_1.z.function({
+        input: [zodInternalAlias_1.z.unknown()],
+        output: zodInternalAlias_1.z.union([zodInternalAlias_1.z.unknown(), zodInternalAlias_1.z.promise(zodInternalAlias_1.z.unknown())]),
+    }),
+});
+const standardSchemaObject = zodInternalAlias_1.z.object({
+    "~standard": standardSchemaProps,
+});
+/**
+ * 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.
+ * @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) {
+    return standardSchemaObject.safeParse(obj).success;
+}
+//# sourceMappingURL=standard-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../src/schema/standard-schema.ts"],"names":[],"mappings":";;AAkCA,4CAEC;AAnCD,uDAAqC;AAErC,MAAM,mBAAmB,GAAG,oBAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,oBAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACrB,MAAM,EAAE,oBAAC,CAAC,MAAM,EAAE;IAClB,QAAQ,EAAE,oBAAC,CAAC,QAAQ,CAAC;QACnB,KAAK,EAAE,CAAC,oBAAC,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,EAAE,oBAAC,CAAC,KAAK,CAAC,CAAC,oBAAC,CAAC,OAAO,EAAE,EAAE,oBAAC,CAAC,OAAO,CAAC,oBAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;KACvD,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,oBAAoB,GAAG,oBAAC,CAAC,MAAM,CAAC;IACpC,WAAW,EAAE,mBAAmB;CACjC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,gBAAgB,CAAC,GAAY;IAC3C,OAAO,oBAAoB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;AACrD,CAAC","sourcesContent":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { z } from \"zodInternalAlias\";\n\nconst standardSchemaProps = z.object({\n  version: z.literal(1),\n  vendor: z.string(),\n  validate: z.function({\n    input: [z.unknown()],\n    output: z.union([z.unknown(), z.promise(z.unknown())]),\n  }),\n});\n\nconst standardSchemaObject = z.object({\n  \"~standard\": standardSchemaProps,\n});\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 * @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  return standardSchemaObject.safeParse(obj).success;\n}\n"]}

package/dist/schema/validate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,148 @@
+"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

@@ -0,0 +1 @@
+{"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/schema/validate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.test.d.ts","sourceRoot":"","sources":["../../src/schema/validate.test.ts"],"names":[],"mappings":""}