@tambo-ai/react 0.65.3 → 0.66.0

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

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

package/dist/schema/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZodFunctionReturns = exports.getZodFunctionArgs = exports.assertNoRecordSchema = exports.isStandardSchema = exports.schemaToJsonSchema = exports.safeSchemaToJsonSchema = exports.hasInputSchema = exports.getParametersFromToolSchema = exports.looksLikeJSONSchema = void 0;
+var json_schema_1 = require("./json-schema");
+Object.defineProperty(exports, "looksLikeJSONSchema", { enumerable: true, get: function () { return json_schema_1.looksLikeJSONSchema; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "getParametersFromToolSchema", { enumerable: true, get: function () { return schema_1.getParametersFromToolSchema; } });
+Object.defineProperty(exports, "hasInputSchema", { enumerable: true, get: function () { return schema_1.hasInputSchema; } });
+Object.defineProperty(exports, "safeSchemaToJsonSchema", { enumerable: true, get: function () { return schema_1.safeSchemaToJsonSchema; } });
+Object.defineProperty(exports, "schemaToJsonSchema", { enumerable: true, get: function () { return schema_1.schemaToJsonSchema; } });
+var standard_schema_1 = require("./standard-schema");
+Object.defineProperty(exports, "isStandardSchema", { enumerable: true, get: function () { return standard_schema_1.isStandardSchema; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "assertNoRecordSchema", { enumerable: true, get: function () { return validate_1.assertNoRecordSchema; } });
+var zod_1 = require("./zod");
+Object.defineProperty(exports, "getZodFunctionArgs", { enumerable: true, get: function () { return zod_1.getZodFunctionArgs; } });
+Object.defineProperty(exports, "getZodFunctionReturns", { enumerable: true, get: function () { return zod_1.getZodFunctionReturns; } });
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;AAAA,6CAAoD;AAA3C,kHAAA,mBAAmB,OAAA;AAC5B,mCAMkB;AALhB,qHAAA,2BAA2B,OAAA;AAC3B,wGAAA,cAAc,OAAA;AACd,gHAAA,sBAAsB,OAAA;AACtB,4GAAA,kBAAkB,OAAA;AAGpB,qDAAqD;AAA5C,mHAAA,gBAAgB,OAAA;AACzB,uCAAkD;AAAzC,gHAAA,oBAAoB,OAAA;AAC7B,6BAAkE;AAAzD,yGAAA,kBAAkB,OAAA;AAAE,4GAAA,qBAAqB,OAAA","sourcesContent":["export { looksLikeJSONSchema } from \"./json-schema\";\nexport {\n  getParametersFromToolSchema,\n  hasInputSchema,\n  safeSchemaToJsonSchema,\n  schemaToJsonSchema,\n  type SupportedSchema,\n} from \"./schema\";\nexport { isStandardSchema } from \"./standard-schema\";\nexport { assertNoRecordSchema } from \"./validate\";\nexport { getZodFunctionArgs, getZodFunctionReturns } from \"./zod\";\n"]}

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

@@ -0,0 +1,35 @@
+import { JSONSchema7 } from "json-schema";
+/**
+ * Basic heuristic to check if an object looks like a JSON Schema at the top level.
+ *
+ * This uses a Zod schema to verify only top-level keys (type, properties, items,
+ * etc.). It intentionally does not perform full JSON Schema validation; a more
+ * thorough check should be done server-side.
+ * @param obj - The value to check
+ * @returns True if the value appears to be a JSON Schema
+ */
+export declare function looksLikeJSONSchema(obj: unknown): obj is JSONSchema7;
+/**
+ * Extended JSON Schema type that includes draft 2020-12 features like prefixItems.
+ * The json-schema package types are from draft-07 and don't include prefixItems.
+ */
+export type JSONSchema7Extended = JSONSchema7 & {
+    prefixItems?: JSONSchema7[];
+};
+/**
+ * Checks if a JSON Schema represents a tuple (array with positional items).
+ * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).
+ * @param schema - The JSON Schema to check
+ * @returns True if the schema represents a tuple
+ */
+export declare function isJsonSchemaTuple(schema: JSONSchema7Extended): schema is JSONSchema7Extended & {
+    type: "array";
+};
+/**
+ * Gets the tuple items from a JSON Schema.
+ * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).
+ * @param schema - The JSON Schema tuple
+ * @returns Array of item schemas, or undefined if not a tuple
+ */
+export declare function getJsonSchemaTupleItems(schema: JSONSchema7Extended): JSONSchema7[] | undefined;
+//# sourceMappingURL=json-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../src/schema/json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAkD1C;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,WAAW,CAMpE;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG;IAC9C,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,mBAAmB,GAC1B,MAAM,IAAI,mBAAmB,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAgBnD;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,GAC1B,WAAW,EAAE,GAAG,SAAS,CAgB3B"}

package/dist/schema/json-schema.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeJSONSchema = looksLikeJSONSchema;
+exports.isJsonSchemaTuple = isJsonSchemaTuple;
+exports.getJsonSchemaTupleItems = getJsonSchemaTupleItems;
+const zodInternalAlias_1 = require("zodInternalAlias");
+const jsonSchemaType = zodInternalAlias_1.z.union([
+    zodInternalAlias_1.z.literal("object"),
+    zodInternalAlias_1.z.literal("array"),
+    zodInternalAlias_1.z.literal("string"),
+    zodInternalAlias_1.z.literal("number"),
+    zodInternalAlias_1.z.literal("integer"),
+    zodInternalAlias_1.z.literal("boolean"),
+    zodInternalAlias_1.z.literal("null"),
+    zodInternalAlias_1.z.array(zodInternalAlias_1.z.union([
+        zodInternalAlias_1.z.literal("object"),
+        zodInternalAlias_1.z.literal("array"),
+        zodInternalAlias_1.z.literal("string"),
+        zodInternalAlias_1.z.literal("number"),
+        zodInternalAlias_1.z.literal("integer"),
+        zodInternalAlias_1.z.literal("boolean"),
+        zodInternalAlias_1.z.literal("null"),
+    ])),
+]);
+const jsonSchemaTopLevel = zodInternalAlias_1.z
+    .looseObject({
+    type: jsonSchemaType.optional(),
+    properties: zodInternalAlias_1.z.record(zodInternalAlias_1.z.string(), zodInternalAlias_1.z.unknown()).optional(),
+    items: zodInternalAlias_1.z.union([zodInternalAlias_1.z.array(zodInternalAlias_1.z.unknown()), zodInternalAlias_1.z.unknown()]).optional(),
+    required: zodInternalAlias_1.z.array(zodInternalAlias_1.z.string()).optional(),
+    additionalProperties: zodInternalAlias_1.z.union([zodInternalAlias_1.z.boolean(), zodInternalAlias_1.z.unknown()]).optional(),
+    enum: zodInternalAlias_1.z.array(zodInternalAlias_1.z.unknown()).optional(),
+    const: zodInternalAlias_1.z.unknown().optional(),
+    $ref: zodInternalAlias_1.z.string().optional(),
+    $id: zodInternalAlias_1.z.string().optional(),
+    $schema: zodInternalAlias_1.z.string().optional(),
+    title: zodInternalAlias_1.z.string().optional(),
+    description: zodInternalAlias_1.z.string().optional(),
+})
+    .refine((value) => {
+    return (value.type !== undefined ||
+        value.properties !== undefined ||
+        value.items !== undefined ||
+        value.enum !== undefined ||
+        value.const !== undefined ||
+        value.$ref !== undefined);
+});
+/**
+ * Basic heuristic to check if an object looks like a JSON Schema at the top level.
+ *
+ * This uses a Zod schema to verify only top-level keys (type, properties, items,
+ * etc.). It intentionally does not perform full JSON Schema validation; a more
+ * thorough check should be done server-side.
+ * @param obj - The value to check
+ * @returns True if the value appears to be a JSON Schema
+ */
+function looksLikeJSONSchema(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return false;
+    }
+    return jsonSchemaTopLevel.safeParse(obj).success;
+}
+/**
+ * Checks if a JSON Schema represents a tuple (array with positional items).
+ * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).
+ * @param schema - The JSON Schema to check
+ * @returns True if the schema represents a tuple
+ */
+function isJsonSchemaTuple(schema) {
+    if (schema.type !== "array") {
+        return false;
+    }
+    // Draft 2020-12: prefixItems array
+    if (schema.prefixItems && Array.isArray(schema.prefixItems)) {
+        return true;
+    }
+    // Draft-07: items as array (not object)
+    if (Array.isArray(schema.items)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Gets the tuple items from a JSON Schema.
+ * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).
+ * @param schema - The JSON Schema tuple
+ * @returns Array of item schemas, or undefined if not a tuple
+ */
+function getJsonSchemaTupleItems(schema) {
+    if (schema.type !== "array") {
+        return undefined;
+    }
+    // Draft 2020-12: prefixItems array
+    if (schema.prefixItems && Array.isArray(schema.prefixItems)) {
+        return schema.prefixItems;
+    }
+    // Draft-07: items as array
+    if (Array.isArray(schema.items)) {
+        return schema.items;
+    }
+    return undefined;
+}
+//# sourceMappingURL=json-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","sourceRoot":"","sources":["../../src/schema/json-schema.ts"],"names":[],"mappings":";;AA2DA,kDAMC;AAgBD,8CAkBC;AAQD,0DAkBC;AA5HD,uDAAqC;AAErC,MAAM,cAAc,GAAG,oBAAC,CAAC,KAAK,CAAC;IAC7B,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACnB,oBAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IAClB,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACnB,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACnB,oBAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,oBAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,oBAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACjB,oBAAC,CAAC,KAAK,CACL,oBAAC,CAAC,KAAK,CAAC;QACN,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACnB,oBAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QAClB,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACnB,oBAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACnB,oBAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QACpB,oBAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QACpB,oBAAC,CAAC,OAAO,CAAC,MAAM,CAAC;KAClB,CAAC,CACH;CACF,CAAC,CAAC;AAEH,MAAM,kBAAkB,GAAG,oBAAC;KACzB,WAAW,CAAC;IACX,IAAI,EAAE,cAAc,CAAC,QAAQ,EAAE;IAC/B,UAAU,EAAE,oBAAC,CAAC,MAAM,CAAC,oBAAC,CAAC,MAAM,EAAE,EAAE,oBAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxD,KAAK,EAAE,oBAAC,CAAC,KAAK,CAAC,CAAC,oBAAC,CAAC,KAAK,CAAC,oBAAC,CAAC,OAAO,EAAE,CAAC,EAAE,oBAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC9D,QAAQ,EAAE,oBAAC,CAAC,KAAK,CAAC,oBAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxC,oBAAoB,EAAE,oBAAC,CAAC,KAAK,CAAC,CAAC,oBAAC,CAAC,OAAO,EAAE,EAAE,oBAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpE,IAAI,EAAE,oBAAC,CAAC,KAAK,CAAC,oBAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACrC,KAAK,EAAE,oBAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC7B,IAAI,EAAE,oBAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,GAAG,EAAE,oBAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC1B,OAAO,EAAE,oBAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,KAAK,EAAE,oBAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,WAAW,EAAE,oBAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACnC,CAAC;KACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;IAChB,OAAO,CACL,KAAK,CAAC,IAAI,KAAK,SAAS;QACxB,KAAK,CAAC,UAAU,KAAK,SAAS;QAC9B,KAAK,CAAC,KAAK,KAAK,SAAS;QACzB,KAAK,CAAC,IAAI,KAAK,SAAS;QACxB,KAAK,CAAC,KAAK,KAAK,SAAS;QACzB,KAAK,CAAC,IAAI,KAAK,SAAS,CACzB,CAAC;AACJ,CAAC,CAAC,CAAC;AAEL;;;;;;;;GAQG;AACH,SAAgB,mBAAmB,CAAC,GAAY;IAC9C,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;AACnD,CAAC;AAUD;;;;;GAKG;AACH,SAAgB,iBAAiB,CAC/B,MAA2B;IAE3B,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,mCAAmC;IACnC,IAAI,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,wCAAwC;IACxC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAgB,uBAAuB,CACrC,MAA2B;IAE3B,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,mCAAmC;IACnC,IAAI,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAC5D,OAAO,MAAM,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,2BAA2B;IAC3B,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,MAAM,CAAC,KAAsB,CAAC;IACvC,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import { JSONSchema7 } from \"json-schema\";\nimport { z } from \"zodInternalAlias\";\n\nconst jsonSchemaType = z.union([\n  z.literal(\"object\"),\n  z.literal(\"array\"),\n  z.literal(\"string\"),\n  z.literal(\"number\"),\n  z.literal(\"integer\"),\n  z.literal(\"boolean\"),\n  z.literal(\"null\"),\n  z.array(\n    z.union([\n      z.literal(\"object\"),\n      z.literal(\"array\"),\n      z.literal(\"string\"),\n      z.literal(\"number\"),\n      z.literal(\"integer\"),\n      z.literal(\"boolean\"),\n      z.literal(\"null\"),\n    ]),\n  ),\n]);\n\nconst jsonSchemaTopLevel = z\n  .looseObject({\n    type: jsonSchemaType.optional(),\n    properties: z.record(z.string(), z.unknown()).optional(),\n    items: z.union([z.array(z.unknown()), z.unknown()]).optional(),\n    required: z.array(z.string()).optional(),\n    additionalProperties: z.union([z.boolean(), z.unknown()]).optional(),\n    enum: z.array(z.unknown()).optional(),\n    const: z.unknown().optional(),\n    $ref: z.string().optional(),\n    $id: z.string().optional(),\n    $schema: z.string().optional(),\n    title: z.string().optional(),\n    description: z.string().optional(),\n  })\n  .refine((value) => {\n    return (\n      value.type !== undefined ||\n      value.properties !== undefined ||\n      value.items !== undefined ||\n      value.enum !== undefined ||\n      value.const !== undefined ||\n      value.$ref !== undefined\n    );\n  });\n\n/**\n * Basic heuristic to check if an object looks like a JSON Schema at the top level.\n *\n * This uses a Zod schema to verify only top-level keys (type, properties, items,\n * etc.). It intentionally does not perform full JSON Schema validation; a more\n * thorough check should be done server-side.\n * @param obj - The value to check\n * @returns True if the value appears to be a JSON Schema\n */\nexport function looksLikeJSONSchema(obj: unknown): obj is JSONSchema7 {\n  if (obj === null || typeof obj !== \"object\") {\n    return false;\n  }\n\n  return jsonSchemaTopLevel.safeParse(obj).success;\n}\n\n/**\n * Extended JSON Schema type that includes draft 2020-12 features like prefixItems.\n * The json-schema package types are from draft-07 and don't include prefixItems.\n */\nexport type JSONSchema7Extended = JSONSchema7 & {\n  prefixItems?: JSONSchema7[];\n};\n\n/**\n * Checks if a JSON Schema represents a tuple (array with positional items).\n * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).\n * @param schema - The JSON Schema to check\n * @returns True if the schema represents a tuple\n */\nexport function isJsonSchemaTuple(\n  schema: JSONSchema7Extended,\n): schema is JSONSchema7Extended & { type: \"array\" } {\n  if (schema.type !== \"array\") {\n    return false;\n  }\n\n  // Draft 2020-12: prefixItems array\n  if (schema.prefixItems && Array.isArray(schema.prefixItems)) {\n    return true;\n  }\n\n  // Draft-07: items as array (not object)\n  if (Array.isArray(schema.items)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Gets the tuple items from a JSON Schema.\n * Supports both draft-07 (items as array) and draft 2020-12 (prefixItems).\n * @param schema - The JSON Schema tuple\n * @returns Array of item schemas, or undefined if not a tuple\n */\nexport function getJsonSchemaTupleItems(\n  schema: JSONSchema7Extended,\n): JSONSchema7[] | undefined {\n  if (schema.type !== \"array\") {\n    return undefined;\n  }\n\n  // Draft 2020-12: prefixItems array\n  if (schema.prefixItems && Array.isArray(schema.prefixItems)) {\n    return schema.prefixItems;\n  }\n\n  // Draft-07: items as array\n  if (Array.isArray(schema.items)) {\n    return schema.items as JSONSchema7[];\n  }\n\n  return undefined;\n}\n"]}

package/dist/schema/schema.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+import type { JSONSchema7 } from "json-schema";
+import { ParameterSpec, SupportedSchema, TamboTool, TamboToolWithToolSchema } from "../model/component-metadata";
+/**
+ * Converts a schema (Standard Schema or JSON Schema) to a JSON Schema object.
+ *
+ * If the schema is already a JSON Schema, it is returned as-is.
+ * For Standard Schema validators (Zod, Valibot, ArkType, etc.), uses
+ * `@standard-community/standard-json` for conversion.
+ * @param schema - The schema to convert
+ * @returns The JSON Schema representation
+ * @example
+ * ```typescript
+ * import { z } from "zod/v4";
+ *
+ * // Convert a Zod schema
+ * const zodSchema = z.object({ name: z.string() });
+ * const jsonSchema = schemaToJsonSchema(zodSchema);
+ *
+ * // Pass through a JSON Schema
+ * const existingJsonSchema = { type: "object", properties: { name: { type: "string" } } };
+ * schemaToJsonSchema(existingJsonSchema); // returns the same object
+ * ```
+ */
+export declare function schemaToJsonSchema(schema: SupportedSchema): JSONSchema7;
+/**
+ * Safely converts a schema to JSON Schema, returning undefined for invalid inputs.
+ * @param schema - The schema to convert (may be undefined)
+ * @param onError - Optional callback invoked on conversion error
+ * @returns The JSON Schema representation, or undefined if conversion fails
+ */
+export declare function safeSchemaToJsonSchema(schema: SupportedSchema | undefined | null, onError?: (error: unknown) => void): JSONSchema7 | undefined;
+/**
+ * Checks if a tool uses the new inputSchema interface (vs deprecated toolSchema).
+ * @param tool - The Tambo tool to check
+ * @returns True if the tool uses inputSchema
+ */
+export declare function hasInputSchema(tool: TamboTool | TamboToolWithToolSchema): tool is TamboTool;
+/**
+ * Extracts parameter specifications from a tool schema.
+ *
+ * For tools with **inputSchema** (new interface):
+ * - Returns a single parameter named "input" representing the object schema
+ * - The inputSchema defines the shape of the single object argument
+ *
+ * For tools with **toolSchema** (deprecated):
+ * - Extracts positional parameters from tuple/function args
+ * - Returns params named "param1", "param2", etc.
+ * @param tool - The tool containing the schema
+ * @returns An array of parameter specifications
+ */
+export declare const getParametersFromToolSchema: (tool: TamboTool | TamboToolWithToolSchema) => ParameterSpec[];
+export type { SupportedSchema };
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EACL,aAAa,EACb,eAAe,EACf,SAAS,EACT,uBAAuB,EACxB,MAAM,6BAA6B,CAAC;AAYrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,CAOvE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,EAC1C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,WAAW,GAAG,SAAS,CAYzB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,GAAG,uBAAuB,GACxC,IAAI,IAAI,SAAS,CAEnB;AA0DD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,SAAS,GAAG,uBAAuB,KACxC,aAAa,EAmDf,CAAC;AAEF,YAAY,EAAE,eAAe,EAAE,CAAC"}

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"}