@tambo-ai/react 0.65.2 → 0.66.0

package/dist/schema/validate.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zodInternalAlias_1 = require("zodInternalAlias");
+const validate_1 = require("./validate");
+describe("assertNoRecordSchema", () => {
+    it("should allow valid schemas without records", () => {
+        const schema = zodInternalAlias_1.z.object({
+            name: zodInternalAlias_1.z.string(),
+            age: zodInternalAlias_1.z.number(),
+            tags: zodInternalAlias_1.z.array(zodInternalAlias_1.z.string()),
+            address: zodInternalAlias_1.z.object({
+                street: zodInternalAlias_1.z.string(),
+                city: zodInternalAlias_1.z.string(),
+            }),
+        });
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).not.toThrow();
+    });
+    it("should throw when encountering a record at root level", () => {
+        const schema = zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string());
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "(root)". Replace it with an object using explicit keys.');
+    });
+    it("should throw when encountering a nested record", () => {
+        const schema = zodInternalAlias_1.z.object({
+            name: zodInternalAlias_1.z.string(),
+            metadata: zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string()),
+        });
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "metadata". Replace it with an object using explicit keys.');
+    });
+    it("should throw when encountering a record in an array", () => {
+        const schema = zodInternalAlias_1.z.object({
+            items: zodInternalAlias_1.z.array(zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string())),
+        });
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "items.[]". Replace it with an object using explicit keys.');
+    });
+    it("should throw when encountering a record in a union", () => {
+        const schema = zodInternalAlias_1.z.union([zodInternalAlias_1.z.string(), zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.number())]);
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "|1". Replace it with an object using explicit keys.');
+    });
+    it("should throw when encountering a record in an intersection", () => {
+        const schema = zodInternalAlias_1.z.intersection(zodInternalAlias_1.z.object({ name: zodInternalAlias_1.z.string() }), zodInternalAlias_1.z.object({ metadata: zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string()) }));
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow(/Record types \(objects with dynamic keys\) are not supported in schema\. Found at path "(&1\.)?metadata"\. Replace it with an object using explicit keys\./);
+    });
+    it("should throw when encountering a record in a discriminated union", () => {
+        const schema = zodInternalAlias_1.z.discriminatedUnion("type", [
+            zodInternalAlias_1.z.object({ type: zodInternalAlias_1.z.literal("string"), value: zodInternalAlias_1.z.string() }),
+            zodInternalAlias_1.z.object({
+                type: zodInternalAlias_1.z.literal("record"),
+                value: zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.number()),
+            }),
+        ]);
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow(/Record types \(objects with dynamic keys\) are not supported in schema\. Found at path "\|1\.value"\. Replace it with an object using explicit keys\./);
+    });
+    it("should throw when encountering a record in an optional field", () => {
+        const schema = zodInternalAlias_1.z.object({
+            optional: zodInternalAlias_1.z.optional(zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string())),
+        });
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "optional". Replace it with an object using explicit keys.');
+    });
+    it("should throw when encountering a record in a nullable field", () => {
+        const schema = zodInternalAlias_1.z.object({
+            nullable: zodInternalAlias_1.z.nullable(zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string())),
+        });
+        // Nullable creates a oneOf in JSON Schema, so the path includes the union index
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow(/Record types \(objects with dynamic keys\) are not supported in schema\. Found at path "nullable(\.\|0)?"\. Replace it with an object using explicit keys\./);
+    });
+    it("should throw when encountering a record in a tuple", () => {
+        const schema = zodInternalAlias_1.z.tuple([zodInternalAlias_1.z.string(), zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.number())]);
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "1". Replace it with an object using explicit keys.');
+    });
+    it("should use custom context name in error message", () => {
+        const schema = zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string());
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema, "mySchema")).toThrow('Record types (objects with dynamic keys) are not supported in mySchema. Found at path "(root)". Replace it with an object using explicit keys.');
+    });
+    it("should handle ZodLazy schemas", () => {
+        const schema = zodInternalAlias_1.z.lazy(() => zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.string()));
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "(root)". Replace it with an object using explicit keys.');
+    });
+    it("should allow z.function() with valid arguments", () => {
+        const schema = zodInternalAlias_1.z.function({
+            input: [zodInternalAlias_1.z.string(), zodInternalAlias_1.z.number()],
+            output: zodInternalAlias_1.z.string(),
+        });
+        // Function schemas can't be converted to JSON Schema directly,
+        // so they should not throw (validation happens on the extracted parameters)
+        expect(() => (0, validate_1.assertNoRecordSchema)(schema)).not.toThrow();
+    });
+    it("should allow JSON Schema without records", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                age: { type: "number" },
+            },
+            required: ["name"],
+        };
+        expect(() => (0, validate_1.assertNoRecordSchema)(jsonSchema)).not.toThrow();
+    });
+    it("should throw when JSON Schema has record pattern", () => {
+        const jsonSchema = {
+            type: "object",
+            additionalProperties: { type: "string" },
+        };
+        expect(() => (0, validate_1.assertNoRecordSchema)(jsonSchema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "(root)". Replace it with an object using explicit keys.');
+    });
+    it("should treat JSON Schema with properties and additionalProperties as a record", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+            },
+            additionalProperties: { type: "number" },
+        };
+        expect(() => (0, validate_1.assertNoRecordSchema)(jsonSchema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "(root)". Replace it with an object using explicit keys.');
+    });
+    it("should throw when nested JSON Schema has record pattern", () => {
+        const jsonSchema = {
+            type: "object",
+            properties: {
+                metadata: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                },
+            },
+        };
+        expect(() => (0, validate_1.assertNoRecordSchema)(jsonSchema)).toThrow('Record types (objects with dynamic keys) are not supported in schema. Found at path "metadata". Replace it with an object using explicit keys.');
+    });
+});
+//# sourceMappingURL=validate.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.test.js","sourceRoot":"","sources":["../../src/schema/validate.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zodInternalAlias\";\nimport { assertNoRecordSchema } from \"./validate\";\n\ndescribe(\"assertNoRecordSchema\", () => {\n  it(\"should allow valid schemas without records\", () => {\n    const schema = z.object({\n      name: z.string(),\n      age: z.number(),\n      tags: z.array(z.string()),\n      address: z.object({\n        street: z.string(),\n        city: z.string(),\n      }),\n    });\n\n    expect(() => assertNoRecordSchema(schema)).not.toThrow();\n  });\n\n  it(\"should throw when encountering a record at root level\", () => {\n    const schema = z.record(z.string(), z.string());\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"(root)\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when encountering a nested record\", () => {\n    const schema = z.object({\n      name: z.string(),\n      metadata: z.record(z.string(), z.string()),\n    });\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"metadata\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when encountering a record in an array\", () => {\n    const schema = z.object({\n      items: z.array(z.record(z.string(), z.string())),\n    });\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"items.[]\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when encountering a record in a union\", () => {\n    const schema = z.union([z.string(), z.record(z.string(), z.number())]);\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"|1\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when encountering a record in an intersection\", () => {\n    const schema = z.intersection(\n      z.object({ name: z.string() }),\n      z.object({ metadata: z.record(z.string(), z.string()) }),\n    );\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      /Record types \\(objects with dynamic keys\\) are not supported in schema\\. Found at path \"(&1\\.)?metadata\"\\. Replace it with an object using explicit keys\\./,\n    );\n  });\n\n  it(\"should throw when encountering a record in a discriminated union\", () => {\n    const schema = z.discriminatedUnion(\"type\", [\n      z.object({ type: z.literal(\"string\"), value: z.string() }),\n      z.object({\n        type: z.literal(\"record\"),\n        value: z.record(z.string(), z.number()),\n      }),\n    ]);\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      /Record types \\(objects with dynamic keys\\) are not supported in schema\\. Found at path \"\\|1\\.value\"\\. Replace it with an object using explicit keys\\./,\n    );\n  });\n\n  it(\"should throw when encountering a record in an optional field\", () => {\n    const schema = z.object({\n      optional: z.optional(z.record(z.string(), z.string())),\n    });\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"optional\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when encountering a record in a nullable field\", () => {\n    const schema = z.object({\n      nullable: z.nullable(z.record(z.string(), z.string())),\n    });\n\n    // Nullable creates a oneOf in JSON Schema, so the path includes the union index\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      /Record types \\(objects with dynamic keys\\) are not supported in schema\\. Found at path \"nullable(\\.\\|0)?\"\\. Replace it with an object using explicit keys\\./,\n    );\n  });\n\n  it(\"should throw when encountering a record in a tuple\", () => {\n    const schema = z.tuple([z.string(), z.record(z.string(), z.number())]);\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"1\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should use custom context name in error message\", () => {\n    const schema = z.record(z.string(), z.string());\n\n    expect(() => assertNoRecordSchema(schema, \"mySchema\")).toThrow(\n      'Record types (objects with dynamic keys) are not supported in mySchema. Found at path \"(root)\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should handle ZodLazy schemas\", () => {\n    const schema = z.lazy(() => z.record(z.string(), z.string()));\n\n    expect(() => assertNoRecordSchema(schema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"(root)\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should allow z.function() with valid arguments\", () => {\n    const schema = z.function({\n      input: [z.string(), z.number()],\n      output: z.string(),\n    });\n\n    // Function schemas can't be converted to JSON Schema directly,\n    // so they should not throw (validation happens on the extracted parameters)\n    expect(() => assertNoRecordSchema(schema)).not.toThrow();\n  });\n\n  it(\"should allow JSON Schema without records\", () => {\n    const jsonSchema = {\n      type: \"object\" as const,\n      properties: {\n        name: { type: \"string\" as const },\n        age: { type: \"number\" as const },\n      },\n      required: [\"name\"],\n    };\n\n    expect(() => assertNoRecordSchema(jsonSchema)).not.toThrow();\n  });\n\n  it(\"should throw when JSON Schema has record pattern\", () => {\n    const jsonSchema = {\n      type: \"object\" as const,\n      additionalProperties: { type: \"string\" as const },\n    };\n\n    expect(() => assertNoRecordSchema(jsonSchema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"(root)\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should treat JSON Schema with properties and additionalProperties as a record\", () => {\n    const jsonSchema = {\n      type: \"object\" as const,\n      properties: {\n        id: { type: \"string\" as const },\n      },\n      additionalProperties: { type: \"number\" as const },\n    };\n\n    expect(() => assertNoRecordSchema(jsonSchema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"(root)\". Replace it with an object using explicit keys.',\n    );\n  });\n\n  it(\"should throw when nested JSON Schema has record pattern\", () => {\n    const jsonSchema = {\n      type: \"object\" as const,\n      properties: {\n        metadata: {\n          type: \"object\" as const,\n          additionalProperties: { type: \"string\" as const },\n        },\n      },\n    };\n\n    expect(() => assertNoRecordSchema(jsonSchema)).toThrow(\n      'Record types (objects with dynamic keys) are not supported in schema. Found at path \"metadata\". Replace it with an object using explicit keys.',\n    );\n  });\n});\n"]}

package/dist/schema/zod.d.ts

@@ -0,0 +1,54 @@
+import { ZodFunction, ZodTuple, ZodTupleItems, ZodType, ZodTypeAny } from "zod/v3";
+import { $ZodFunction, $ZodType } from "zod/v4/core";
+/**
+ * @returns True if the schema is a Zod 3 function schema
+ */
+export declare function isZod3FunctionSchema(schema: unknown): schema is ZodFunction<ZodTuple<ZodTupleItems, any>, ZodTypeAny>;
+/**
+ * @returns True if the schema is a Zod 4 function schema
+ */
+export declare function isZod4FunctionSchema(schema: unknown): schema is $ZodFunction;
+/**
+ * Checks if a schema is a Zod function schema (Zod 3 or Zod 4).
+ * @param schema - The schema to check
+ * @returns True if the schema is a Zod function schema
+ */
+export declare function isZodFunctionSchema(schema: unknown): schema is ZodFunction<ZodTuple<ZodTupleItems, any>, ZodTypeAny> | $ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
+/**
+ * Extracts the args schema from a Zod 3 function schema.
+ * @param schema - The Zod 3 function schema
+ * @returns The args schema, or undefined if not a Zod 3 function schema
+ */
+export declare function getZodFunctionArgs(schema: unknown): any;
+/**
+ * Extracts the return schema from a Zod 3 or Zod 4 function schema.
+ * @param schema - The Zod function schema
+ * @returns The return schema, or undefined if not a Zod function schema
+ */
+export declare function getZodFunctionReturns(schema: unknown): any;
+/**
+ * Handles conversion of Zod schemas to JSON Schema.
+ * Supports both Zod 3 (via zod-to-json-schema) and Zod 4 (native).
+ * @param schema - The Zod schema to convert
+ * @returns The JSON Schema representation
+ */
+export declare function handleZodSchemaToJson(schema: unknown): any;
+/**
+ * Checks if a schema is probably a Zod 3 schema.
+ * @param schema - The schema to check
+ * @returns True if the schema looks like a Zod 3 schema
+ */
+export declare function isZod3Schema(schema: unknown): schema is ZodType;
+/**
+ * Detects if a schema is Zod 4 by checking for def.type property.
+ * Zod 4 uses `def.type` with lowercase type names like "object", "string".
+ * @returns True if the schema appears to be Zod 4 style
+ */
+export declare function isZod4Schema(schema: unknown): schema is $ZodType;
+/**
+ * Checks if a schema is a Zod schema
+ * @param schema - The schema to check
+ * @returns True if the schema is a Zod schema
+ */
+export declare function isZodSchema(schema: unknown): ReturnType<typeof isZod3Schema> | ReturnType<typeof isZod4Schema>;
+//# sourceMappingURL=zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,QAAQ,EACR,aAAa,EACb,OAAO,EACP,UAAU,EACX,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,YAAY,EACZ,QAAQ,EAET,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,CAMjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAO5E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,iKAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,OAWjD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAWpD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,OAkBpD;AAaD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,OAAO,CAE/D;AAUD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,QAAQ,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,OAAO,GACd,UAAU,CAAC,OAAO,YAAY,CAAC,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAEnE"}

package/dist/schema/zod.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZod3FunctionSchema = isZod3FunctionSchema;
+exports.isZod4FunctionSchema = isZod4FunctionSchema;
+exports.isZodFunctionSchema = isZodFunctionSchema;
+exports.getZodFunctionArgs = getZodFunctionArgs;
+exports.getZodFunctionReturns = getZodFunctionReturns;
+exports.handleZodSchemaToJson = handleZodSchemaToJson;
+exports.isZod3Schema = isZod3Schema;
+exports.isZod4Schema = isZod4Schema;
+exports.isZodSchema = isZodSchema;
+const core_1 = require("zod/v4/core");
+const zodInternalAlias_1 = require("zodInternalAlias");
+/**
+ * @returns True if the schema is a Zod 3 function schema
+ */
+function isZod3FunctionSchema(schema) {
+    if (!isZod3Schema(schema)) {
+        return false;
+    }
+    return "typeName" in schema._def && schema._def.typeName === "ZodFunction";
+}
+/**
+ * @returns True if the schema is a Zod 4 function schema
+ */
+function isZod4FunctionSchema(schema) {
+    if (!isZod4Schema(schema)) {
+        return false;
+    }
+    // @ts-expect-error -- Error in Zod types for v3 vs v4
+    return "def" in schema && schema._zod.def.type === "function";
+}
+/**
+ * Checks if a schema is a Zod function schema (Zod 3 or Zod 4).
+ * @param schema - The schema to check
+ * @returns True if the schema is a Zod function schema
+ */
+function isZodFunctionSchema(schema) {
+    return isZod3FunctionSchema(schema) || isZod4FunctionSchema(schema);
+}
+/**
+ * Extracts the args schema from a Zod 3 function schema.
+ * @param schema - The Zod 3 function schema
+ * @returns The args schema, or undefined if not a Zod 3 function schema
+ */
+function getZodFunctionArgs(schema) {
+    if (isZod3FunctionSchema(schema)) {
+        return schema._def.args;
+    }
+    if (isZod4FunctionSchema(schema)) {
+        // @ts-expect-error -- Error in Zod types for v3 vs v4
+        return schema._zod.def.input;
+    }
+    throw new Error("Unable to determine parameters from zod function schema");
+}
+/**
+ * Extracts the return schema from a Zod 3 or Zod 4 function schema.
+ * @param schema - The Zod function schema
+ * @returns The return schema, or undefined if not a Zod function schema
+ */
+function getZodFunctionReturns(schema) {
+    if (isZod3FunctionSchema(schema)) {
+        return schema._def.returns;
+    }
+    if (isZod4FunctionSchema(schema)) {
+        // @ts-expect-error -- Error in Zod types for v3 vs v4
+        return schema._zod.def.output;
+    }
+    throw new Error("Unable to determine return type from zod function schema");
+}
+/**
+ * Handles conversion of Zod schemas to JSON Schema.
+ * Supports both Zod 3 (via zod-to-json-schema) and Zod 4 (native).
+ * @param schema - The Zod schema to convert
+ * @returns The JSON Schema representation
+ */
+function handleZodSchemaToJson(schema) {
+    // Detect Zod 4 by checking for def.type
+    if (isZod4Schema(schema))
+        return (0, core_1.toJSONSchema)(schema);
+    try {
+        // Dynamic require for optional peer dependency
+        // eslint-disable-next-line @typescript-eslint/no-require-imports -- need require because zod-to-json-schema may be missing
+        const { zodToJsonSchema } = require("zod-to-json-schema");
+        return zodToJsonSchema(schema);
+    }
+    catch (error) {
+        throw new Error("Zod 3 requires 'zod-to-json-schema' package for JSON Schema conversion. " +
+            "Install it with: npm install zod-to-json-schema", {
+            cause: error,
+        });
+    }
+}
+// Zod 3 schemas have _def with typeName and ~standard with vendor "zod"
+// Use looseObject to allow any _def shape (different for each type)
+const zod3SchemaType = zodInternalAlias_1.z.object({
+    _def: zodInternalAlias_1.z.looseObject({
+        typeName: zodInternalAlias_1.z.string().optional(),
+    }),
+    "~standard": zodInternalAlias_1.z.looseObject({
+        vendor: zodInternalAlias_1.z.literal("zod"),
+    }),
+});
+/**
+ * Checks if a schema is probably a Zod 3 schema.
+ * @param schema - The schema to check
+ * @returns True if the schema looks like a Zod 3 schema
+ */
+function isZod3Schema(schema) {
+    return zod3SchemaType.safeParse(schema).success;
+}
+const zod4SchemaType = zodInternalAlias_1.z.object({
+    def: zodInternalAlias_1.z.object(),
+    _zod: zodInternalAlias_1.z.looseObject({
+        def: zodInternalAlias_1.z.looseObject({}),
+    }),
+    "~standard": zodInternalAlias_1.z.looseObject({}),
+});
+/**
+ * Detects if a schema is Zod 4 by checking for def.type property.
+ * Zod 4 uses `def.type` with lowercase type names like "object", "string".
+ * @returns True if the schema appears to be Zod 4 style
+ */
+function isZod4Schema(schema) {
+    return zod4SchemaType.safeParse(schema).success;
+}
+/**
+ * Checks if a schema is a Zod schema
+ * @param schema - The schema to check
+ * @returns True if the schema is a Zod schema
+ */
+function isZodSchema(schema) {
+    return isZod3Schema(schema) || isZod4Schema(schema);
+}
+//# sourceMappingURL=zod.js.map

package/dist/schema/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.js","sourceRoot":"","sources":["../../src/schema/zod.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ZodFunction,\n  ZodTuple,\n  ZodTupleItems,\n  ZodType,\n  ZodTypeAny,\n} from \"zod/v3\";\nimport {\n  $ZodFunction,\n  $ZodType,\n  toJSONSchema as zod4ToJSONSchema,\n} from \"zod/v4/core\";\nimport { z } from \"zodInternalAlias\";\n\n/**\n * @returns True if the schema is a Zod 3 function schema\n */\nexport function isZod3FunctionSchema(\n  schema: unknown,\n): schema is ZodFunction<ZodTuple<ZodTupleItems, any>, ZodTypeAny> {\n  if (!isZod3Schema(schema)) {\n    return false;\n  }\n\n  return \"typeName\" in schema._def && schema._def.typeName === \"ZodFunction\";\n}\n\n/**\n * @returns True if the schema is a Zod 4 function schema\n */\nexport function isZod4FunctionSchema(schema: unknown): schema is $ZodFunction {\n  if (!isZod4Schema(schema)) {\n    return false;\n  }\n\n  // @ts-expect-error -- Error in Zod types for v3 vs v4\n  return \"def\" in schema && schema._zod.def.type === \"function\";\n}\n\n/**\n * Checks if a schema is a Zod function schema (Zod 3 or Zod 4).\n * @param schema - The schema to check\n * @returns True if the schema is a Zod function schema\n */\nexport function isZodFunctionSchema(schema: unknown) {\n  return isZod3FunctionSchema(schema) || isZod4FunctionSchema(schema);\n}\n\n/**\n * Extracts the args schema from a Zod 3 function schema.\n * @param schema - The Zod 3 function schema\n * @returns The args schema, or undefined if not a Zod 3 function schema\n */\nexport function getZodFunctionArgs(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.args;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4\n    return schema._zod.def.input;\n  }\n\n  throw new Error(\"Unable to determine parameters from zod function schema\");\n}\n\n/**\n * Extracts the return schema from a Zod 3 or Zod 4 function schema.\n * @param schema - The Zod function schema\n * @returns The return schema, or undefined if not a Zod function schema\n */\nexport function getZodFunctionReturns(schema: unknown) {\n  if (isZod3FunctionSchema(schema)) {\n    return schema._def.returns;\n  }\n\n  if (isZod4FunctionSchema(schema)) {\n    // @ts-expect-error -- Error in Zod types for v3 vs v4\n    return schema._zod.def.output;\n  }\n\n  throw new Error(\"Unable to determine return type from zod function schema\");\n}\n\n/**\n * Handles conversion of Zod schemas to JSON Schema.\n * Supports both Zod 3 (via zod-to-json-schema) and Zod 4 (native).\n * @param schema - The Zod schema to convert\n * @returns The JSON Schema representation\n */\nexport function handleZodSchemaToJson(schema: unknown) {\n  // Detect Zod 4 by checking for def.type\n  if (isZod4Schema(schema)) return zod4ToJSONSchema(schema);\n\n  try {\n    // Dynamic require for optional peer dependency\n    // eslint-disable-next-line @typescript-eslint/no-require-imports -- need require because zod-to-json-schema may be missing\n    const { zodToJsonSchema } = require(\"zod-to-json-schema\");\n    return zodToJsonSchema(schema);\n  } catch (error) {\n    throw new Error(\n      \"Zod 3 requires 'zod-to-json-schema' package for JSON Schema conversion. \" +\n        \"Install it with: npm install zod-to-json-schema\",\n      {\n        cause: error,\n      },\n    );\n  }\n}\n\n// Zod 3 schemas have _def with typeName and ~standard with vendor \"zod\"\n// Use looseObject to allow any _def shape (different for each type)\nconst zod3SchemaType = z.object({\n  _def: z.looseObject({\n    typeName: z.string().optional(),\n  }),\n  \"~standard\": z.looseObject({\n    vendor: z.literal(\"zod\"),\n  }),\n});\n\n/**\n * Checks if a schema is probably a Zod 3 schema.\n * @param schema - The schema to check\n * @returns True if the schema looks like a Zod 3 schema\n */\nexport function isZod3Schema(schema: unknown): schema is ZodType {\n  return zod3SchemaType.safeParse(schema).success;\n}\n\nconst zod4SchemaType = z.object({\n  def: z.object(),\n  _zod: z.looseObject({\n    def: z.looseObject({}),\n  }),\n  \"~standard\": z.looseObject({}),\n});\n\n/**\n * Detects if a schema is Zod 4 by checking for def.type property.\n * Zod 4 uses `def.type` with lowercase type names like \"object\", \"string\".\n * @returns True if the schema appears to be Zod 4 style\n */\nexport function isZod4Schema(schema: unknown): schema is $ZodType {\n  return zod4SchemaType.safeParse(schema).success;\n}\n\n/**\n * Checks if a schema is a Zod schema\n * @param schema - The schema to check\n * @returns True if the schema is a Zod schema\n */\nexport function isZodSchema(\n  schema: unknown,\n): ReturnType<typeof isZod3Schema> | ReturnType<typeof isZod4Schema> {\n  return isZod3Schema(schema) || isZod4Schema(schema);\n}\n"]}

package/dist/testing/tools.d.ts

@@ -1,25 +1,39 @@
-import { TamboComponent } from "../providers";
+import { TamboToolWithToolSchema } from "../model/component-metadata";
+import { TamboComponent, TamboTool } from "../providers";
 /**
- * Serializes the registry for testing purposes
+ * Serializes the registry for testing purposes.
+ * Converts Standard Schema validators to JSON Schema format.
+ * Uses the same logic as production code via mapTamboToolToContextTool.
  * @param mockRegistry - The registry to serialize
- * @returns The serialized registry
+ * @returns The serialized registry with JSON Schema representations
  */
 export declare function serializeRegistry(mockRegistry: TamboComponent[]): {
-    props: import("zod-to-json-schema").JsonSchema7Type & {
-        $schema?: string | undefined;
-        definitions?: {
-            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
-        } | undefined;
-    };
-    contextTools: {
-        parameters: any;
-        name: string;
-        description: string;
-        transformToContent?: ((result: any) => Promise<import("@tambo-ai/typescript-sdk/resources/beta").ChatCompletionContentPart[]> | import("@tambo-ai/typescript-sdk/resources/beta").ChatCompletionContentPart[]) | undefined;
-    }[] | undefined;
+    props: import("json-schema").JSONSchema7 | undefined;
+    contextTools: import("../model/component-metadata").ComponentContextToolMetadata[] | undefined;
     name: string;
     description: string;
     propsDefinition?: any;
     loadingComponent?: import("react").ComponentType<any>;
 }[];
+interface CreateMockToolOptions {
+    inputSchema: TamboTool["inputSchema"];
+    outputSchema?: TamboTool["outputSchema"];
+}
+/**
+ * Creates a mock TamboTool with the given input schema for testing purposes.
+ * Accepts either an inputSchema directly or an options object with inputSchema and outputSchema.
+ * @param schemaOrOptions - The input schema or options object
+ * @returns A mock TamboTool instance
+ * @internal
+ */
+export declare function createMockTool(schemaOrOptions: TamboTool["inputSchema"] | CreateMockToolOptions): TamboTool;
+/**
+ * Creates a mock TamboToolWithToolSchema for testing purposes.
+ * Does NOT adapt to inputSchema format - preserves the deprecated toolSchema interface.
+ * @param toolSchema - The tool schema for the tool
+ * @returns A mock TamboToolWithToolSchema instance (NOT adapted)
+ * @internal
+ */
+export declare function createMockToolWithToolSchema(toolSchema: TamboToolWithToolSchema["toolSchema"]): TamboToolWithToolSchema;
+export {};
 //# sourceMappingURL=tools.d.ts.map

package/dist/testing/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/testing/tools.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,cAAc,EAAE;;;;;;;;;;;;;;;;;IA0B/D"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/testing/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAOzD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,cAAc,EAAE;;;;;;;IAiB/D;AAED,UAAU,qBAAqB;IAC7B,WAAW,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IACtC,YAAY,CAAC,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;CAC1C;AAGD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,eAAe,EAAE,SAAS,CAAC,aAAa,CAAC,GAAG,qBAAqB,GAChE,SAAS,CAiCX;AAGD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,uBAAuB,CAAC,YAAY,CAAC,GAChD,uBAAuB,CAOzB"}

package/dist/testing/tools.js

@@ -1,31 +1,76 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeRegistry = serializeRegistry;
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+exports.createMockTool = createMockTool;
+exports.createMockToolWithToolSchema = createMockToolWithToolSchema;
+const schema_1 = require("../schema");
+const registry_1 = require("../util/registry");
 /**
- * Serializes the registry for testing purposes
+ * Serializes the registry for testing purposes.
+ * Converts Standard Schema validators to JSON Schema format.
+ * Uses the same logic as production code via mapTamboToolToContextTool.
  * @param mockRegistry - The registry to serialize
- * @returns The serialized registry
+ * @returns The serialized registry with JSON Schema representations
  */
 function serializeRegistry(mockRegistry) {
     return mockRegistry.map(({ component: _component, propsSchema, associatedTools, ...componentEntry }) => ({
         ...componentEntry,
-        props: (0, zod_to_json_schema_1.default)(propsSchema),
-        contextTools: associatedTools?.map(({ toolSchema, tool: _tool, ...toolEntry }) => ({
-            ...toolEntry,
-            parameters: toolSchema
-                .parameters()
-                .items.map((p, index) => ({
-                name: `param${index + 1}`,
-                schema: (0, zod_to_json_schema_1.default)(p),
-                isRequired: true,
-                description: p.description,
-                type: (0, zod_to_json_schema_1.default)(p).type,
-            })),
-        })),
+        props: (0, schema_1.isStandardSchema)(propsSchema)
+            ? (0, schema_1.safeSchemaToJsonSchema)(propsSchema)
+            : propsSchema,
+        contextTools: associatedTools?.map((tool) => (0, registry_1.mapTamboToolToContextTool)((0, registry_1.adaptToolFromFnSchema)(tool))),
     }));
 }
+// Helper to create a minimal TamboTool for testing
+/**
+ * Creates a mock TamboTool with the given input schema for testing purposes.
+ * Accepts either an inputSchema directly or an options object with inputSchema and outputSchema.
+ * @param schemaOrOptions - The input schema or options object
+ * @returns A mock TamboTool instance
+ * @internal
+ */
+function createMockTool(schemaOrOptions) {
+    // Check if options object was passed
+    const hasInputSchemaProperty = (obj) => {
+        return (typeof obj === "object" &&
+            obj !== null &&
+            "inputSchema" in obj &&
+            obj.inputSchema != null);
+    };
+    if (hasInputSchemaProperty(schemaOrOptions)) {
+        return {
+            name: "mockTool",
+            description: "A mock tool for testing",
+            tool: jest.fn().mockImplementation(() => { }),
+            inputSchema: schemaOrOptions.inputSchema,
+            outputSchema: schemaOrOptions.outputSchema ?? {
+                type: "object",
+                properties: {},
+            },
+        };
+    }
+    return {
+        name: "mockTool",
+        description: "A mock tool for testing",
+        tool: jest.fn().mockImplementation(() => { }),
+        inputSchema: schemaOrOptions,
+        outputSchema: { type: "object", properties: {} },
+    };
+}
+// Helper to create a minimal TamboTool for testing -- uses toolSchema field as function instead of inputSchema
+/**
+ * Creates a mock TamboToolWithToolSchema for testing purposes.
+ * Does NOT adapt to inputSchema format - preserves the deprecated toolSchema interface.
+ * @param toolSchema - The tool schema for the tool
+ * @returns A mock TamboToolWithToolSchema instance (NOT adapted)
+ * @internal
+ */
+function createMockToolWithToolSchema(toolSchema) {
+    return {
+        name: "testTool",
+        description: "A test tool",
+        tool: jest.fn().mockImplementation(() => { }),
+        toolSchema,
+    };
+}
 //# sourceMappingURL=tools.js.map

package/dist/testing/tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/testing/tools.ts"],"names":[],"mappings":";;;;;AASA,8CA0BC;AAlCD,4EAAiD;AAGjD;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,YAA8B;IAC9D,OAAO,YAAY,CAAC,GAAG,CACrB,CAAC,EACC,SAAS,EAAE,UAAU,EACrB,WAAW,EACX,eAAe,EACf,GAAG,cAAc,EAClB,EAAE,EAAE,CAAC,CAAC;QACL,GAAG,cAAc;QACjB,KAAK,EAAE,IAAA,4BAAe,EAAC,WAA2B,CAAC;QACnD,YAAY,EAAE,eAAe,EAAE,GAAG,CAChC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;YAC9C,GAAG,SAAS;YACZ,UAAU,EAAG,UAAsC;iBAChD,UAAU,EAAE;iBACZ,KAAK,CAAC,GAAG,CAAC,CAAC,CAAe,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC;gBAC9C,IAAI,EAAE,QAAQ,KAAK,GAAG,CAAC,EAAE;gBACzB,MAAM,EAAE,IAAA,4BAAe,EAAC,CAAC,CAAC;gBAC1B,UAAU,EAAE,IAAI;gBAChB,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,IAAI,EAAG,IAAA,4BAAe,EAAC,CAAC,CAAS,CAAC,IAAI;aACvC,CAAC,CAAC;SACN,CAAC,CACH;KACF,CAAC,CACH,CAAC;AACJ,CAAC","sourcesContent":["import { z } from \"zod\";\nimport zodToJsonSchema from \"zod-to-json-schema\";\nimport { TamboComponent } from \"../providers\";\n\n/**\n * Serializes the registry for testing purposes\n * @param mockRegistry - The registry to serialize\n * @returns The serialized registry\n */\nexport function serializeRegistry(mockRegistry: TamboComponent[]) {\n  return mockRegistry.map(\n    ({\n      component: _component,\n      propsSchema,\n      associatedTools,\n      ...componentEntry\n    }) => ({\n      ...componentEntry,\n      props: zodToJsonSchema(propsSchema as z.ZodTypeAny),\n      contextTools: associatedTools?.map(\n        ({ toolSchema, tool: _tool, ...toolEntry }) => ({\n          ...toolEntry,\n          parameters: (toolSchema as z.ZodFunction<any, any>)\n            .parameters()\n            .items.map((p: z.ZodTypeAny, index: number) => ({\n              name: `param${index + 1}`,\n              schema: zodToJsonSchema(p),\n              isRequired: true,\n              description: p.description,\n              type: (zodToJsonSchema(p) as any).type,\n            })),\n        }),\n      ),\n    }),\n  );\n}\n"]}
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/testing/tools.ts"],"names":[],"mappings":";;AAeA,8CAiBC;AAeD,wCAmCC;AAUD,oEASC;AAnGD,sCAAqE;AACrE,+CAG0B;AAE1B;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,YAA8B;IAC9D,OAAO,YAAY,CAAC,GAAG,CACrB,CAAC,EACC,SAAS,EAAE,UAAU,EACrB,WAAW,EACX,eAAe,EACf,GAAG,cAAc,EAClB,EAAE,EAAE,CAAC,CAAC;QACL,GAAG,cAAc;QACjB,KAAK,EAAE,IAAA,yBAAgB,EAAC,WAAW,CAAC;YAClC,CAAC,CAAC,IAAA,+BAAsB,EAAC,WAAW,CAAC;YACrC,CAAC,CAAC,WAAW;QACf,YAAY,EAAE,eAAe,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAC1C,IAAA,oCAAyB,EAAC,IAAA,gCAAqB,EAAC,IAAI,CAAC,CAAC,CACvD;KACF,CAAC,CACH,CAAC;AACJ,CAAC;AAOD,mDAAmD;AACnD;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,eAAiE;IAEjE,qCAAqC;IACrC,MAAM,sBAAsB,GAAG,CAC7B,GAAY,EACkB,EAAE;QAChC,OAAO,CACL,OAAO,GAAG,KAAK,QAAQ;YACvB,GAAG,KAAK,IAAI;YACZ,aAAa,IAAI,GAAG;YACpB,GAAG,CAAC,WAAW,IAAI,IAAI,CACxB,CAAC;IACJ,CAAC,CAAC;IAEF,IAAI,sBAAsB,CAAC,eAAe,CAAC,EAAE,CAAC;QAC5C,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,yBAAyB;YACtC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;YAC5C,WAAW,EAAE,eAAe,CAAC,WAAW;YACxC,YAAY,EAAE,eAAe,CAAC,YAAY,IAAI;gBAC5C,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE,EAAE;aACf;SACF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,yBAAyB;QACtC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;QAC5C,WAAW,EAAE,eAAe;QAC5B,YAAY,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE;KACjD,CAAC;AACJ,CAAC;AAED,+GAA+G;AAC/G;;;;;;GAMG;AACH,SAAgB,4BAA4B,CAC1C,UAAiD;IAEjD,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,aAAa;QAC1B,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;QAC5C,UAAU;KACX,CAAC;AACJ,CAAC","sourcesContent":["import { TamboToolWithToolSchema } from \"../model/component-metadata\";\nimport { TamboComponent, TamboTool } from \"../providers\";\nimport { isStandardSchema, safeSchemaToJsonSchema } from \"../schema\";\nimport {\n  adaptToolFromFnSchema,\n  mapTamboToolToContextTool,\n} from \"../util/registry\";\n\n/**\n * Serializes the registry for testing purposes.\n * Converts Standard Schema validators to JSON Schema format.\n * Uses the same logic as production code via mapTamboToolToContextTool.\n * @param mockRegistry - The registry to serialize\n * @returns The serialized registry with JSON Schema representations\n */\nexport function serializeRegistry(mockRegistry: TamboComponent[]) {\n  return mockRegistry.map(\n    ({\n      component: _component,\n      propsSchema,\n      associatedTools,\n      ...componentEntry\n    }) => ({\n      ...componentEntry,\n      props: isStandardSchema(propsSchema)\n        ? safeSchemaToJsonSchema(propsSchema)\n        : propsSchema,\n      contextTools: associatedTools?.map((tool) =>\n        mapTamboToolToContextTool(adaptToolFromFnSchema(tool)),\n      ),\n    }),\n  );\n}\n\ninterface CreateMockToolOptions {\n  inputSchema: TamboTool[\"inputSchema\"];\n  outputSchema?: TamboTool[\"outputSchema\"];\n}\n\n// Helper to create a minimal TamboTool for testing\n/**\n * Creates a mock TamboTool with the given input schema for testing purposes.\n * Accepts either an inputSchema directly or an options object with inputSchema and outputSchema.\n * @param schemaOrOptions - The input schema or options object\n * @returns A mock TamboTool instance\n * @internal\n */\nexport function createMockTool(\n  schemaOrOptions: TamboTool[\"inputSchema\"] | CreateMockToolOptions,\n): TamboTool {\n  // Check if options object was passed\n  const hasInputSchemaProperty = (\n    obj: unknown,\n  ): obj is CreateMockToolOptions => {\n    return (\n      typeof obj === \"object\" &&\n      obj !== null &&\n      \"inputSchema\" in obj &&\n      obj.inputSchema != null\n    );\n  };\n\n  if (hasInputSchemaProperty(schemaOrOptions)) {\n    return {\n      name: \"mockTool\",\n      description: \"A mock tool for testing\",\n      tool: jest.fn().mockImplementation(() => {}),\n      inputSchema: schemaOrOptions.inputSchema,\n      outputSchema: schemaOrOptions.outputSchema ?? {\n        type: \"object\",\n        properties: {},\n      },\n    };\n  }\n\n  return {\n    name: \"mockTool\",\n    description: \"A mock tool for testing\",\n    tool: jest.fn().mockImplementation(() => {}),\n    inputSchema: schemaOrOptions,\n    outputSchema: { type: \"object\", properties: {} },\n  };\n}\n\n// Helper to create a minimal TamboTool for testing -- uses toolSchema field as function instead of inputSchema\n/**\n * Creates a mock TamboToolWithToolSchema for testing purposes.\n * Does NOT adapt to inputSchema format - preserves the deprecated toolSchema interface.\n * @param toolSchema - The tool schema for the tool\n * @returns A mock TamboToolWithToolSchema instance (NOT adapted)\n * @internal\n */\nexport function createMockToolWithToolSchema(\n  toolSchema: TamboToolWithToolSchema[\"toolSchema\"],\n): TamboToolWithToolSchema {\n  return {\n    name: \"testTool\",\n    description: \"A test tool\",\n    tool: jest.fn().mockImplementation(() => {}),\n    toolSchema,\n  };\n}\n"]}

package/dist/util/content-parts.test.d.ts.map

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

package/dist/util/{__tests__/content-parts.test.js → content-parts.test.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const content_parts_1 = require("../content-parts");
+const content_parts_1 = require("./content-parts");
 describe("content-parts type guards", () => {
     it("returns true for a valid text content part array", () => {
         const parts = [{ type: "text", text: "hello" }];

package/dist/util/content-parts.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-parts.test.js","sourceRoot":"","sources":["../../src/util/content-parts.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { isContentPartArray, isContentPart, toText } from \"./content-parts\";\n\ndescribe(\"content-parts type guards\", () => {\n  it(\"returns true for a valid text content part array\", () => {\n    const parts = [{ type: \"text\", text: \"hello\" }];\n    expect(isContentPartArray(parts)).toBe(true);\n  });\n\n  it(\"returns true for a valid image_url content part array\", () => {\n    const parts = [\n      { type: \"image_url\", image_url: { url: \"data:image/png;base64,abc\" } },\n    ];\n    expect(isContentPartArray(parts)).toBe(true);\n  });\n\n  it(\"returns false for non-object array elements\", () => {\n    const parts = [\"text\", 123, null];\n    expect(isContentPartArray(parts as any)).toBe(false);\n  });\n\n  it(\"returns false when elements are objects without string type\", () => {\n    const parts = [{}, { type: 42 }, { type: undefined }];\n    expect(isContentPartArray(parts as any)).toBe(false);\n  });\n\n  it(\"isContentPart narrows a single part\", () => {\n    const val: unknown = { type: \"text\", text: \"hi\" };\n    if (!isContentPart(val)) {\n      throw new Error(\"should be content part\");\n    }\n    // runtime spot-check\n    expect(val.type).toBe(\"text\");\n  });\n\n  it(\"returns false for non-array inputs\", () => {\n    expect(isContentPartArray({})).toBe(false);\n    expect(isContentPartArray(null)).toBe(false);\n    expect(isContentPartArray(undefined)).toBe(false);\n    expect(isContentPartArray(\"foo\")).toBe(false);\n  });\n\n  it(\"toText safely stringifies values and never throws\", () => {\n    expect(toText(\"hello\")).toBe(\"hello\");\n    expect(toText(42)).toBe(\"42\");\n    const circular: any = { a: 1 };\n    circular.self = circular;\n    // Should not throw for circular structures\n    expect(() => toText(circular)).not.toThrow();\n    expect(typeof toText(undefined)).toBe(\"string\");\n  });\n});\n"]}

package/dist/util/generate-component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-component.d.ts","sourceRoot":"","sources":["../../src/util/generate-component.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,0BAA0B,CAAC;AAK/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAG1E;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAC3C,aAAa,EAAE,iBAAiB,GAC/B,kBAAkB,CAsCpB"}
+{"version":3,"file":"generate-component.d.ts","sourceRoot":"","sources":["../../src/util/generate-component.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,0BAA0B,CAAC;AAI/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAI1E;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAC3C,aAAa,EAAE,iBAAiB,GAC/B,kBAAkB,CAqCpB"}

package/dist/util/generate-component.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderComponentIntoMessage = renderComponentIntoMessage;
 const partial_json_1 = require("partial-json");
 const react_1 = __importDefault(require("react"));
-const zod_1 = require("zod");
 const use_current_message_1 = require("../hooks/use-current-message");
+const schema_1 = require("../schema");
 const registry_1 = require("../util/registry");
 /**
  * Generate a message that has a component rendered into it, if the message
@@ -22,8 +22,8 @@ function renderComponentIntoMessage(message, componentList) {
     }
     const parsedProps = (0, partial_json_1.parse)(JSON.stringify(message.component.props));
     const registeredComponent = (0, registry_1.getComponentFromRegistry)(message.component.componentName, componentList);
-    const validatedProps = registeredComponent.props instanceof zod_1.z.ZodType
-        ? registeredComponent.props.parse(parsedProps)
+    const validatedProps = (0, schema_1.isStandardSchema)(registeredComponent.props)
+        ? registeredComponent.props["~standard"].validate(parsedProps)
         : parsedProps;
     const renderedComponent = react_1.default.createElement(registeredComponent.component, validatedProps);
     // Create the full message object first so we can pass it to the provider

package/dist/util/generate-component.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate-component.js","sourceRoot":"","sources":["../../src/util/generate-component.ts"],"names":[],"mappings":";;;;;AAgBA,gEAyCC;AAxDD,+CAAqC;AACrC,kDAA0B;AAC1B,6BAAwB;AACxB,sEAA4E;AAG5E,+CAA4D;AAE5D;;;;;;GAMG;AACH,SAAgB,0BAA0B,CACxC,OAA2C,EAC3C,aAAgC;IAEhC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IACD,MAAM,WAAW,GAAG,IAAA,oBAAK,EAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACnE,MAAM,mBAAmB,GAAG,IAAA,mCAAwB,EAClD,OAAO,CAAC,SAAS,CAAC,aAAa,EAC/B,aAAa,CACd,CAAC;IAEF,MAAM,cAAc,GAClB,mBAAmB,CAAC,KAAK,YAAY,OAAC,CAAC,OAAO;QAC5C,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;QAC9C,CAAC,CAAC,WAAW,CAAC;IAElB,MAAM,iBAAiB,GAAG,eAAK,CAAC,aAAa,CAC3C,mBAAmB,CAAC,SAAS,EAC7B,cAAc,CACf,CAAC;IAEF,yEAAyE;IACzE,MAAM,WAAW,GAAuB;QACtC,GAAG,OAAO;QACV,SAAS,EAAE;YACT,GAAG,OAAO,CAAC,SAAS;YACpB,KAAK,EAAE,cAAc;SACtB;KACF,CAAC;IAEF,MAAM,gBAAgB,GAAG,IAAA,kDAA4B,EACnD,iBAAiB,EACjB,WAAW,CACZ,CAAC;IAEF,OAAO;QACL,GAAG,WAAW;QACd,iBAAiB,EAAE,gBAAgB;KACpC,CAAC;AACJ,CAAC","sourcesContent":["import TamboAI from \"@tambo-ai/typescript-sdk\";\nimport { parse } from \"partial-json\";\nimport React from \"react\";\nimport { z } from \"zod\";\nimport { wrapWithTamboMessageProvider } from \"../hooks/use-current-message\";\nimport { ComponentRegistry } from \"../model/component-metadata\";\nimport { TamboThreadMessage } from \"../model/generate-component-response\";\nimport { getComponentFromRegistry } from \"../util/registry\";\n\n/**\n * Generate a message that has a component rendered into it, if the message\n * came with one.\n * @param message - The message that may contain a component\n * @param componentList - the list of available components\n * @returns The updated message with the component rendered into it\n */\nexport function renderComponentIntoMessage(\n  message: TamboAI.Beta.Threads.ThreadMessage,\n  componentList: ComponentRegistry,\n): TamboThreadMessage {\n  if (!message.component?.componentName) {\n    throw new Error(\"Component not found\");\n  }\n  const parsedProps = parse(JSON.stringify(message.component.props));\n  const registeredComponent = getComponentFromRegistry(\n    message.component.componentName,\n    componentList,\n  );\n\n  const validatedProps =\n    registeredComponent.props instanceof z.ZodType\n      ? registeredComponent.props.parse(parsedProps)\n      : parsedProps;\n\n  const renderedComponent = React.createElement(\n    registeredComponent.component,\n    validatedProps,\n  );\n\n  // Create the full message object first so we can pass it to the provider\n  const fullMessage: TamboThreadMessage = {\n    ...message,\n    component: {\n      ...message.component,\n      props: validatedProps,\n    },\n  };\n\n  const wrappedComponent = wrapWithTamboMessageProvider(\n    renderedComponent,\n    fullMessage,\n  );\n\n  return {\n    ...fullMessage,\n    renderedComponent: wrappedComponent,\n  };\n}\n"]}
+{"version":3,"file":"generate-component.js","sourceRoot":"","sources":["../../src/util/generate-component.ts"],"names":[],"mappings":";;;;;AAgBA,gEAwCC;AAvDD,+CAAqC;AACrC,kDAA0B;AAC1B,sEAA4E;AAG5E,sCAA6C;AAC7C,+CAA4D;AAE5D;;;;;;GAMG;AACH,SAAgB,0BAA0B,CACxC,OAA2C,EAC3C,aAAgC;IAEhC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACzC,CAAC;IACD,MAAM,WAAW,GAAG,IAAA,oBAAK,EAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACnE,MAAM,mBAAmB,GAAG,IAAA,mCAAwB,EAClD,OAAO,CAAC,SAAS,CAAC,aAAa,EAC/B,aAAa,CACd,CAAC;IAEF,MAAM,cAAc,GAAG,IAAA,yBAAgB,EAAC,mBAAmB,CAAC,KAAK,CAAC;QAChE,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;QAC9D,CAAC,CAAC,WAAW,CAAC;IAEhB,MAAM,iBAAiB,GAAG,eAAK,CAAC,aAAa,CAC3C,mBAAmB,CAAC,SAAS,EAC7B,cAAc,CACf,CAAC;IAEF,yEAAyE;IACzE,MAAM,WAAW,GAAuB;QACtC,GAAG,OAAO;QACV,SAAS,EAAE;YACT,GAAG,OAAO,CAAC,SAAS;YACpB,KAAK,EAAE,cAAc;SACtB;KACF,CAAC;IAEF,MAAM,gBAAgB,GAAG,IAAA,kDAA4B,EACnD,iBAAiB,EACjB,WAAW,CACZ,CAAC;IAEF,OAAO;QACL,GAAG,WAAW;QACd,iBAAiB,EAAE,gBAAgB;KACpC,CAAC;AACJ,CAAC","sourcesContent":["import TamboAI from \"@tambo-ai/typescript-sdk\";\nimport { parse } from \"partial-json\";\nimport React from \"react\";\nimport { wrapWithTamboMessageProvider } from \"../hooks/use-current-message\";\nimport { ComponentRegistry } from \"../model/component-metadata\";\nimport { TamboThreadMessage } from \"../model/generate-component-response\";\nimport { isStandardSchema } from \"../schema\";\nimport { getComponentFromRegistry } from \"../util/registry\";\n\n/**\n * Generate a message that has a component rendered into it, if the message\n * came with one.\n * @param message - The message that may contain a component\n * @param componentList - the list of available components\n * @returns The updated message with the component rendered into it\n */\nexport function renderComponentIntoMessage(\n  message: TamboAI.Beta.Threads.ThreadMessage,\n  componentList: ComponentRegistry,\n): TamboThreadMessage {\n  if (!message.component?.componentName) {\n    throw new Error(\"Component not found\");\n  }\n  const parsedProps = parse(JSON.stringify(message.component.props));\n  const registeredComponent = getComponentFromRegistry(\n    message.component.componentName,\n    componentList,\n  );\n\n  const validatedProps = isStandardSchema(registeredComponent.props)\n    ? registeredComponent.props[\"~standard\"].validate(parsedProps)\n    : parsedProps;\n\n  const renderedComponent = React.createElement(\n    registeredComponent.component,\n    validatedProps,\n  );\n\n  // Create the full message object first so we can pass it to the provider\n  const fullMessage: TamboThreadMessage = {\n    ...message,\n    component: {\n      ...message.component,\n      props: validatedProps,\n    },\n  };\n\n  const wrappedComponent = wrapWithTamboMessageProvider(\n    renderedComponent,\n    fullMessage,\n  );\n\n  return {\n    ...fullMessage,\n    renderedComponent: wrappedComponent,\n  };\n}\n"]}