@tambo-ai/client 0.0.1

package/dist/model/component-metadata.d.ts

@@ -0,0 +1,390 @@
+import type { ToolAnnotations as MCPToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import TamboAI from "@tambo-ai/typescript-sdk";
+import { JSONSchema7 } from "json-schema";
+/**
+ * A schema type that accepts either a Standard Schema compliant validator
+ * (e.g., Zod, Valibot, ArkType) or a raw JSON Schema object.
+ *
+ * Standard Schema is a specification that provides a unified interface for
+ * TypeScript validation libraries. Libraries like Zod implement this spec,
+ * allowing us to accept any compliant validator without depending on a specific library.
+ * @see https://standardschema.dev/
+ */
+export type SupportedSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> | JSONSchema7;
+/**
+ * Annotations describing a tool's behavior, aligned with the MCP (Model Context Protocol)
+ * specification. These hints help clients understand how tools behave and can be used
+ * to optimize tool execution strategies.
+ * @see https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations
+ */
+export type ToolAnnotations = MCPToolAnnotations & {
+    /**
+     * Indicates that the tool is safe to be called repeatedly while a response is
+     * being streamed. This is typically used for read-only tools that do not
+     * cause side effects.
+     */
+    tamboStreamableHint?: boolean;
+};
+/** Extension of the ToolParameters interface from Tambo AI to include JSONSchema definition */
+export type ParameterSpec = TamboAI.ToolParameters & {
+    schema?: JSONSchema7;
+};
+/**
+ * Extends the base ContextTool interface from Tambo AI to include schema information
+ * for parameter validation.
+ */
+export interface ComponentContextToolMetadata extends TamboAI.ComponentContextToolMetadata {
+    parameters: ParameterSpec[];
+    /**
+     * Optional per-tool call limit. When set, this overrides the project's
+     * global tool call limit for this specific tool.
+     *
+     * This is useful for tools that should only be called once or twice
+     * regardless of the project's global limit.
+     */
+    maxCalls?: number;
+    /**
+     * Annotations describing the tool's behavior. See {@link ToolAnnotations}.
+     */
+    annotations?: ToolAnnotations;
+}
+export interface ComponentContextTool {
+    getComponentContext: (...args: any[]) => Promise<any>;
+    definition: ComponentContextToolMetadata;
+}
+export interface RegisteredComponent extends TamboAI.AvailableComponent {
+    component: unknown;
+    loadingComponent?: unknown;
+}
+export type ComponentRegistry = Record<string, RegisteredComponent>;
+export type TamboToolRegistry = Record<string, TamboTool>;
+/**
+ * A JSON Schema that is compatible with the MCP.
+ * This is a simplified JSON Schema that is compatible with the MCPClient and the tool's inputSchema.
+ *
+ * Do not export this type from the SDK.
+ */
+export type JSONSchemaLite = JSONSchema7 & {
+    description?: string;
+};
+type MaybeAsync<T> = T | Promise<T>;
+/**
+ * TamboTool is a type that represents a tool that can be registered with Tambo.
+ *
+ * It is preferable to use the `defineTool` helper function to create tools, as
+ * it provides better type inference and safety.
+ * @example
+ * ```ts
+ * import { TamboTool, defineTool } from "@tambo-ai/react";
+ * import { z } from "zod";
+ *
+ * const locationToLatLon = defineTool({
+ *   name: "location_to_latlon",
+ *   description:
+ *     "Fetch latitude and longitude from a location string. Returns an object with 'lat' and 'lon' properties.",
+ *   tool: async ({ location }) => getLatLonFromLocation(location),
+ *   inputSchema: z.object({
+ *     location: z.string(),
+ *   }),
+ *   outputSchema: z.object({
+ *     lat: z.number(),
+ *     lon: z.number(),
+ *   }),
+ * });
+ * ```
+ */
+export interface TamboTool<Params = any, Returns = any, Rest extends any[] = []> {
+    /**
+     * Unique identifier for the tool
+     */
+    name: string;
+    /**
+     * Description of what the tool does - used by AI to determine when to use it
+     */
+    description: string;
+    /**
+     * Optional human-readable name of the tool for display purposes.
+     */
+    title?: string;
+    /**
+     * Optional limit for how many times this tool may be called while
+     * generating a single response. If present, this value overrides the
+     * project's global `maxToolCallLimit` for this tool.
+     * @example 1
+     */
+    maxCalls?: number;
+    /**
+     * Annotations describing the tool's behavior, aligned with the MCP specification.
+     * Use `tamboStreamableHint: true` to enable streaming execution of partial tool calls.
+     * @see {@link ToolAnnotations}
+     * @example
+     * ```ts
+     * const setTextTool: TamboTool<{ text: string }> = {
+     *   name: "set_text",
+     *   description: "Set the displayed text",
+     *   annotations: {
+     *     tamboStreamableHint: true, // tool is safe for streaming calls
+     *   },
+     *   tool: ({ text }) => setText(text),
+     *   inputSchema: z.object({ text: z.string() }),
+     *   outputSchema: z.void(),
+     * };
+     * ```
+     */
+    annotations?: ToolAnnotations;
+    /**
+     * The function that implements the tool's logic. This function will be called
+     * by Tambo when the model decides to invoke the tool.
+     * @param params - The input parameters for the tool. These are validated
+     * against the inputSchema before being passed so are guaranteed to be correct
+     * when called by the model.
+     * @returns The result of the tool execution, which can be a value or a
+     * Promise resolving to a value
+     */
+    tool: (params: Params, ...rest: Rest) => MaybeAsync<Returns>;
+    /**
+     * The schema for the tool's input parameters. This can be a validator from
+     * any Standard Schema compliant library (Zod 3.24+, Zod 4.x) or a
+     * raw JSON Schema object.
+     *
+     * This schema is used to validate and parse the parameters before passing
+     * them to the tool function.
+     */
+    inputSchema: SupportedSchema<Params>;
+    /**
+     * The schema for the tool's output/return value. This can be any Standard Schema
+     * compliant validator (Zod 3.24+, Zod 4.x) or a raw JSON Schema object.
+     *
+     * This is used to inform the model about the structure of the tool's return value
+     * and is not used for runtime validation at this stage.
+     */
+    outputSchema: SupportedSchema<Returns>;
+    /**
+     * Optional function to transform the tool's return value into an array of content parts.
+     * If not provided, the return value will be converted to a string and wrapped in a text content part.
+     * @param result - The result returned by the tool function
+     * @returns An array of content parts to be sent back to the AI
+     */
+    transformToContent?: (result: any) => Promise<TamboAI.Beta.Threads.ChatCompletionContentPart[]> | TamboAI.Beta.Threads.ChatCompletionContentPart[];
+}
+/**
+ * A tool that uses JSON Schema compliant input and output schemas.
+ * This does not provide type safety for the tool's parameters and return value.
+ * @internal
+ */
+export type TamboToolJSONSchema<Args extends unknown[] = unknown[], Returns = unknown> = Omit<TamboTool<Args, Returns>, "tool" | "inputSchema" | "outputSchema"> & {
+    tool: (...args: Args) => MaybeAsync<Returns>;
+    inputSchema: JSONSchemaLite;
+    outputSchema: JSONSchemaLite;
+};
+/**
+ * A tool that could not be matched to any known schema types.
+ * This means type safety cannot be guaranteed.
+ * @internal
+ */
+export type TamboToolUnknown = Omit<TamboTool, "tool" | "inputSchema" | "outputSchema"> & {
+    tool: (...args: unknown[]) => MaybeAsync<unknown>;
+    inputSchema: SupportedSchema;
+    outputSchema: SupportedSchema;
+};
+/**
+ * A tool that uses Standard Schema compliant input and output schemas.
+ * This provides full type safety for the tool's parameters and return value.
+ * @internal
+ */
+export type TamboToolStandardSchema<Input extends StandardSchemaV1 = StandardSchemaV1, Output extends StandardSchemaV1 = StandardSchemaV1> = Omit<TamboTool<StandardSchemaV1.InferOutput<Input>, StandardSchemaV1.InferOutput<Output>>, "tool" | "inputSchema" | "outputSchema"> & {
+    tool: (...args: [StandardSchemaV1.InferOutput<Input>]) => MaybeAsync<StandardSchemaV1.InferOutput<Output>>;
+    inputSchema: Input;
+    outputSchema: Output;
+};
+/**
+ * If you're seeing this type, it means that you are using a deprecated and now
+ * unsupported schema type for defining Tambo tools.
+ *
+ * Follow the migration guide to update your tool definitions to use
+ * inputSchema and outputSchema with either Standard Schema compliant validators
+ * (like Zod 3.25.76, Zod 4.x) or raw JSON Schema objects.
+ * @deprecated replace `toolSchema` with `inputSchema` and `outputSchema` instead.
+ * @see {@link https://docs.tambo.co/reference/react-sdk/migration}
+ */
+export type UnsupportedSchemaTamboTool = Omit<TamboTool, "tool" | "inputSchema" | "outputSchema"> & {
+    /**
+     * @deprecated replace `toolSchema` with `inputSchema` and `outputSchema` instead.
+     */
+    toolSchema: any;
+    tool: (...args: any[]) => MaybeAsync<any>;
+    inputSchema?: never;
+    outputSchema?: never;
+};
+export type TamboToolAssociations = Record<string, string[]>;
+/**
+ * A component that can be registered with the TamboRegistryProvider.
+ */
+export interface TamboComponent {
+    /** The name of the component */
+    name: string;
+    /** The description of the component */
+    description: string;
+    /**
+     * The component to render.
+     *
+     * In the React SDK, this should be a React ComponentType.
+     * In the client package, this is typed as `unknown` since it is framework-agnostic.
+     */
+    component: unknown;
+    /**
+     * Schema describing the component's props. Accepts any Standard Schema
+     * compliant validator (Zod, Valibot, ArkType, etc.) or a raw JSON Schema
+     * object.
+     *
+     * Either this or propsDefinition must be provided, but not both.
+     * @example
+     * ```typescript
+     * import { z } from "zod/v4";
+     *
+     * const component: TamboComponent = {
+     *   name: "MyComponent",
+     *   description: "A sample component",
+     *   component: MyComponent,
+     *   propsSchema: z.object({
+     *     title: z.string(),
+     *     count: z.number().optional()
+     *   })
+     * };
+     * ```
+     */
+    propsSchema?: SupportedSchema;
+    /**
+     * The props definition of the component as a JSON object.
+     * Either this or propsSchema must be provided, but not both.
+     * @deprecated Use propsSchema instead.
+     */
+    propsDefinition?: any;
+    /** The loading component to render while the component is loading */
+    loadingComponent?: unknown;
+    /** The tools that are associated with the component */
+    associatedTools?: TamboTool[];
+    /** Annotations describing the component's behavior. */
+    annotations?: ToolAnnotations;
+}
+type OptionalSchemaProps<T> = Omit<T, "inputSchema" | "outputSchema"> & {
+    inputSchema?: T extends {
+        inputSchema: infer I;
+    } ? I : never;
+    outputSchema?: T extends {
+        outputSchema: infer O;
+    } ? O : never;
+};
+/**
+ * Registers one or more Tambo tools.
+ * @param tools - An array of Tambo tools to register
+ * @param warnOnOverwrite - Whether to warn if any tool is being overwritten
+ */
+export interface RegisterToolsFn {
+    /**
+     * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update
+     * your tool definitions to use `inputSchema` and `outputSchema` instead.
+     */
+    (tools: UnsupportedSchemaTamboTool[], warnOnOverwrite?: boolean): void;
+    /**
+     * Register one or more Tambo tools. For better type inference, consider registering tools individually using the
+     * `registerTool` function or use the `defineTool` helper when defining your tools.
+     * @example
+     * ```typescript
+     * import { defineTool } from "@tambo-ai/react";
+     * const tools = [
+     *   defineTool({...});
+     *   defineTool({...});
+     * ];
+     * registerTools(tools);
+     * @param tools - An array of Tambo tools to register
+     * @param warnOnOverwrite - Whether to warn if any tool is being overwritten
+     */
+    (tools: TamboTool[], warnOnOverwrite?: boolean): void;
+}
+/**
+ * Function interface for registering a Tambo tool with full type inference.
+ * This function has multiple overloads to handle different schema types. This
+ * is a utility function and does not perform any runtime logic.
+ */
+export interface RegisterToolFn {
+    <Args extends StandardSchemaV1, Returns extends StandardSchemaV1>(tool: TamboToolStandardSchema<Args, Returns>, warnOnOverwrite?: boolean): void;
+    <Args extends any[], Returns = any>(tool: TamboToolJSONSchema<Args, Returns>, warnOnOverwrite?: boolean): void;
+    (tool: TamboToolUnknown, warnOnOverwrite?: boolean): void;
+    (tool: TamboTool, warnOnOverwrite?: boolean): void;
+    /**
+     * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update
+     * your tool definitions to use `inputSchema` and `outputSchema` instead.
+     * @param tool - The unsupported schema Tambo tool to register
+     * @param warnOnOverwrite - Whether to warn if the tool is being overwritten
+     */
+    (tool: UnsupportedSchemaTamboTool, warnOnOverwrite?: boolean): void;
+}
+/**
+ * Function interface for defining a Tambo tool with full type inference. This function has multiple overloads to handle
+ * different schema types. This is a utility function and does not perform any runtime logic.
+ */
+export interface DefineToolFn {
+    /**
+     * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update
+     * your tool definitions to use `inputSchema` and `outputSchema` instead.
+     * @param tool The tool definition to register
+     * @returns The registered tool definition
+     */
+    (tool: UnsupportedSchemaTamboTool): typeof tool;
+    /**
+     * Provides type safety for defining a Tambo Tool.
+     *
+     * Tambo uses the [standard-schema.dev](https://standard-schema.dev) spec which means you can use any Standard Schema
+     * compliant validator (Zod 3.24+, Zod 4.x). This definition ensures the input and output types are correctly
+     * inferred from the provided schemas.
+     * @example
+     * ```typescript
+     * import { z } from "zod/v4";
+     *
+     * const myTool = defineTool({
+     *   name: "myTool",
+     *   description: "An example tool",
+     *   inputSchema: z.object({
+     *     input: z.string().describe("Input description")
+     *   }),
+     *   outputSchema: z.number().describe("Result description"),
+     *   tool: ({ input }) => input.length,
+     * });
+     * ```
+     * @see {@link https://standard-schema.dev/}
+     * @param tool The tool definition to register
+     * @returns The registered tool definition
+     */
+    <Input extends StandardSchemaV1, Output extends StandardSchemaV1>(tool: OptionalSchemaProps<TamboToolStandardSchema<Input, Output>>): TamboToolStandardSchema<Input, Output>;
+    /**
+     * Provides type safety for defining a Tambo Tool with JSON Schema input and output.
+     *
+     * This overload is used when providing raw JSON Schema objects instead of StandardSchema validators.
+     * Type inference is limited when using raw JSON Schema.
+     * @see {@link https://standard-schema.dev/}
+     * @param tool The tool definition to register
+     * @returns The registered tool definition
+     */
+    <I extends any[], O = any>(tool: OptionalSchemaProps<TamboToolJSONSchema<I, O>>): TamboToolJSONSchema<I, O>;
+    /**
+     * Provides type safety for defining a Tambo Tool.
+     *
+     * This overload is used when the schema types could not be matched to known types.
+     * Type safety cannot be guaranteed.
+     * @param tool The tool definition to register
+     * @returns The registered tool definition
+     */
+    (tool: OptionalSchemaProps<TamboToolUnknown>): TamboToolUnknown;
+    /**
+     * Provides type safety for defining a Tambo Tool.
+     *
+     * This overload is used when providing a fully defined TamboTool.
+     * @param tool The tool definition to register
+     * @returns The registered tool definition
+     */
+    (tool: OptionalSchemaProps<TamboTool>): TamboTool;
+}
+export {};
+//# sourceMappingURL=component-metadata.d.ts.map

package/dist/model/component-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-metadata.d.ts","sourceRoot":"","sources":["../../src/model/component-metadata.ts"],"names":[],"mappings":"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"}

package/dist/model/component-metadata.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=component-metadata.js.map

package/dist/model/component-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-metadata.js","sourceRoot":"","sources":["../../src/model/component-metadata.ts"],"names":[],"mappings":"","sourcesContent":["import type { ToolAnnotations as MCPToolAnnotations } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport TamboAI from \"@tambo-ai/typescript-sdk\";\nimport { JSONSchema7 } from \"json-schema\";\n\n/**\n * A schema type that accepts either a Standard Schema compliant validator\n * (e.g., Zod, Valibot, ArkType) or a raw JSON Schema object.\n *\n * Standard Schema is a specification that provides a unified interface for\n * TypeScript validation libraries. Libraries like Zod implement this spec,\n * allowing us to accept any compliant validator without depending on a specific library.\n * @see https://standardschema.dev/\n */\nexport type SupportedSchema<Input = unknown, Output = Input> =\n  | StandardSchemaV1<Input, Output>\n  | JSONSchema7;\n\n/**\n * Annotations describing a tool's behavior, aligned with the MCP (Model Context Protocol)\n * specification. These hints help clients understand how tools behave and can be used\n * to optimize tool execution strategies.\n * @see https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations\n */\nexport type ToolAnnotations = MCPToolAnnotations & {\n  /**\n   * Indicates that the tool is safe to be called repeatedly while a response is\n   * being streamed. This is typically used for read-only tools that do not\n   * cause side effects.\n   */\n  tamboStreamableHint?: boolean;\n};\n\n/** Extension of the ToolParameters interface from Tambo AI to include JSONSchema definition */\nexport type ParameterSpec = TamboAI.ToolParameters & {\n  schema?: JSONSchema7;\n};\n\n/**\n * Extends the base ContextTool interface from Tambo AI to include schema information\n * for parameter validation.\n */\nexport interface ComponentContextToolMetadata\n  extends TamboAI.ComponentContextToolMetadata {\n  parameters: ParameterSpec[];\n  /**\n   * Optional per-tool call limit. When set, this overrides the project's\n   * global tool call limit for this specific tool.\n   *\n   * This is useful for tools that should only be called once or twice\n   * regardless of the project's global limit.\n   */\n  maxCalls?: number;\n  /**\n   * Annotations describing the tool's behavior. See {@link ToolAnnotations}.\n   */\n  annotations?: ToolAnnotations;\n}\n\nexport interface ComponentContextTool {\n  getComponentContext: (...args: any[]) => Promise<any>;\n  definition: ComponentContextToolMetadata;\n}\n\nexport interface RegisteredComponent extends TamboAI.AvailableComponent {\n  component: unknown;\n  loadingComponent?: unknown;\n}\n\nexport type ComponentRegistry = Record<string, RegisteredComponent>;\n\nexport type TamboToolRegistry = Record<string, TamboTool>;\n\n/**\n * A JSON Schema that is compatible with the MCP.\n * This is a simplified JSON Schema that is compatible with the MCPClient and the tool's inputSchema.\n *\n * Do not export this type from the SDK.\n */\nexport type JSONSchemaLite = JSONSchema7 & {\n  description?: string;\n};\n\ntype MaybeAsync<T> = T | Promise<T>;\n\n/**\n * TamboTool is a type that represents a tool that can be registered with Tambo.\n *\n * It is preferable to use the `defineTool` helper function to create tools, as\n * it provides better type inference and safety.\n * @example\n * ```ts\n * import { TamboTool, defineTool } from \"@tambo-ai/react\";\n * import { z } from \"zod\";\n *\n * const locationToLatLon = defineTool({\n *   name: \"location_to_latlon\",\n *   description:\n *     \"Fetch latitude and longitude from a location string. Returns an object with 'lat' and 'lon' properties.\",\n *   tool: async ({ location }) => getLatLonFromLocation(location),\n *   inputSchema: z.object({\n *     location: z.string(),\n *   }),\n *   outputSchema: z.object({\n *     lat: z.number(),\n *     lon: z.number(),\n *   }),\n * });\n * ```\n */\nexport interface TamboTool<\n  Params = any,\n  Returns = any,\n  Rest extends any[] = [],\n> {\n  /**\n   * Unique identifier for the tool\n   */\n  name: string;\n  /**\n   * Description of what the tool does - used by AI to determine when to use it\n   */\n  description: string;\n  /**\n   * Optional human-readable name of the tool for display purposes.\n   */\n  title?: string;\n  /**\n   * Optional limit for how many times this tool may be called while\n   * generating a single response. If present, this value overrides the\n   * project's global `maxToolCallLimit` for this tool.\n   * @example 1\n   */\n  maxCalls?: number;\n  /**\n   * Annotations describing the tool's behavior, aligned with the MCP specification.\n   * Use `tamboStreamableHint: true` to enable streaming execution of partial tool calls.\n   * @see {@link ToolAnnotations}\n   * @example\n   * ```ts\n   * const setTextTool: TamboTool<{ text: string }> = {\n   *   name: \"set_text\",\n   *   description: \"Set the displayed text\",\n   *   annotations: {\n   *     tamboStreamableHint: true, // tool is safe for streaming calls\n   *   },\n   *   tool: ({ text }) => setText(text),\n   *   inputSchema: z.object({ text: z.string() }),\n   *   outputSchema: z.void(),\n   * };\n   * ```\n   */\n  annotations?: ToolAnnotations;\n\n  /**\n   * The function that implements the tool's logic. This function will be called\n   * by Tambo when the model decides to invoke the tool.\n   * @param params - The input parameters for the tool. These are validated\n   * against the inputSchema before being passed so are guaranteed to be correct\n   * when called by the model.\n   * @returns The result of the tool execution, which can be a value or a\n   * Promise resolving to a value\n   */\n  tool: (params: Params, ...rest: Rest) => MaybeAsync<Returns>;\n\n  /**\n   * The schema for the tool's input parameters. This can be a validator from\n   * any Standard Schema compliant library (Zod 3.24+, Zod 4.x) or a\n   * raw JSON Schema object.\n   *\n   * This schema is used to validate and parse the parameters before passing\n   * them to the tool function.\n   */\n  inputSchema: SupportedSchema<Params>;\n\n  /**\n   * The schema for the tool's output/return value. This can be any Standard Schema\n   * compliant validator (Zod 3.24+, Zod 4.x) or a raw JSON Schema object.\n   *\n   * This is used to inform the model about the structure of the tool's return value\n   * and is not used for runtime validation at this stage.\n   */\n  outputSchema: SupportedSchema<Returns>;\n\n  /**\n   * Optional function to transform the tool's return value into an array of content parts.\n   * If not provided, the return value will be converted to a string and wrapped in a text content part.\n   * @param result - The result returned by the tool function\n   * @returns An array of content parts to be sent back to the AI\n   */\n  transformToContent?: (\n    result: any,\n  ) =>\n    | Promise<TamboAI.Beta.Threads.ChatCompletionContentPart[]>\n    | TamboAI.Beta.Threads.ChatCompletionContentPart[];\n}\n\n/**\n * A tool that uses JSON Schema compliant input and output schemas.\n * This does not provide type safety for the tool's parameters and return value.\n * @internal\n */\nexport type TamboToolJSONSchema<\n  Args extends unknown[] = unknown[],\n  Returns = unknown,\n> = Omit<TamboTool<Args, Returns>, \"tool\" | \"inputSchema\" | \"outputSchema\"> & {\n  tool: (...args: Args) => MaybeAsync<Returns>;\n  inputSchema: JSONSchemaLite;\n  outputSchema: JSONSchemaLite;\n};\n\n/**\n * A tool that could not be matched to any known schema types.\n * This means type safety cannot be guaranteed.\n * @internal\n */\nexport type TamboToolUnknown = Omit<\n  TamboTool,\n  \"tool\" | \"inputSchema\" | \"outputSchema\"\n> & {\n  tool: (...args: unknown[]) => MaybeAsync<unknown>;\n  inputSchema: SupportedSchema;\n  outputSchema: SupportedSchema;\n};\n\n/**\n * A tool that uses Standard Schema compliant input and output schemas.\n * This provides full type safety for the tool's parameters and return value.\n * @internal\n */\nexport type TamboToolStandardSchema<\n  Input extends StandardSchemaV1 = StandardSchemaV1,\n  Output extends StandardSchemaV1 = StandardSchemaV1,\n> = Omit<\n  TamboTool<\n    StandardSchemaV1.InferOutput<Input>,\n    StandardSchemaV1.InferOutput<Output>\n  >,\n  \"tool\" | \"inputSchema\" | \"outputSchema\"\n> & {\n  tool: (\n    ...args: [StandardSchemaV1.InferOutput<Input>]\n  ) => MaybeAsync<StandardSchemaV1.InferOutput<Output>>;\n  inputSchema: Input;\n  outputSchema: Output;\n};\n\n/**\n * If you're seeing this type, it means that you are using a deprecated and now\n * unsupported schema type for defining Tambo tools.\n *\n * Follow the migration guide to update your tool definitions to use\n * inputSchema and outputSchema with either Standard Schema compliant validators\n * (like Zod 3.25.76, Zod 4.x) or raw JSON Schema objects.\n * @deprecated replace `toolSchema` with `inputSchema` and `outputSchema` instead.\n * @see {@link https://docs.tambo.co/reference/react-sdk/migration}\n */\nexport type UnsupportedSchemaTamboTool = Omit<\n  TamboTool,\n  \"tool\" | \"inputSchema\" | \"outputSchema\"\n> & {\n  /**\n   * @deprecated replace `toolSchema` with `inputSchema` and `outputSchema` instead.\n   */\n  toolSchema: any;\n  tool: (...args: any[]) => MaybeAsync<any>;\n  inputSchema?: never;\n  outputSchema?: never;\n};\n\nexport type TamboToolAssociations = Record<string, string[]>;\n/**\n * A component that can be registered with the TamboRegistryProvider.\n */\n\nexport interface TamboComponent {\n  /** The name of the component */\n  name: string;\n  /** The description of the component */\n  description: string;\n  /**\n   * The component to render.\n   *\n   * In the React SDK, this should be a React ComponentType.\n   * In the client package, this is typed as `unknown` since it is framework-agnostic.\n   */\n  component: unknown;\n\n  /**\n   * Schema describing the component's props. Accepts any Standard Schema\n   * compliant validator (Zod, Valibot, ArkType, etc.) or a raw JSON Schema\n   * object.\n   *\n   * Either this or propsDefinition must be provided, but not both.\n   * @example\n   * ```typescript\n   * import { z } from \"zod/v4\";\n   *\n   * const component: TamboComponent = {\n   *   name: \"MyComponent\",\n   *   description: \"A sample component\",\n   *   component: MyComponent,\n   *   propsSchema: z.object({\n   *     title: z.string(),\n   *     count: z.number().optional()\n   *   })\n   * };\n   * ```\n   */\n  propsSchema?: SupportedSchema;\n  /**\n   * The props definition of the component as a JSON object.\n   * Either this or propsSchema must be provided, but not both.\n   * @deprecated Use propsSchema instead.\n   */\n  propsDefinition?: any;\n  /** The loading component to render while the component is loading */\n  loadingComponent?: unknown;\n  /** The tools that are associated with the component */\n  associatedTools?: TamboTool[];\n  /** Annotations describing the component's behavior. */\n  annotations?: ToolAnnotations;\n}\n\ntype OptionalSchemaProps<T> = Omit<T, \"inputSchema\" | \"outputSchema\"> & {\n  inputSchema?: T extends { inputSchema: infer I } ? I : never;\n  outputSchema?: T extends { outputSchema: infer O } ? O : never;\n};\n\n/**\n * Registers one or more Tambo tools.\n * @param tools - An array of Tambo tools to register\n * @param warnOnOverwrite - Whether to warn if any tool is being overwritten\n */\nexport interface RegisterToolsFn {\n  /**\n   * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update\n   * your tool definitions to use `inputSchema` and `outputSchema` instead.\n   */\n  (tools: UnsupportedSchemaTamboTool[], warnOnOverwrite?: boolean): void;\n  /**\n   * Register one or more Tambo tools. For better type inference, consider registering tools individually using the\n   * `registerTool` function or use the `defineTool` helper when defining your tools.\n   * @example\n   * ```typescript\n   * import { defineTool } from \"@tambo-ai/react\";\n   * const tools = [\n   *   defineTool({...});\n   *   defineTool({...});\n   * ];\n   * registerTools(tools);\n   * @param tools - An array of Tambo tools to register\n   * @param warnOnOverwrite - Whether to warn if any tool is being overwritten\n   */\n  (tools: TamboTool[], warnOnOverwrite?: boolean): void;\n}\n\n/**\n * Function interface for registering a Tambo tool with full type inference.\n * This function has multiple overloads to handle different schema types. This\n * is a utility function and does not perform any runtime logic.\n */\nexport interface RegisterToolFn {\n  <Args extends StandardSchemaV1, Returns extends StandardSchemaV1>(\n    tool: TamboToolStandardSchema<Args, Returns>,\n    warnOnOverwrite?: boolean,\n  ): void;\n  <Args extends any[], Returns = any>(\n    tool: TamboToolJSONSchema<Args, Returns>,\n    warnOnOverwrite?: boolean,\n  ): void;\n  (tool: TamboToolUnknown, warnOnOverwrite?: boolean): void;\n  (tool: TamboTool, warnOnOverwrite?: boolean): void;\n  /**\n   * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update\n   * your tool definitions to use `inputSchema` and `outputSchema` instead.\n   * @param tool - The unsupported schema Tambo tool to register\n   * @param warnOnOverwrite - Whether to warn if the tool is being overwritten\n   */\n  (tool: UnsupportedSchemaTamboTool, warnOnOverwrite?: boolean): void;\n}\n\n/**\n * Function interface for defining a Tambo tool with full type inference. This function has multiple overloads to handle\n * different schema types. This is a utility function and does not perform any runtime logic.\n */\nexport interface DefineToolFn {\n  /**\n   * @deprecated Follow the {@link https://docs.tambo.co/reference/react-sdk/migration | Migration Guide} to update\n   * your tool definitions to use `inputSchema` and `outputSchema` instead.\n   * @param tool The tool definition to register\n   * @returns The registered tool definition\n   */\n  (tool: UnsupportedSchemaTamboTool): typeof tool;\n  /**\n   * Provides type safety for defining a Tambo Tool.\n   *\n   * Tambo uses the [standard-schema.dev](https://standard-schema.dev) spec which means you can use any Standard Schema\n   * compliant validator (Zod 3.24+, Zod 4.x). This definition ensures the input and output types are correctly\n   * inferred from the provided schemas.\n   * @example\n   * ```typescript\n   * import { z } from \"zod/v4\";\n   *\n   * const myTool = defineTool({\n   *   name: \"myTool\",\n   *   description: \"An example tool\",\n   *   inputSchema: z.object({\n   *     input: z.string().describe(\"Input description\")\n   *   }),\n   *   outputSchema: z.number().describe(\"Result description\"),\n   *   tool: ({ input }) => input.length,\n   * });\n   * ```\n   * @see {@link https://standard-schema.dev/}\n   * @param tool The tool definition to register\n   * @returns The registered tool definition\n   */\n  <Input extends StandardSchemaV1, Output extends StandardSchemaV1>(\n    tool: OptionalSchemaProps<TamboToolStandardSchema<Input, Output>>,\n  ): TamboToolStandardSchema<Input, Output>;\n  /**\n   * Provides type safety for defining a Tambo Tool with JSON Schema input and output.\n   *\n   * This overload is used when providing raw JSON Schema objects instead of StandardSchema validators.\n   * Type inference is limited when using raw JSON Schema.\n   * @see {@link https://standard-schema.dev/}\n   * @param tool The tool definition to register\n   * @returns The registered tool definition\n   */\n  <I extends any[], O = any>(\n    tool: OptionalSchemaProps<TamboToolJSONSchema<I, O>>,\n  ): TamboToolJSONSchema<I, O>;\n  /**\n   * Provides type safety for defining a Tambo Tool.\n   *\n   * This overload is used when the schema types could not be matched to known types.\n   * Type safety cannot be guaranteed.\n   * @param tool The tool definition to register\n   * @returns The registered tool definition\n   */\n  (tool: OptionalSchemaProps<TamboToolUnknown>): TamboToolUnknown;\n  /**\n   * Provides type safety for defining a Tambo Tool.\n   *\n   * This overload is used when providing a fully defined TamboTool.\n   * @param tool The tool definition to register\n   * @returns The registered tool definition\n   */\n  (tool: OptionalSchemaProps<TamboTool>): TamboTool;\n}\n"]}

package/dist/model/mcp-server-info.d.ts

@@ -0,0 +1,72 @@
+import { MCPHandlers } from "../mcp";
+/**
+ * The transport protocol to use for MCP connections.
+ */
+export declare enum MCPTransport {
+    SSE = "sse",
+    HTTP = "http"
+}
+/**
+ * User-provided configuration for an MCP server.
+ *
+ * This is the type accepted by `TamboProvider` / `TamboRegistryProvider` in
+ * the `mcpServers` prop.
+ *
+ * The `handlers` field is typed as `Partial<MCPHandlers>` (with
+ * `elicitation` / `sampling` callbacks). The `@modelcontextprotocol/sdk` is
+ * included automatically with `@tambo-ai/react`. See the React SDK README for
+ * any additional optional peer dependencies needed for MCP features.
+ */
+export interface McpServerInfo {
+    /** Optional name for the MCP server */
+    name?: string;
+    /** The URL of the MCP server to connect to */
+    url: string;
+    /** Optional description of the MCP server */
+    description?: string;
+    /** The transport type to use (SSE or HTTP). Defaults to HTTP for string URLs */
+    transport?: MCPTransport;
+    /** Optional custom headers to include in requests */
+    customHeaders?: Record<string, string>;
+    /**
+     * Optional short name for namespacing MCP resources, prompts, and tools.
+     * When multiple MCP servers are configured, this key is used to prefix:
+     * - prompts: `<serverKey>:<promptName>`
+     * - resources: `<serverKey>:<resourceUrl>`
+     * - tools: `<serverKey>__<toolName>`
+     *
+     * If not provided, a key will be derived from the URL hostname.
+     * For example, "https://mcp.linear.app/mcp" becomes "linear".
+     */
+    serverKey?: string;
+    /**
+     * Optional handlers for elicitation and sampling requests from the server.
+     *
+     * Note: These callbacks should be stable (e.g., wrapped in useCallback or
+     * defined outside the component) to avoid constant re-registration of the
+     * MCP server on every render.
+     */
+    handlers?: Partial<MCPHandlers>;
+}
+/**
+ * Normalized MCP server metadata used internally by the registry and MCP
+ * provider.
+ *
+ * This is equivalent to `McpServerInfo` except that:
+ * - `serverKey` is guaranteed to be present
+ * - `transport` is resolved to a concrete value (defaults to HTTP)
+ */
+export interface NormalizedMcpServerInfo extends McpServerInfo {
+    transport: MCPTransport;
+    serverKey: string;
+}
+/**
+ * Creates a stable identifier for an MCP server based on its connection properties.
+ * Two servers with the same URL, transport, and headers will have the same key.
+ *
+ * This is used by both the registry and MCP provider to deduplicate servers,
+ * so it lives alongside the shared server metadata type.
+ * @returns A stable string key identifying the server
+ */
+export declare function getMcpServerUniqueKey(serverInfo: Pick<McpServerInfo, "url" | "transport" | "customHeaders">): string;
+//# sourceMappingURL=mcp-server-info.d.ts.map

package/dist/model/mcp-server-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-info.d.ts","sourceRoot":"","sources":["../../src/model/mcp-server-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;GAEG;AACH,oBAAY,YAAY;IACtB,GAAG,QAAQ;IACX,IAAI,SAAS;CACd;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC5D,SAAS,EAAE,YAAY,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,WAAW,GAAG,eAAe,CAAC,GACrE,MAAM,CAUR"}

package/dist/model/mcp-server-info.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPTransport = void 0;
+exports.getMcpServerUniqueKey = getMcpServerUniqueKey;
+/**
+ * The transport protocol to use for MCP connections.
+ */
+var MCPTransport;
+(function (MCPTransport) {
+    MCPTransport["SSE"] = "sse";
+    MCPTransport["HTTP"] = "http";
+})(MCPTransport || (exports.MCPTransport = MCPTransport = {}));
+/**
+ * Creates a stable identifier for an MCP server based on its connection properties.
+ * Two servers with the same URL, transport, and headers will have the same key.
+ *
+ * This is used by both the registry and MCP provider to deduplicate servers,
+ * so it lives alongside the shared server metadata type.
+ * @returns A stable string key identifying the server
+ */
+function getMcpServerUniqueKey(serverInfo) {
+    const headerStr = serverInfo.customHeaders
+        ? JSON.stringify(Object.entries(serverInfo.customHeaders)
+            .map(([k, v]) => [k.toLowerCase(), v])
+            .sort(([a], [b]) => a.localeCompare(b)))
+        : "";
+    return `${serverInfo.url}|${serverInfo.transport ?? MCPTransport.HTTP}|${headerStr}`;
+}
+//# sourceMappingURL=mcp-server-info.js.map

package/dist/model/mcp-server-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server-info.js","sourceRoot":"","sources":["../../src/model/mcp-server-info.ts"],"names":[],"mappings":";;;AA0EA,sDAYC;AApFD;;GAEG;AACH,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,2BAAW,CAAA;IACX,6BAAa,CAAA;AACf,CAAC,EAHW,YAAY,4BAAZ,YAAY,QAGvB;AA0DD;;;;;;;GAOG;AACH,SAAgB,qBAAqB,CACnC,UAAsE;IAEtE,MAAM,SAAS,GAAG,UAAU,CAAC,aAAa;QACxC,CAAC,CAAC,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC;aACrC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAU,CAAC;aAC9C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAC1C;QACH,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO,GAAG,UAAU,CAAC,GAAG,IAAI,UAAU,CAAC,SAAS,IAAI,YAAY,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;AACvF,CAAC","sourcesContent":["import { MCPHandlers } from \"../mcp\";\n\n/**\n * The transport protocol to use for MCP connections.\n */\nexport enum MCPTransport {\n  SSE = \"sse\",\n  HTTP = \"http\",\n}\n\n/**\n * User-provided configuration for an MCP server.\n *\n * This is the type accepted by `TamboProvider` / `TamboRegistryProvider` in\n * the `mcpServers` prop.\n *\n * The `handlers` field is typed as `Partial<MCPHandlers>` (with\n * `elicitation` / `sampling` callbacks). The `@modelcontextprotocol/sdk` is\n * included automatically with `@tambo-ai/react`. See the React SDK README for\n * any additional optional peer dependencies needed for MCP features.\n */\nexport interface McpServerInfo {\n  /** Optional name for the MCP server */\n  name?: string;\n  /** The URL of the MCP server to connect to */\n  url: string;\n  /** Optional description of the MCP server */\n  description?: string;\n  /** The transport type to use (SSE or HTTP). Defaults to HTTP for string URLs */\n  transport?: MCPTransport;\n  /** Optional custom headers to include in requests */\n  customHeaders?: Record<string, string>;\n  /**\n   * Optional short name for namespacing MCP resources, prompts, and tools.\n   * When multiple MCP servers are configured, this key is used to prefix:\n   * - prompts: `<serverKey>:<promptName>`\n   * - resources: `<serverKey>:<resourceUrl>`\n   * - tools: `<serverKey>__<toolName>`\n   *\n   * If not provided, a key will be derived from the URL hostname.\n   * For example, \"https://mcp.linear.app/mcp\" becomes \"linear\".\n   */\n  serverKey?: string;\n  /**\n   * Optional handlers for elicitation and sampling requests from the server.\n   *\n   * Note: These callbacks should be stable (e.g., wrapped in useCallback or\n   * defined outside the component) to avoid constant re-registration of the\n   * MCP server on every render.\n   */\n  handlers?: Partial<MCPHandlers>;\n}\n\n/**\n * Normalized MCP server metadata used internally by the registry and MCP\n * provider.\n *\n * This is equivalent to `McpServerInfo` except that:\n * - `serverKey` is guaranteed to be present\n * - `transport` is resolved to a concrete value (defaults to HTTP)\n */\nexport interface NormalizedMcpServerInfo extends McpServerInfo {\n  transport: MCPTransport;\n  serverKey: string;\n}\n\n/**\n * Creates a stable identifier for an MCP server based on its connection properties.\n * Two servers with the same URL, transport, and headers will have the same key.\n *\n * This is used by both the registry and MCP provider to deduplicate servers,\n * so it lives alongside the shared server metadata type.\n * @returns A stable string key identifying the server\n */\nexport function getMcpServerUniqueKey(\n  serverInfo: Pick<McpServerInfo, \"url\" | \"transport\" | \"customHeaders\">,\n): string {\n  const headerStr = serverInfo.customHeaders\n    ? JSON.stringify(\n        Object.entries(serverInfo.customHeaders)\n          .map(([k, v]) => [k.toLowerCase(), v] as const)\n          .sort(([a], [b]) => a.localeCompare(b)),\n      )\n    : \"\";\n\n  return `${serverInfo.url}|${serverInfo.transport ?? MCPTransport.HTTP}|${headerStr}`;\n}\n"]}

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export { looksLikeJSONSchema, makeJsonSchemaPartial } from "./json-schema";
+export { getParametersFromToolSchema, safeSchemaToJsonSchema, schemaToJsonSchema, type SupportedSchema, } from "./schema";
+export { isStandardSchema } from "./standard-schema";
+export { assertNoRecordSchema } from "./validate";
+//# sourceMappingURL=index.d.ts.map

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,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}

package/dist/schema/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoRecordSchema = exports.isStandardSchema = exports.schemaToJsonSchema = exports.safeSchemaToJsonSchema = exports.getParametersFromToolSchema = exports.makeJsonSchemaPartial = exports.looksLikeJSONSchema = void 0;
+var json_schema_1 = require("./json-schema");
+Object.defineProperty(exports, "looksLikeJSONSchema", { enumerable: true, get: function () { return json_schema_1.looksLikeJSONSchema; } });
+Object.defineProperty(exports, "makeJsonSchemaPartial", { enumerable: true, get: function () { return json_schema_1.makeJsonSchemaPartial; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "getParametersFromToolSchema", { enumerable: true, get: function () { return schema_1.getParametersFromToolSchema; } });
+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; } });
+//# 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,6CAA2E;AAAlE,kHAAA,mBAAmB,OAAA;AAAE,oHAAA,qBAAqB,OAAA;AACnD,mCAKkB;AAJhB,qHAAA,2BAA2B,OAAA;AAC3B,gHAAA,sBAAsB,OAAA;AACtB,4GAAA,kBAAkB,OAAA;AAGpB,qDAAqD;AAA5C,mHAAA,gBAAgB,OAAA;AACzB,uCAAkD;AAAzC,gHAAA,oBAAoB,OAAA","sourcesContent":["export { looksLikeJSONSchema, makeJsonSchemaPartial } from \"./json-schema\";\nexport {\n  getParametersFromToolSchema,\n  safeSchemaToJsonSchema,\n  schemaToJsonSchema,\n  type SupportedSchema,\n} from \"./schema\";\nexport { isStandardSchema } from \"./standard-schema\";\nexport { assertNoRecordSchema } from \"./validate\";\n"]}

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

@@ -0,0 +1,42 @@
+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;
+/**
+ * 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
+ */
+export declare function makeJsonSchemaPartial(schema: JSONSchema7): JSONSchema7;
+//# 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;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAGtE"}