@tambo-ai/client 0.0.1

package/esm/schema/json-schema.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeJSONSchema = looksLikeJSONSchema;
+exports.isJsonSchemaTuple = isJsonSchemaTuple;
+exports.getJsonSchemaTupleItems = getJsonSchemaTupleItems;
+exports.makeJsonSchemaPartial = makeJsonSchemaPartial;
+const v4_1 = require("zod/v4");
+const jsonSchemaType = v4_1.z.union([
+    v4_1.z.literal("object"),
+    v4_1.z.literal("array"),
+    v4_1.z.literal("string"),
+    v4_1.z.literal("number"),
+    v4_1.z.literal("integer"),
+    v4_1.z.literal("boolean"),
+    v4_1.z.literal("null"),
+    v4_1.z.array(v4_1.z.union([
+        v4_1.z.literal("object"),
+        v4_1.z.literal("array"),
+        v4_1.z.literal("string"),
+        v4_1.z.literal("number"),
+        v4_1.z.literal("integer"),
+        v4_1.z.literal("boolean"),
+        v4_1.z.literal("null"),
+    ])),
+]);
+const jsonSchemaTopLevel = v4_1.z
+    .looseObject({
+    type: jsonSchemaType.optional(),
+    properties: v4_1.z.record(v4_1.z.string(), v4_1.z.unknown()).optional(),
+    items: v4_1.z.union([v4_1.z.array(v4_1.z.unknown()), v4_1.z.unknown()]).optional(),
+    required: v4_1.z.array(v4_1.z.string()).optional(),
+    additionalProperties: v4_1.z.union([v4_1.z.boolean(), v4_1.z.unknown()]).optional(),
+    enum: v4_1.z.array(v4_1.z.unknown()).optional(),
+    const: v4_1.z.unknown().optional(),
+    $ref: v4_1.z.string().optional(),
+    $id: v4_1.z.string().optional(),
+    $schema: v4_1.z.string().optional(),
+    title: v4_1.z.string().optional(),
+    description: v4_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;
+}
+/**
+ * Creates a partial version of a JSON Schema by removing required constraints.
+ * This allows LLM to provide only the properties it wants to update.
+ * @param schema - The JSON Schema to make partial
+ * @returns A new JSON Schema with the required constraint removed
+ */
+function makeJsonSchemaPartial(schema) {
+    const { required: _required, ...rest } = schema;
+    return rest;
+}
+//# sourceMappingURL=json-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","sourceRoot":"","sources":["../../src/schema/json-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import { JSONSchema7 } from \"json-schema\";\nimport { z } from \"zod/v4\";\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\n/**\n * Creates a partial version of a JSON Schema by removing required constraints.\n * This allows LLM to provide only the properties it wants to update.\n * @param schema - The JSON Schema to make partial\n * @returns A new JSON Schema with the required constraint removed\n */\nexport function makeJsonSchemaPartial(schema: JSONSchema7): JSONSchema7 {\n  const { required: _required, ...rest } = schema;\n  return rest;\n}\n"]}

package/esm/schema/schema.d.ts

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

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

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

package/esm/schema/schema.js

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

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

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

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

package/esm/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;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,gBAAgB,CAuBtE"}

package/esm/schema/standard-schema.js

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

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

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

package/esm/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/esm/schema/validate.d.ts.map

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

package/esm/schema/validate.js

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

package/esm/schema/validate.js.map

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