langchain 1.2.18 → 1.2.19

package/dist/agents/responses.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    /**\n     * The options to use for the tool output.\n     */\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}

package/dist/agents/responses.d.ts

@@ -19,11 +19,20 @@ type ResponseFormatUndefined = {
  * corresponding tool implementation used by the tools strategy.
  */
 declare class ToolStrategy<_T = unknown> {
+  /**
+   * The original JSON Schema provided for structured output
+   */
   readonly schema: Record<string, unknown>;
+  /**
+   * The tool that will be used to parse the tool call arguments.
+   */
   readonly tool: {
     type: "function";
     function: FunctionDefinition;
   };
+  /**
+   * The options to use for the tool output.
+   */
   readonly options?: ToolStrategyOptions | undefined;
   private constructor();
   get name(): string;

package/dist/agents/responses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"responses.d.ts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    readonly schema: Record<string, unknown>;\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"responses.d.ts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    /**\n     * The options to use for the tool output.\n     */\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}

package/dist/agents/responses.js.map

@@ -1 +1 @@
-{"version":3,"file":"responses.js","names":["schema: Record<string, unknown>","tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    }","options?: ToolStrategyOptions","schema: InteropZodObject | Record<string, unknown>","outputOptions?: ToolStrategyOptions","name?: string","asJsonSchema","tool","functionDefinition: FunctionDefinition","toolArgs: Record<string, unknown>","schemaOrOptions:\n      | Record<string, unknown>\n      | { schema: Record<string, unknown>; strict?: boolean }","strict?: boolean","schema: InteropZodType<T> | Record<string, unknown>","response: AIMessage","textContent: string | undefined","responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined","model?: LanguageModelLike | string","responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]","responseFormat:\n    | InteropZodType<unknown>\n    | JsonSchemaFormat\n    | { schema: InteropZodType<unknown> | JsonSchemaFormat; strict?: boolean }"],"sources":["../../src/agents/responses.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  InteropZodObject,\n  isInteropZodSchema,\n  InteropZodType,\n  isInteropZodObject,\n} from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { toJsonSchema, Validator } from \"@langchain/core/utils/json_schema\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\n\nimport {\n  StructuredOutputParsingError,\n  MultipleStructuredOutputsError,\n} from \"./errors.js\";\nimport { isConfigurableModel, isBaseChatModel } from \"./model.js\";\n\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n  __responseFormatUndefined: true;\n};\n\n/**\n * Default value for strict mode in providerStrategy.\n *\n * When using providerStrategy with json_schema response format, OpenAI's parse() method\n * requires all function tools to have strict: true. This ensures the model's output\n * exactly matches the provided JSON schema.\n *\n * @see https://platform.openai.com/docs/guides/structured-outputs\n */\nconst PROVIDER_STRATEGY_DEFAULT_STRICT = true;\n\n/**\n * This is a global counter for generating unique names for tools.\n */\nlet bindingIdentifier = 0;\n\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport class ToolStrategy<_T = unknown> {\n  private constructor(\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    public readonly schema: Record<string, unknown>,\n\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    public readonly tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    },\n\n    /**\n     * The options to use for the tool output.\n     */\n    public readonly options?: ToolStrategyOptions\n  ) {}\n\n  get name() {\n    return this.tool.function.name;\n  }\n\n  static fromSchema<S extends InteropZodObject>(\n    schema: S,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n\n  static fromSchema(\n    schema: Record<string, unknown>,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<Record<string, unknown>>;\n\n  static fromSchema(\n    schema: InteropZodObject | Record<string, unknown>,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<any> {\n    /**\n     * It is required for tools to have a name so we can map the tool call to the correct tool\n     * when parsing the response.\n     */\n    function getFunctionName(name?: string) {\n      return name ?? `extract-${++bindingIdentifier}`;\n    }\n\n    if (isInteropZodSchema(schema)) {\n      const asJsonSchema = toJsonSchema(schema);\n      const tool = {\n        type: \"function\" as const,\n        function: {\n          name: getFunctionName(asJsonSchema.title),\n          strict: false,\n          description:\n            asJsonSchema.description ??\n            \"Tool for extracting structured output from the model's response.\",\n          parameters: asJsonSchema,\n        },\n      };\n      return new ToolStrategy(asJsonSchema, tool, outputOptions);\n    }\n\n    let functionDefinition: FunctionDefinition;\n    if (\n      typeof schema.name === \"string\" &&\n      typeof schema.parameters === \"object\" &&\n      schema.parameters != null\n    ) {\n      functionDefinition = schema as unknown as FunctionDefinition;\n    } else {\n      functionDefinition = {\n        name: getFunctionName(schema.title as string),\n        description: (schema.description as string) ?? \"\",\n        parameters: schema.schema || (schema as Record<string, unknown>),\n      };\n    }\n    const asJsonSchema = toJsonSchema(schema);\n    const tool = {\n      type: \"function\" as const,\n      function: functionDefinition,\n    };\n    return new ToolStrategy(asJsonSchema, tool, outputOptions);\n  }\n\n  /**\n   * Parse tool arguments according to the schema.\n   *\n   * @throws {StructuredOutputParsingError} if the response is not valid\n   * @param toolArgs - The arguments from the tool call\n   * @returns The parsed response according to the schema type\n   */\n  parse(toolArgs: Record<string, unknown>): Record<string, unknown> {\n    const validator = new Validator(this.schema);\n    const result = validator.validate(toolArgs);\n    if (!result.valid) {\n      throw new StructuredOutputParsingError(\n        this.name,\n        result.errors.map((e) => e.error)\n      );\n    }\n    return toolArgs;\n  }\n}\n\nexport class ProviderStrategy<T = unknown> {\n  // @ts-expect-error - _schemaType is used only for type inference\n  private _schemaType?: T;\n\n  /**\n   * The schema to use for the provider strategy\n   */\n  public readonly schema: Record<string, unknown>;\n\n  /**\n   * Whether to use strict mode for the provider strategy\n   */\n  public readonly strict: boolean;\n\n  private constructor(options: {\n    schema: Record<string, unknown>;\n    strict?: boolean;\n  });\n  private constructor(schema: Record<string, unknown>, strict?: boolean);\n  private constructor(\n    schemaOrOptions:\n      | Record<string, unknown>\n      | { schema: Record<string, unknown>; strict?: boolean },\n    strict?: boolean\n  ) {\n    if (\n      \"schema\" in schemaOrOptions &&\n      typeof schemaOrOptions.schema === \"object\" &&\n      schemaOrOptions.schema !== null &&\n      !(\"type\" in schemaOrOptions)\n    ) {\n      const options = schemaOrOptions as {\n        schema: Record<string, unknown>;\n        strict?: boolean;\n      };\n      this.schema = options.schema;\n      this.strict = options.strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;\n    } else {\n      this.schema = schemaOrOptions as Record<string, unknown>;\n      this.strict = strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;\n    }\n  }\n\n  static fromSchema<T>(\n    schema: InteropZodType<T>,\n    strict?: boolean\n  ): ProviderStrategy<T>;\n\n  static fromSchema(\n    schema: Record<string, unknown>,\n    strict?: boolean\n  ): ProviderStrategy<Record<string, unknown>>;\n\n  static fromSchema<T = unknown>(\n    schema: InteropZodType<T> | Record<string, unknown>,\n    strict?: boolean\n  ): ProviderStrategy<T> | ProviderStrategy<Record<string, unknown>> {\n    const asJsonSchema = toJsonSchema(schema);\n    return new ProviderStrategy(asJsonSchema, strict) as\n      | ProviderStrategy<T>\n      | ProviderStrategy<Record<string, unknown>>;\n  }\n\n  /**\n   * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n   *\n   * @param response - The AI message response to parse\n   * @returns The parsed response according to the schema type\n   */\n  parse(response: AIMessage) {\n    /**\n     * Extract text content from the response.\n     * Handles both string content and array content (e.g., from thinking models).\n     */\n    let textContent: string | undefined;\n\n    if (typeof response.content === \"string\") {\n      textContent = response.content;\n    } else if (Array.isArray(response.content)) {\n      /**\n       * For thinking models, content is an array with thinking blocks and text blocks.\n       * Extract the text from text blocks.\n       */\n      for (const block of response.content) {\n        if (\n          typeof block === \"object\" &&\n          block !== null &&\n          \"type\" in block &&\n          block.type === \"text\" &&\n          \"text\" in block &&\n          typeof block.text === \"string\"\n        ) {\n          textContent = block.text;\n          break; // Use the first text block found\n        }\n      }\n    }\n\n    // Return if no valid text content found\n    if (!textContent || textContent === \"\") {\n      return;\n    }\n\n    try {\n      const content = JSON.parse(textContent);\n      const validator = new Validator(this.schema);\n      const result = validator.validate(content);\n      if (!result.valid) {\n        return;\n      }\n\n      return content;\n    } catch {\n      // no-op\n    }\n  }\n}\n\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport function transformResponseFormat(\n  responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined,\n  options?: ToolStrategyOptions,\n  model?: LanguageModelLike | string\n): ResponseFormat[] {\n  if (!responseFormat) {\n    return [];\n  }\n\n  // Handle ResponseFormatUndefined case\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"__responseFormatUndefined\" in responseFormat\n  ) {\n    return [];\n  }\n\n  /**\n   * If users provide an array, it should only contain raw schemas (Zod or JSON schema),\n   * not ToolStrategy or ProviderStrategy instances.\n   */\n  if (Array.isArray(responseFormat)) {\n    /**\n     * if every entry is a ToolStrategy or ProviderStrategy instance, return the array as is\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          item instanceof ToolStrategy || item instanceof ProviderStrategy\n      )\n    ) {\n      return responseFormat as unknown as ResponseFormat[];\n    }\n\n    /**\n     * Check if all items are Zod schemas\n     */\n    if (responseFormat.every((item) => isInteropZodObject(item))) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as InteropZodObject, options)\n      );\n    }\n\n    /**\n     * Check if all items are plain objects (JSON schema)\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          typeof item === \"object\" && item !== null && !isInteropZodObject(item)\n      )\n    ) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as JsonSchemaFormat, options)\n      );\n    }\n\n    throw new Error(\n      `Invalid response format: list contains mixed types.\\n` +\n        `All items must be either InteropZodObject or plain JSON schema objects.`\n    );\n  }\n\n  if (\n    responseFormat instanceof ToolStrategy ||\n    responseFormat instanceof ProviderStrategy\n  ) {\n    return [responseFormat];\n  }\n\n  const useProviderStrategy = hasSupportForJsonSchemaOutput(model);\n\n  /**\n   * `responseFormat` is a Zod schema\n   */\n  if (isInteropZodObject(responseFormat)) {\n    return useProviderStrategy\n      ? [ProviderStrategy.fromSchema(responseFormat)]\n      : [ToolStrategy.fromSchema(responseFormat, options)];\n  }\n\n  /**\n   * Handle plain object (JSON schema)\n   */\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"properties\" in responseFormat\n  ) {\n    return useProviderStrategy\n      ? [ProviderStrategy.fromSchema(responseFormat as JsonSchemaFormat)]\n      : [ToolStrategy.fromSchema(responseFormat as JsonSchemaFormat, options)];\n  }\n\n  throw new Error(`Invalid response format: ${String(responseFormat)}`);\n}\n\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown>\n  extends Array<ToolStrategy<any>> {\n  _schemaType?: T;\n}\nexport type ToolStrategyError =\n  | StructuredOutputParsingError\n  | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n  /**\n   * Allows you to customize the message that appears in the conversation history when structured\n   * output is generated.\n   */\n  toolMessageContent?: string;\n  /**\n   * Handle errors from the structured output tool call. Using tools to generate structured output\n   * can cause errors, e.g. if:\n   * - you provide multiple structured output schemas and the model calls multiple structured output tools\n   * - if the structured output generated by the tool call doesn't match provided schema\n   *\n   * This property allows to handle these errors in different ways:\n   * - `true` - retry the tool call\n   * - `false` - throw an error\n   * - `string` - retry the tool call with the provided message\n   * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n   *\n   * @default true\n   */\n  handleError?:\n    | boolean\n    | string\n    | ((error: ToolStrategyError) => Promise<string> | string);\n}\n\nexport function toolStrategy<T extends InteropZodType<any>>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function toolStrategy<T extends readonly InteropZodType<any>[]>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<\n  { [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never }[number]\n>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\n\n/**\n * Creates a tool strategy for structured output using function calling.\n *\n * This function configures structured output by converting schemas into function tools that\n * the model calls. Unlike `providerStrategy`, which uses native JSON schema support,\n * `toolStrategy` works with any model that supports function calling, making it more\n * widely compatible across providers and model versions.\n *\n * The model will call a function with arguments matching your schema, and the agent will\n * extract and validate the structured output from the tool call. This approach is automatically\n * used when your model doesn't support native JSON schema output.\n *\n * @param responseFormat - The schema(s) to enforce. Can be a single Zod schema, an array of Zod schemas,\n *   a JSON schema object, or an array of JSON schema objects.\n * @param options - Optional configuration for the tool strategy\n * @param options.handleError - How to handle errors when the model calls multiple structured output tools\n *   or when the output doesn't match the schema. Defaults to `true` (auto-retry). Can be `false` (throw),\n *   a `string` (retry with message), or a `function` (custom handler).\n * @param options.toolMessageContent - Custom message content to include in conversation history\n *   when structured output is generated via tool call\n * @returns A `TypedToolStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { toolStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: toolStrategy(\n *     z.object({\n *       answer: z.string(),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Multiple schemas - model can choose which one to use\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: toolStrategy([\n *     z.object({ name: z.string(), age: z.number() }),\n *     z.object({ email: z.string(), phone: z.string() }),\n *   ]),\n * });\n * ```\n */\nexport function toolStrategy(\n  responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy {\n  return transformResponseFormat(responseFormat, options) as TypedToolStrategy;\n}\n\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport function providerStrategy<T extends InteropZodType<unknown>>(\n  responseFormat: T | { schema: T; strict?: boolean }\n): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function providerStrategy(\n  responseFormat:\n    | JsonSchemaFormat\n    | { schema: JsonSchemaFormat; strict?: boolean }\n): ProviderStrategy<Record<string, unknown>>;\nexport function providerStrategy(\n  responseFormat:\n    | InteropZodType<unknown>\n    | JsonSchemaFormat\n    | { schema: InteropZodType<unknown> | JsonSchemaFormat; strict?: boolean }\n): ProviderStrategy<unknown> {\n  /**\n   * Handle options object format\n   */\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"schema\" in responseFormat &&\n    !isInteropZodSchema(responseFormat) &&\n    !(\"type\" in responseFormat)\n  ) {\n    const { schema, strict: strictFlag } = responseFormat as {\n      schema: InteropZodType<unknown> | JsonSchemaFormat;\n      strict?: boolean;\n    };\n    return ProviderStrategy.fromSchema(\n      schema as InteropZodType<unknown>,\n      strictFlag\n    ) as ProviderStrategy<unknown>;\n  }\n\n  /**\n   * Handle direct schema format\n   */\n  return ProviderStrategy.fromSchema(\n    responseFormat as InteropZodType<unknown>\n  ) as ProviderStrategy<unknown>;\n}\n\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n  type:\n    | \"null\"\n    | \"boolean\"\n    | \"object\"\n    | \"array\"\n    | \"number\"\n    | \"string\"\n    | \"integer\";\n  properties?: Record<string, unknown>;\n  required?: string[];\n  additionalProperties?: boolean;\n  [key: string]: unknown;\n} & {\n  // Brand to ensure this is not a ToolStrategy or ProviderStrategy\n  __brand?: never;\n};\n\nconst CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [\"ChatOpenAI\", \"ChatXAI\"];\nconst MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [\n  \"grok\",\n  \"gpt-5\",\n  \"gpt-4.1\",\n  \"gpt-4o\",\n  \"gpt-oss\",\n  \"o3-pro\",\n  \"o3-mini\",\n];\n\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport function hasSupportForJsonSchemaOutput(\n  model?: LanguageModelLike | string\n): boolean {\n  if (!model) {\n    return false;\n  }\n\n  if (typeof model === \"string\") {\n    const modelName = model.split(\":\").pop() as string;\n    return MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(\n      (modelNameSnippet) => modelName.includes(modelNameSnippet)\n    );\n  }\n\n  if (isConfigurableModel(model)) {\n    const configurableModel = model as unknown as {\n      _defaultConfig: { model: string };\n    };\n    return hasSupportForJsonSchemaOutput(\n      configurableModel._defaultConfig.model\n    );\n  }\n\n  if (!isBaseChatModel(model)) {\n    return false;\n  }\n\n  const chatModelClass = model.getName();\n\n  /**\n   * for testing purposes only\n   */\n  if (chatModelClass === \"FakeToolCallingChatModel\") {\n    return true;\n  }\n\n  if (\n    CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) &&\n    /**\n     * OpenAI models\n     */ ((\"model\" in model &&\n      MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(\n        (modelNameSnippet) =>\n          typeof model.model === \"string\" &&\n          model.model.includes(modelNameSnippet)\n      )) ||\n      /**\n       * for testing purposes only\n       */\n      (chatModelClass === \"FakeToolCallingModel\" &&\n        \"structuredResponse\" in model))\n  ) {\n    return true;\n  }\n\n  return false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"responses.js","names":["schema: Record<string, unknown>","tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    }","options?: ToolStrategyOptions","schema: InteropZodObject | Record<string, unknown>","outputOptions?: ToolStrategyOptions","name?: string","asJsonSchema","tool","functionDefinition: FunctionDefinition","toolArgs: Record<string, unknown>","schemaOrOptions:\n      | Record<string, unknown>\n      | { schema: Record<string, unknown>; strict?: boolean }","strict?: boolean","schema: InteropZodType<T> | Record<string, unknown>","response: AIMessage","textContent: string | undefined","responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined","model?: LanguageModelLike | string","responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]","responseFormat:\n    | InteropZodType<unknown>\n    | JsonSchemaFormat\n    | { schema: InteropZodType<unknown> | JsonSchemaFormat; strict?: boolean }"],"sources":["../../src/agents/responses.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  InteropZodObject,\n  isInteropZodSchema,\n  InteropZodType,\n  isInteropZodObject,\n} from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { toJsonSchema, Validator } from \"@langchain/core/utils/json_schema\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\n\nimport {\n  StructuredOutputParsingError,\n  MultipleStructuredOutputsError,\n} from \"./errors.js\";\nimport { isConfigurableModel, isBaseChatModel } from \"./model.js\";\n\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n  __responseFormatUndefined: true;\n};\n\n/**\n * Default value for strict mode in providerStrategy.\n *\n * When using providerStrategy with json_schema response format, OpenAI's parse() method\n * requires all function tools to have strict: true. This ensures the model's output\n * exactly matches the provided JSON schema.\n *\n * @see https://platform.openai.com/docs/guides/structured-outputs\n */\nconst PROVIDER_STRATEGY_DEFAULT_STRICT = true;\n\n/**\n * This is a global counter for generating unique names for tools.\n */\nlet bindingIdentifier = 0;\n\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport class ToolStrategy<_T = unknown> {\n  private constructor(\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    public readonly schema: Record<string, unknown>,\n\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    public readonly tool: {\n      type: \"function\";\n      function: FunctionDefinition;\n    },\n\n    /**\n     * The options to use for the tool output.\n     */\n    public readonly options?: ToolStrategyOptions\n  ) {}\n\n  get name() {\n    return this.tool.function.name;\n  }\n\n  static fromSchema<S extends InteropZodObject>(\n    schema: S,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n\n  static fromSchema(\n    schema: Record<string, unknown>,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<Record<string, unknown>>;\n\n  static fromSchema(\n    schema: InteropZodObject | Record<string, unknown>,\n    outputOptions?: ToolStrategyOptions\n  ): ToolStrategy<any> {\n    /**\n     * It is required for tools to have a name so we can map the tool call to the correct tool\n     * when parsing the response.\n     */\n    function getFunctionName(name?: string) {\n      return name ?? `extract-${++bindingIdentifier}`;\n    }\n\n    if (isInteropZodSchema(schema)) {\n      const asJsonSchema = toJsonSchema(schema);\n      const tool = {\n        type: \"function\" as const,\n        function: {\n          name: getFunctionName(asJsonSchema.title),\n          strict: false,\n          description:\n            asJsonSchema.description ??\n            \"Tool for extracting structured output from the model's response.\",\n          parameters: asJsonSchema,\n        },\n      };\n      return new ToolStrategy(asJsonSchema, tool, outputOptions);\n    }\n\n    let functionDefinition: FunctionDefinition;\n    if (\n      typeof schema.name === \"string\" &&\n      typeof schema.parameters === \"object\" &&\n      schema.parameters != null\n    ) {\n      functionDefinition = schema as unknown as FunctionDefinition;\n    } else {\n      functionDefinition = {\n        name: getFunctionName(schema.title as string),\n        description: (schema.description as string) ?? \"\",\n        parameters: schema.schema || (schema as Record<string, unknown>),\n      };\n    }\n    const asJsonSchema = toJsonSchema(schema);\n    const tool = {\n      type: \"function\" as const,\n      function: functionDefinition,\n    };\n    return new ToolStrategy(asJsonSchema, tool, outputOptions);\n  }\n\n  /**\n   * Parse tool arguments according to the schema.\n   *\n   * @throws {StructuredOutputParsingError} if the response is not valid\n   * @param toolArgs - The arguments from the tool call\n   * @returns The parsed response according to the schema type\n   */\n  parse(toolArgs: Record<string, unknown>): Record<string, unknown> {\n    const validator = new Validator(this.schema);\n    const result = validator.validate(toolArgs);\n    if (!result.valid) {\n      throw new StructuredOutputParsingError(\n        this.name,\n        result.errors.map((e) => e.error)\n      );\n    }\n    return toolArgs;\n  }\n}\n\nexport class ProviderStrategy<T = unknown> {\n  // @ts-expect-error - _schemaType is used only for type inference\n  private _schemaType?: T;\n\n  /**\n   * The schema to use for the provider strategy\n   */\n  public readonly schema: Record<string, unknown>;\n\n  /**\n   * Whether to use strict mode for the provider strategy\n   */\n  public readonly strict: boolean;\n\n  private constructor(options: {\n    schema: Record<string, unknown>;\n    strict?: boolean;\n  });\n  private constructor(schema: Record<string, unknown>, strict?: boolean);\n  private constructor(\n    schemaOrOptions:\n      | Record<string, unknown>\n      | { schema: Record<string, unknown>; strict?: boolean },\n    strict?: boolean\n  ) {\n    if (\n      \"schema\" in schemaOrOptions &&\n      typeof schemaOrOptions.schema === \"object\" &&\n      schemaOrOptions.schema !== null &&\n      !(\"type\" in schemaOrOptions)\n    ) {\n      const options = schemaOrOptions as {\n        schema: Record<string, unknown>;\n        strict?: boolean;\n      };\n      this.schema = options.schema;\n      this.strict = options.strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;\n    } else {\n      this.schema = schemaOrOptions as Record<string, unknown>;\n      this.strict = strict ?? PROVIDER_STRATEGY_DEFAULT_STRICT;\n    }\n  }\n\n  static fromSchema<T>(\n    schema: InteropZodType<T>,\n    strict?: boolean\n  ): ProviderStrategy<T>;\n\n  static fromSchema(\n    schema: Record<string, unknown>,\n    strict?: boolean\n  ): ProviderStrategy<Record<string, unknown>>;\n\n  static fromSchema<T = unknown>(\n    schema: InteropZodType<T> | Record<string, unknown>,\n    strict?: boolean\n  ): ProviderStrategy<T> | ProviderStrategy<Record<string, unknown>> {\n    const asJsonSchema = toJsonSchema(schema);\n    return new ProviderStrategy(asJsonSchema, strict) as\n      | ProviderStrategy<T>\n      | ProviderStrategy<Record<string, unknown>>;\n  }\n\n  /**\n   * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n   *\n   * @param response - The AI message response to parse\n   * @returns The parsed response according to the schema type\n   */\n  parse(response: AIMessage) {\n    /**\n     * Extract text content from the response.\n     * Handles both string content and array content (e.g., from thinking models).\n     */\n    let textContent: string | undefined;\n\n    if (typeof response.content === \"string\") {\n      textContent = response.content;\n    } else if (Array.isArray(response.content)) {\n      /**\n       * For thinking models, content is an array with thinking blocks and text blocks.\n       * Extract the text from text blocks.\n       */\n      for (const block of response.content) {\n        if (\n          typeof block === \"object\" &&\n          block !== null &&\n          \"type\" in block &&\n          block.type === \"text\" &&\n          \"text\" in block &&\n          typeof block.text === \"string\"\n        ) {\n          textContent = block.text;\n          break; // Use the first text block found\n        }\n      }\n    }\n\n    // Return if no valid text content found\n    if (!textContent || textContent === \"\") {\n      return;\n    }\n\n    try {\n      const content = JSON.parse(textContent);\n      const validator = new Validator(this.schema);\n      const result = validator.validate(content);\n      if (!result.valid) {\n        return;\n      }\n\n      return content;\n    } catch {\n      // no-op\n    }\n  }\n}\n\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport function transformResponseFormat(\n  responseFormat?:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[]\n    | ResponseFormat\n    | ToolStrategy<any>[]\n    | ResponseFormatUndefined,\n  options?: ToolStrategyOptions,\n  model?: LanguageModelLike | string\n): ResponseFormat[] {\n  if (!responseFormat) {\n    return [];\n  }\n\n  // Handle ResponseFormatUndefined case\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"__responseFormatUndefined\" in responseFormat\n  ) {\n    return [];\n  }\n\n  /**\n   * If users provide an array, it should only contain raw schemas (Zod or JSON schema),\n   * not ToolStrategy or ProviderStrategy instances.\n   */\n  if (Array.isArray(responseFormat)) {\n    /**\n     * if every entry is a ToolStrategy or ProviderStrategy instance, return the array as is\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          item instanceof ToolStrategy || item instanceof ProviderStrategy\n      )\n    ) {\n      return responseFormat as unknown as ResponseFormat[];\n    }\n\n    /**\n     * Check if all items are Zod schemas\n     */\n    if (responseFormat.every((item) => isInteropZodObject(item))) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as InteropZodObject, options)\n      );\n    }\n\n    /**\n     * Check if all items are plain objects (JSON schema)\n     */\n    if (\n      responseFormat.every(\n        (item) =>\n          typeof item === \"object\" && item !== null && !isInteropZodObject(item)\n      )\n    ) {\n      return responseFormat.map((item) =>\n        ToolStrategy.fromSchema(item as JsonSchemaFormat, options)\n      );\n    }\n\n    throw new Error(\n      `Invalid response format: list contains mixed types.\\n` +\n        `All items must be either InteropZodObject or plain JSON schema objects.`\n    );\n  }\n\n  if (\n    responseFormat instanceof ToolStrategy ||\n    responseFormat instanceof ProviderStrategy\n  ) {\n    return [responseFormat];\n  }\n\n  const useProviderStrategy = hasSupportForJsonSchemaOutput(model);\n\n  /**\n   * `responseFormat` is a Zod schema\n   */\n  if (isInteropZodObject(responseFormat)) {\n    return useProviderStrategy\n      ? [ProviderStrategy.fromSchema(responseFormat)]\n      : [ToolStrategy.fromSchema(responseFormat, options)];\n  }\n\n  /**\n   * Handle plain object (JSON schema)\n   */\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"properties\" in responseFormat\n  ) {\n    return useProviderStrategy\n      ? [ProviderStrategy.fromSchema(responseFormat as JsonSchemaFormat)]\n      : [ToolStrategy.fromSchema(responseFormat as JsonSchemaFormat, options)];\n  }\n\n  throw new Error(`Invalid response format: ${String(responseFormat)}`);\n}\n\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<\n  ToolStrategy<any>\n> {\n  _schemaType?: T;\n}\nexport type ToolStrategyError =\n  | StructuredOutputParsingError\n  | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n  /**\n   * Allows you to customize the message that appears in the conversation history when structured\n   * output is generated.\n   */\n  toolMessageContent?: string;\n  /**\n   * Handle errors from the structured output tool call. Using tools to generate structured output\n   * can cause errors, e.g. if:\n   * - you provide multiple structured output schemas and the model calls multiple structured output tools\n   * - if the structured output generated by the tool call doesn't match provided schema\n   *\n   * This property allows to handle these errors in different ways:\n   * - `true` - retry the tool call\n   * - `false` - throw an error\n   * - `string` - retry the tool call with the provided message\n   * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n   *\n   * @default true\n   */\n  handleError?:\n    | boolean\n    | string\n    | ((error: ToolStrategyError) => Promise<string> | string);\n}\n\nexport function toolStrategy<T extends InteropZodType<any>>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function toolStrategy<T extends readonly InteropZodType<any>[]>(\n  responseFormat: T,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<\n  { [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never }[number]\n>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat,\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\nexport function toolStrategy(\n  responseFormat: JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy<Record<string, unknown>>;\n\n/**\n * Creates a tool strategy for structured output using function calling.\n *\n * This function configures structured output by converting schemas into function tools that\n * the model calls. Unlike `providerStrategy`, which uses native JSON schema support,\n * `toolStrategy` works with any model that supports function calling, making it more\n * widely compatible across providers and model versions.\n *\n * The model will call a function with arguments matching your schema, and the agent will\n * extract and validate the structured output from the tool call. This approach is automatically\n * used when your model doesn't support native JSON schema output.\n *\n * @param responseFormat - The schema(s) to enforce. Can be a single Zod schema, an array of Zod schemas,\n *   a JSON schema object, or an array of JSON schema objects.\n * @param options - Optional configuration for the tool strategy\n * @param options.handleError - How to handle errors when the model calls multiple structured output tools\n *   or when the output doesn't match the schema. Defaults to `true` (auto-retry). Can be `false` (throw),\n *   a `string` (retry with message), or a `function` (custom handler).\n * @param options.toolMessageContent - Custom message content to include in conversation history\n *   when structured output is generated via tool call\n * @returns A `TypedToolStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { toolStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: toolStrategy(\n *     z.object({\n *       answer: z.string(),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Multiple schemas - model can choose which one to use\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: toolStrategy([\n *     z.object({ name: z.string(), age: z.number() }),\n *     z.object({ email: z.string(), phone: z.string() }),\n *   ]),\n * });\n * ```\n */\nexport function toolStrategy(\n  responseFormat:\n    | InteropZodType<any>\n    | InteropZodType<any>[]\n    | JsonSchemaFormat\n    | JsonSchemaFormat[],\n  options?: ToolStrategyOptions\n): TypedToolStrategy {\n  return transformResponseFormat(responseFormat, options) as TypedToolStrategy;\n}\n\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport function providerStrategy<T extends InteropZodType<unknown>>(\n  responseFormat: T | { schema: T; strict?: boolean }\n): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function providerStrategy(\n  responseFormat:\n    | JsonSchemaFormat\n    | { schema: JsonSchemaFormat; strict?: boolean }\n): ProviderStrategy<Record<string, unknown>>;\nexport function providerStrategy(\n  responseFormat:\n    | InteropZodType<unknown>\n    | JsonSchemaFormat\n    | { schema: InteropZodType<unknown> | JsonSchemaFormat; strict?: boolean }\n): ProviderStrategy<unknown> {\n  /**\n   * Handle options object format\n   */\n  if (\n    typeof responseFormat === \"object\" &&\n    responseFormat !== null &&\n    \"schema\" in responseFormat &&\n    !isInteropZodSchema(responseFormat) &&\n    !(\"type\" in responseFormat)\n  ) {\n    const { schema, strict: strictFlag } = responseFormat as {\n      schema: InteropZodType<unknown> | JsonSchemaFormat;\n      strict?: boolean;\n    };\n    return ProviderStrategy.fromSchema(\n      schema as InteropZodType<unknown>,\n      strictFlag\n    ) as ProviderStrategy<unknown>;\n  }\n\n  /**\n   * Handle direct schema format\n   */\n  return ProviderStrategy.fromSchema(\n    responseFormat as InteropZodType<unknown>\n  ) as ProviderStrategy<unknown>;\n}\n\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n  type:\n    | \"null\"\n    | \"boolean\"\n    | \"object\"\n    | \"array\"\n    | \"number\"\n    | \"string\"\n    | \"integer\";\n  properties?: Record<string, unknown>;\n  required?: string[];\n  additionalProperties?: boolean;\n  [key: string]: unknown;\n} & {\n  // Brand to ensure this is not a ToolStrategy or ProviderStrategy\n  __brand?: never;\n};\n\nconst CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [\"ChatOpenAI\", \"ChatXAI\"];\nconst MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [\n  \"grok\",\n  \"gpt-5\",\n  \"gpt-4.1\",\n  \"gpt-4o\",\n  \"gpt-oss\",\n  \"o3-pro\",\n  \"o3-mini\",\n];\n\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport function hasSupportForJsonSchemaOutput(\n  model?: LanguageModelLike | string\n): boolean {\n  if (!model) {\n    return false;\n  }\n\n  if (typeof model === \"string\") {\n    const modelName = model.split(\":\").pop() as string;\n    return MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(\n      (modelNameSnippet) => modelName.includes(modelNameSnippet)\n    );\n  }\n\n  if (isConfigurableModel(model)) {\n    const configurableModel = model as unknown as {\n      _defaultConfig: { model: string };\n    };\n    return hasSupportForJsonSchemaOutput(\n      configurableModel._defaultConfig.model\n    );\n  }\n\n  if (!isBaseChatModel(model)) {\n    return false;\n  }\n\n  const chatModelClass = model.getName();\n\n  /**\n   * for testing purposes only\n   */\n  if (chatModelClass === \"FakeToolCallingChatModel\") {\n    return true;\n  }\n\n  if (\n    CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) &&\n    /**\n     * OpenAI models\n     */ ((\"model\" in model &&\n      MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(\n        (modelNameSnippet) =>\n          typeof model.model === \"string\" &&\n          model.model.includes(modelNameSnippet)\n      )) ||\n      /**\n       * for testing purposes only\n       */\n      (chatModelClass === \"FakeToolCallingModel\" &&\n        \"structuredResponse\" in model))\n  ) {\n    return true;\n  }\n\n  return false;\n}\n"],"mappings":"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"}

package/dist/agents/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["stateSchema: unknown","state: Record<string, unknown>","StateSchema","result: Record<string, unknown>","message: T","AIMessage","AIMessageChunk","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","Runnable","llm: LanguageModelLike","isBaseChatModel","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","RunnableBinding","RunnableSequence","step: RunnableLike","isConfigurableModel","MultipleToolsBoundError","message?: BaseMessage","systemPrompt?: string | SystemMessage","SystemMessage","model","nextSteps: unknown[]","handlers: WrapToolCallHook[]","outer: WrapToolCallHook","inner: WrapToolCallHook","innerHandler: ToolCallHandler","middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]","wrappedHandler: WrapToolCallHook","wrappedInnerHandler: ToolCallHandler","ToolMessage","MiddlewareError"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  BaseMessageLike,\n  SystemMessage,\n  MessageContent,\n  ToolMessage,\n} from \"@langchain/core/messages\";\nimport { isCommand, StateSchema } from \"@langchain/langgraph\";\nimport {\n  type InteropZodObject,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseChatModel,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { isBaseChatModel, isConfigurableModel } from \"./model.js\";\nimport { MultipleToolsBoundError, MiddlewareError } from \"./errors.js\";\nimport type { AgentBuiltInState } from \"./runtime.js\";\nimport type {\n  ToolCallHandler,\n  AgentMiddleware,\n  ToolCallRequest,\n  WrapToolCallHook,\n} from \"./middleware/types.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\n/**\n * Parse middleware state from the full agent state based on the middleware's stateSchema.\n *\n * Handles two types of state schemas:\n * 1. Zod schemas (v3 or v4) - parsed using interopParse\n * 2. LangGraph StateSchema - extracts only the keys defined in `fields`\n *\n * @param stateSchema - The middleware's state schema (Zod or LangGraph StateSchema)\n * @param state - The full agent state to parse from\n * @returns Parsed state containing only the keys defined in the schema\n */\nfunction parseMiddlewareState(\n  stateSchema: unknown,\n  state: Record<string, unknown>\n): Record<string, unknown> {\n  // Handle LangGraph StateSchema (has `fields` property)\n  if (StateSchema.isInstance(stateSchema)) {\n    const result: Record<string, unknown> = {};\n    for (const key of Object.keys(stateSchema.fields)) {\n      if (key in state) {\n        result[key] = state[key];\n      }\n    }\n    return result;\n  }\n\n  // Handle Zod schemas using interopParse\n  if (isInteropZodSchema(stateSchema)) {\n    return interopParse(stateSchema as InteropZodObject, state);\n  }\n\n  throw new Error(`Invalid state schema type: ${typeof stateSchema}`);\n}\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) {\n    return message;\n  }\n\n  if (!message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...message.lc_kwargs,\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!AIMessage.isInstance(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    updatedName = nameMatch[1];\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\n/**\n * Helper function to check if a language model has a bindTools method.\n * @param llm - The language model to check if it has a bindTools method.\n * @returns True if the language model has a bindTools method, false otherwise.\n */\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(message?: BaseMessage): boolean {\n  return Boolean(\n    AIMessage.isInstance(message) &&\n      message.tool_calls &&\n      message.tool_calls.length > 0\n  );\n}\n\n/**\n * Normalizes a system prompt to a SystemMessage object.\n * If it's already a SystemMessage, returns it as-is.\n * If it's a string, converts it to a SystemMessage.\n * If it's undefined, creates an empty system message so it is easier to append to it later.\n */\nexport function normalizeSystemPrompt(\n  systemPrompt?: string | SystemMessage\n): SystemMessage {\n  if (systemPrompt == null) {\n    return new SystemMessage(\"\");\n  }\n  if (SystemMessage.isInstance(systemPrompt)) {\n    return systemPrompt;\n  }\n  if (typeof systemPrompt === \"string\") {\n    return new SystemMessage({\n      content: [{ type: \"text\", text: systemPrompt }],\n    });\n  }\n  throw new Error(\n    `Invalid systemPrompt type: expected string or SystemMessage, got ${typeof systemPrompt}`\n  );\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<unknown, unknown>\n  | RunnableBinding<unknown, unknown, RunnableConfig<Record<string, unknown>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(\n      await llm._getModelInstance(),\n      toolClasses,\n      options\n    );\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Compose multiple wrapToolCall handlers into a single middleware stack.\n *\n * Composes handlers so the first in the list becomes the outermost layer.\n * Each handler receives a handler callback to execute inner layers.\n *\n * @param handlers - List of handlers. First handler wraps all others.\n * @returns Composed handler, or undefined if handlers array is empty.\n *\n * @example\n * ```typescript\n * // handlers=[auth, retry] means: auth wraps retry\n * // Flow: auth calls retry, retry calls base handler\n * const auth: ToolCallWrapper = async (request, handler) => {\n *   try {\n *     return await handler(request);\n *   } catch (error) {\n *     if (error.message === \"Unauthorized\") {\n *       await refreshToken();\n *       return await handler(request);\n *     }\n *     throw error;\n *   }\n * };\n *\n * const retry: ToolCallWrapper = async (request, handler) => {\n *   for (let attempt = 0; attempt < 3; attempt++) {\n *     try {\n *       return await handler(request);\n *     } catch (error) {\n *       if (attempt === 2) throw error;\n *     }\n *   }\n *   throw new Error(\"Unreachable\");\n * };\n *\n * const composedHandler = chainToolCallHandlers([auth, retry]);\n * ```\n */\nfunction chainToolCallHandlers(\n  handlers: WrapToolCallHook[]\n): WrapToolCallHook | undefined {\n  if (handlers.length === 0) {\n    return undefined;\n  }\n\n  if (handlers.length === 1) {\n    return handlers[0];\n  }\n\n  // Compose two handlers where outer wraps inner\n  // The key is to properly propagate request modifications through the chain\n  function composeTwo(\n    outer: WrapToolCallHook,\n    inner: WrapToolCallHook\n  ): WrapToolCallHook {\n    return async (request, handler) => {\n      // Create a wrapper that calls inner with the base handler\n      // The innerHandler receives the (possibly modified) request from outer\n      // and passes it to inner, which then calls the base handler\n      const innerHandler: ToolCallHandler = async (passedRequest) => {\n        // inner receives the request passed by outer (which may be modified)\n        return inner(passedRequest, handler);\n      };\n\n      // Call outer with the wrapped inner as its handler\n      return outer(request, innerHandler);\n    };\n  }\n\n  // Compose right-to-left: outer(inner(innermost(handler)))\n  let result = handlers[handlers.length - 1];\n  for (let i = handlers.length - 2; i >= 0; i--) {\n    result = composeTwo(handlers[i], result);\n  }\n\n  return result;\n}\n\n/**\n * Wrapping `wrapToolCall` invocation so we can inject middleware name into\n * the error message.\n *\n * @param middleware list of middleware passed to the agent\n * @param state state of the agent\n * @returns single wrap function\n */\nexport function wrapToolCall(\n  middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]\n) {\n  const middlewareWithWrapToolCall = middleware.filter((m) => m.wrapToolCall);\n\n  if (middlewareWithWrapToolCall.length === 0) {\n    return;\n  }\n\n  return chainToolCallHandlers(\n    middlewareWithWrapToolCall.map((m) => {\n      const originalHandler = m.wrapToolCall!;\n      /**\n       * Wrap with error handling and validation\n       */\n      const wrappedHandler: WrapToolCallHook = async (request, handler) => {\n        /**\n         * Capture the original state for this middleware's schema parsing.\n         * This is important because the request may be modified (via override)\n         * as it passes through the middleware chain, but each middleware\n         * should always see the full original state for its schema parsing.\n         */\n        const originalState = request.state;\n\n        /**\n         * Create a handler that preserves state parsing for this middleware\n         * while allowing tool/toolCall/state modifications from inner middleware\n         */\n        const wrappedInnerHandler: ToolCallHandler = async (passedRequest) => {\n          /**\n           * Merge the passed request with the original state for parsing.\n           * This ensures middleware can override tool/toolCall while\n           * maintaining proper state parsing for each middleware in the chain.\n           */\n          const mergedState = {\n            ...originalState,\n            ...passedRequest.state,\n          };\n          return handler({\n            ...passedRequest,\n            state: mergedState,\n          });\n        };\n\n        try {\n          const result = await originalHandler(\n            {\n              ...request,\n              /**\n               * override state with the state from the specific middleware\n               */\n              state: {\n                messages: originalState.messages,\n                ...(m.stateSchema\n                  ? parseMiddlewareState(m.stateSchema, { ...originalState })\n                  : {}),\n              },\n            } as ToolCallRequest<AgentBuiltInState, unknown>,\n            wrappedInnerHandler\n          );\n\n          /**\n           * Validate return type\n           */\n          if (!ToolMessage.isInstance(result) && !isCommand(result)) {\n            throw new Error(\n              `Invalid response from \"wrapToolCall\" in middleware \"${m.name}\": ` +\n                `expected ToolMessage or Command, got ${typeof result}`\n            );\n          }\n\n          return result;\n        } catch (error) {\n          throw MiddlewareError.wrap(error, m.name);\n        }\n      };\n      return wrappedHandler;\n    })\n  );\n}\n"],"mappings":";;;;;;;;;AA0CA,MAAM,eAAe;AACrB,MAAM,kBAAkB;;;;;;;;;;;;AAaxB,SAAS,qBACPA,aACAC,OACyB;AAEzB,KAAIC,kCAAY,WAAW,YAAY,EAAE;EACvC,MAAMC,SAAkC,CAAE;AAC1C,OAAK,MAAM,OAAO,OAAO,KAAK,YAAY,OAAO,CAC/C,KAAI,OAAO,OACT,OAAO,OAAO,MAAM;AAGxB,SAAO;CACR;AAGD,0DAAuB,YAAY,CACjC,uDAAoB,aAAiC,MAAM;AAG7D,OAAM,IAAI,MAAM,CAAC,2BAA2B,EAAE,OAAO,aAAa;AACnE;;;;;;;;;;;;;;;AAkBD,SAAgB,oBACdC,SACe;AACf,KAAI,CAACC,oCAAU,WAAW,QAAQ,IAAIC,yCAAe,WAAW,QAAQ,CACtE,QAAO;AAGT,KAAI,CAAC,QAAQ,KACX,QAAO;CAGT,MAAM,EAAE,MAAM,GAAG;AAEjB,KAAI,OAAO,QAAQ,YAAY,SAC7B,QAAO,IAAID,oCAAU;EACnB,GAAG,QAAQ;EACX,SAAS,CAAC,MAAM,EAAE,KAAK,gBAAgB,EAAE,QAAQ,QAAQ,UAAU,CAAC;EACpE,MAAM;CACP;CAGH,MAAM,iBAAiB,CAAE;CACzB,IAAI,iBAAiB;AAErB,MAAK,MAAM,gBAAgB,QAAQ,QACjC,KAAI,OAAO,iBAAiB,UAAU;EACpC,kBAAkB;EAClB,eAAe,KACb,CAAC,MAAM,EAAE,KAAK,gBAAgB,EAAE,aAAa,UAAU,CAAC,CACzD;CACF,WACC,OAAO,iBAAiB,YACxB,UAAU,gBACV,aAAa,SAAS,QACtB;EACA,kBAAkB;EAClB,eAAe,KAAK;GAClB,GAAG;GACH,MAAM,CAAC,MAAM,EAAE,KAAK,gBAAgB,EAAE,aAAa,KAAK,UAAU,CAAC;EACpE,EAAC;CACH,OACC,eAAe,KAAK,aAAa;AAIrC,KAAI,CAAC,gBACH,eAAe,QAAQ;EACrB,MAAM;EACN,MAAM,CAAC,MAAM,EAAE,KAAK,0BAA0B,CAAC;CAChD,EAAC;AAEJ,QAAO,IAAIA,oCAAU;EACnB,GAAG,QAAQ;EACX,SAAS;EACT,MAAM;CACP;AACF;;;;;;;;;;;;;;;;;AAkBD,SAAgB,uBAA8CD,SAAe;AAC3E,KAAI,CAACC,oCAAU,WAAW,QAAQ,IAAI,CAAC,QAAQ,QAC7C,QAAO;CAGT,IAAIE,iBAAiC,CAAE;CACvC,IAAIC;AAEJ,KAAI,MAAM,QAAQ,QAAQ,QAAQ,EAChC,iBAAiB,QAAQ,QACtB,OAAO,CAAC,UAAU;AACjB,MAAI,MAAM,SAAS,UAAU,OAAO,MAAM,SAAS,UAAU;GAC3D,MAAM,YAAY,MAAM,KAAK,MAAM,aAAa;GAChD,MAAM,eAAe,MAAM,KAAK,MAAM,gBAAgB;AAEtD,OAAI,cAAc,CAAC,gBAAgB,aAAa,OAAO,KAAK;IAE1D,cAAc,UAAU;AACxB,WAAO;GACR;AACD,UAAO;EACR;AACD,SAAO;CACR,EAAC,CACD,IAAI,CAAC,UAAU;AACd,MAAI,MAAM,SAAS,UAAU,OAAO,MAAM,SAAS,UAAU;GAC3D,MAAM,YAAY,MAAM,KAAK,MAAM,aAAa;GAChD,MAAM,eAAe,MAAM,KAAK,MAAM,gBAAgB;AAEtD,OAAI,CAAC,aAAa,CAAC,aACjB,QAAO;GAIT,cAAc,UAAU;AAExB,UAAO;IACL,GAAG;IACH,MAAM,aAAa;GACpB;EACF;AACD,SAAO;CACR,EAAC;MACC;EACL,MAAM,UAAU,QAAQ;EACxB,MAAM,YAAY,QAAQ,MAAM,aAAa;EAC7C,MAAM,eAAe,QAAQ,MAAM,gBAAgB;AAEnD,MAAI,CAAC,aAAa,CAAC,aACjB,QAAO;EAGT,cAAc,UAAU;EACxB,iBAAiB,aAAa;CAC/B;AAED,QAAO,IAAIH,oCAAU;EACnB,GAAI,OAAO,KAAK,QAAQ,aAAa,CAAE,EAAC,CAAC,SAAS,IAC9C,QAAQ,YACR;EACJ,SAAS;EACT,MAAM;CACP;AACF;AAED,SAAgB,aACdI,MACoB;AACpB,QAAOC,oCAAS,WAAW,KAAK;AACjC;;;;;;AAOD,SAAS,0BACPC,KACmE;AACnE,KAAI,CAACC,8BAAgB,IAAI,CAAE,QAAO;AAClC,QAAO,eAAe,OAAO,OAAO,IAAI,cAAc;AACvD;;;;;;;;AASD,MAAM,mBAAmB,CACvBD,KACAE,aACAC,UAA6C,CAAE,MAC5C;AACH,KAAI,0BAA0B,IAAI,CAChC,QAAO,IAAI,UAAU,aAAa,QAAQ;AAG5C,KACEC,2CAAgB,kBAAkB,IAAI,IACtC,0BAA0B,IAAI,MAAM,EACpC;EACA,MAAM,WAAW,IAAI,MAAM,UAAU,aAAa,QAAQ;AAE1D,MAAIA,2CAAgB,kBAAkB,SAAS,CAC7C,QAAO,IAAIA,2CAAgB;GACzB,OAAO,SAAS;GAChB,QAAQ;IAAE,GAAG,IAAI;IAAQ,GAAG,SAAS;GAAQ;GAC7C,QAAQ;IAAE,GAAG,IAAI;IAAQ,GAAG,SAAS;GAAQ;GAC7C,iBAAiB,SAAS,mBAAmB,IAAI;EAClD;AAGH,SAAO,IAAIA,2CAAgB;GACzB,OAAO;GACP,QAAQ,IAAI;GACZ,QAAQ,IAAI;GACZ,iBAAiB,IAAI;EACtB;CACF;AAED,QAAO;AACR;;;;;;;AAQD,SAAgB,2BAA2BJ,KAA8B;;;;AAIvE,KAAI,OAAO,QAAQ,WACjB;CAGF,IAAI,QAAQ;;;;AAKZ,KAAIK,4CAAiB,mBAAmB,MAAM,EAC5C,QACE,MAAM,MAAM,KAAK,CAACC,SAChBF,2CAAgB,kBAAkB,KAAK,CACxC,IAAI;;;;AAMT,KAAIG,kCAAoB,MAAM;;;;AAI5B;;;;AAMF,KAAIH,2CAAgB,kBAAkB,MAAM,EAAE;EAC5C,MAAM,mBACJ,MAAM,UAAU,QAChB,OAAO,MAAM,WAAW,YACxB,WAAW,MAAM,UACjB,MAAM,QAAQ,MAAM,OAAO,MAAM,IACjC,MAAM,OAAO,MAAM,SAAS;EAE9B,MAAM,mBACJ,MAAM,UAAU,QAChB,OAAO,MAAM,WAAW,YACxB,WAAW,MAAM,UACjB,MAAM,QAAQ,MAAM,OAAO,MAAM,IACjC,MAAM,OAAO,MAAM,SAAS;AAE9B,MAAI,oBAAoB,iBACtB,OAAM,IAAII;CAEb;;;;AAKD,KACE,WAAW,SACX,MAAM,UAAU,UAChB,MAAM,QAAQ,MAAM,MAAM,IAC1B,MAAM,MAAM,SAAS,EAErB,OAAM,IAAIA;AAEb;;;;;;;AAQD,SAAgB,aAAaC,SAAgC;AAC3D,QAAO,QACLf,oCAAU,WAAW,QAAQ,IAC3B,QAAQ,cACR,QAAQ,WAAW,SAAS,EAC/B;AACF;;;;;;;AAQD,SAAgB,sBACdgB,cACe;AACf,KAAI,gBAAgB,KAClB,QAAO,IAAIC,wCAAc;AAE3B,KAAIA,wCAAc,WAAW,aAAa,CACxC,QAAO;AAET,KAAI,OAAO,iBAAiB,SAC1B,QAAO,IAAIA,wCAAc,EACvB,SAAS,CAAC;EAAE,MAAM;EAAQ,MAAM;CAAc,CAAC,EAChD;AAEH,OAAM,IAAI,MACR,CAAC,iEAAiE,EAAE,OAAO,cAAc;AAE5F;;;;;;;;AASD,eAAsB,UACpBX,KACAE,aACAC,UAA6C,CAAE,GAK/C;CACA,MAAM,QAAQ,iBAAiB,KAAK,aAAa,QAAQ;AACzD,KAAI,MAAO,QAAO;AAElB,KAAII,kCAAoB,IAAI,EAAE;EAC5B,MAAMK,UAAQ,iBACZ,MAAM,IAAI,mBAAmB,EAC7B,aACA,QACD;AACD,MAAIA,QAAO,QAAOA;CACnB;AAED,KAAIP,4CAAiB,mBAAmB,IAAI,EAAE;EAC5C,MAAM,YAAY,IAAI,MAAM,UAC1B,CAAC,SACCD,2CAAgB,kBAAkB,KAAK,IACvCH,8BAAgB,KAAK,IACrBM,kCAAoB,KAAK,CAC5B;AAED,MAAI,aAAa,GAAG;GAClB,MAAMK,UAAQ,iBACZ,IAAI,MAAM,YACV,aACA,QACD;AACD,OAAIA,SAAO;IACT,MAAMC,YAAuB,IAAI,MAAM,OAAO;IAC9C,UAAU,OAAO,WAAW,GAAGD,QAAM;AAErC,WAAOP,4CAAiB,KACtB,UACD;GACF;EACF;CACF;AAED,OAAM,IAAI,MAAM,CAAC,IAAI,EAAE,IAAI,8BAA8B,CAAC;AAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCD,SAAS,sBACPS,UAC8B;AAC9B,KAAI,SAAS,WAAW,EACtB,QAAO;AAGT,KAAI,SAAS,WAAW,EACtB,QAAO,SAAS;CAKlB,SAAS,WACPC,OACAC,OACkB;AAClB,SAAO,OAAO,SAAS,YAAY;GAIjC,MAAMC,eAAgC,OAAO,kBAAkB;AAE7D,WAAO,MAAM,eAAe,QAAQ;GACrC;AAGD,UAAO,MAAM,SAAS,aAAa;EACpC;CACF;CAGD,IAAI,SAAS,SAAS,SAAS,SAAS;AACxC,MAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KACxC,SAAS,WAAW,SAAS,IAAI,OAAO;AAG1C,QAAO;AACR;;;;;;;;;AAUD,SAAgB,aACdC,YACA;CACA,MAAM,6BAA6B,WAAW,OAAO,CAAC,MAAM,EAAE,aAAa;AAE3E,KAAI,2BAA2B,WAAW,EACxC;AAGF,QAAO,sBACL,2BAA2B,IAAI,CAAC,MAAM;EACpC,MAAM,kBAAkB,EAAE;;;;EAI1B,MAAMC,iBAAmC,OAAO,SAAS,YAAY;;;;;;;GAOnE,MAAM,gBAAgB,QAAQ;;;;;GAM9B,MAAMC,sBAAuC,OAAO,kBAAkB;;;;;;IAMpE,MAAM,cAAc;KAClB,GAAG;KACH,GAAG,cAAc;IAClB;AACD,WAAO,QAAQ;KACb,GAAG;KACH,OAAO;IACR,EAAC;GACH;AAED,OAAI;IACF,MAAM,SAAS,MAAM,gBACnB;KACE,GAAG;KAIH,OAAO;MACL,UAAU,cAAc;MACxB,GAAI,EAAE,cACF,qBAAqB,EAAE,aAAa,EAAE,GAAG,cAAe,EAAC,GACzD,CAAE;KACP;IACF,GACD,oBACD;;;;AAKD,QAAI,CAACC,sCAAY,WAAW,OAAO,IAAI,sCAAW,OAAO,CACvD,OAAM,IAAI,MACR,CAAC,oDAAoD,EAAE,EAAE,KAAK,wCAAG,EACvB,OAAO,QAAQ;AAI7D,WAAO;GACR,SAAQ,OAAO;AACd,UAAMC,+BAAgB,KAAK,OAAO,EAAE,KAAK;GAC1C;EACF;AACD,SAAO;CACR,EAAC,CACH;AACF"}
+{"version":3,"file":"utils.cjs","names":["stateSchema: unknown","state: Record<string, unknown>","StateSchema","result: Record<string, unknown>","message: T","AIMessage","AIMessageChunk","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","Runnable","llm: LanguageModelLike","isBaseChatModel","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","RunnableBinding","RunnableSequence","step: RunnableLike","isConfigurableModel","MultipleToolsBoundError","message?: BaseMessage","systemPrompt?: string | SystemMessage","SystemMessage","model","nextSteps: unknown[]","handlers: WrapToolCallHook[]","outer: WrapToolCallHook","inner: WrapToolCallHook","innerHandler: ToolCallHandler","middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]","wrappedHandler: WrapToolCallHook","wrappedInnerHandler: ToolCallHandler","ToolMessage","MiddlewareError"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  BaseMessageLike,\n  SystemMessage,\n  MessageContent,\n  ToolMessage,\n} from \"@langchain/core/messages\";\nimport { isCommand, StateSchema } from \"@langchain/langgraph\";\nimport {\n  type InteropZodObject,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseChatModel,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { isBaseChatModel, isConfigurableModel } from \"./model.js\";\nimport { MultipleToolsBoundError, MiddlewareError } from \"./errors.js\";\nimport type { AgentBuiltInState } from \"./runtime.js\";\nimport type {\n  ToolCallHandler,\n  AgentMiddleware,\n  ToolCallRequest,\n  WrapToolCallHook,\n} from \"./middleware/types.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\n/**\n * Parse middleware state from the full agent state based on the middleware's stateSchema.\n *\n * Handles two types of state schemas:\n * 1. Zod schemas (v3 or v4) - parsed using interopParse\n * 2. LangGraph StateSchema - extracts only the keys defined in `fields`\n *\n * @param stateSchema - The middleware's state schema (Zod or LangGraph StateSchema)\n * @param state - The full agent state to parse from\n * @returns Parsed state containing only the keys defined in the schema\n */\nfunction parseMiddlewareState(\n  stateSchema: unknown,\n  state: Record<string, unknown>\n): Record<string, unknown> {\n  // Handle LangGraph StateSchema (has `fields` property)\n  if (StateSchema.isInstance(stateSchema)) {\n    const result: Record<string, unknown> = {};\n    for (const key of Object.keys(stateSchema.fields)) {\n      if (key in state) {\n        result[key] = state[key];\n      }\n    }\n    return result;\n  }\n\n  // Handle Zod schemas using interopParse\n  if (isInteropZodSchema(stateSchema)) {\n    return interopParse(stateSchema as InteropZodObject, state);\n  }\n\n  throw new Error(`Invalid state schema type: ${typeof stateSchema}`);\n}\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) {\n    return message;\n  }\n\n  if (!message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...message.lc_kwargs,\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!AIMessage.isInstance(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    updatedName = nameMatch[1];\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\n/**\n * Helper function to check if a language model has a bindTools method.\n * @param llm - The language model to check if it has a bindTools method.\n * @returns True if the language model has a bindTools method, false otherwise.\n */\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(message?: BaseMessage): boolean {\n  return Boolean(\n    AIMessage.isInstance(message) &&\n    message.tool_calls &&\n    message.tool_calls.length > 0\n  );\n}\n\n/**\n * Normalizes a system prompt to a SystemMessage object.\n * If it's already a SystemMessage, returns it as-is.\n * If it's a string, converts it to a SystemMessage.\n * If it's undefined, creates an empty system message so it is easier to append to it later.\n */\nexport function normalizeSystemPrompt(\n  systemPrompt?: string | SystemMessage\n): SystemMessage {\n  if (systemPrompt == null) {\n    return new SystemMessage(\"\");\n  }\n  if (SystemMessage.isInstance(systemPrompt)) {\n    return systemPrompt;\n  }\n  if (typeof systemPrompt === \"string\") {\n    return new SystemMessage({\n      content: [{ type: \"text\", text: systemPrompt }],\n    });\n  }\n  throw new Error(\n    `Invalid systemPrompt type: expected string or SystemMessage, got ${typeof systemPrompt}`\n  );\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<unknown, unknown>\n  | RunnableBinding<unknown, unknown, RunnableConfig<Record<string, unknown>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(\n      await llm._getModelInstance(),\n      toolClasses,\n      options\n    );\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Compose multiple wrapToolCall handlers into a single middleware stack.\n *\n * Composes handlers so the first in the list becomes the outermost layer.\n * Each handler receives a handler callback to execute inner layers.\n *\n * @param handlers - List of handlers. First handler wraps all others.\n * @returns Composed handler, or undefined if handlers array is empty.\n *\n * @example\n * ```typescript\n * // handlers=[auth, retry] means: auth wraps retry\n * // Flow: auth calls retry, retry calls base handler\n * const auth: ToolCallWrapper = async (request, handler) => {\n *   try {\n *     return await handler(request);\n *   } catch (error) {\n *     if (error.message === \"Unauthorized\") {\n *       await refreshToken();\n *       return await handler(request);\n *     }\n *     throw error;\n *   }\n * };\n *\n * const retry: ToolCallWrapper = async (request, handler) => {\n *   for (let attempt = 0; attempt < 3; attempt++) {\n *     try {\n *       return await handler(request);\n *     } catch (error) {\n *       if (attempt === 2) throw error;\n *     }\n *   }\n *   throw new Error(\"Unreachable\");\n * };\n *\n * const composedHandler = chainToolCallHandlers([auth, retry]);\n * ```\n */\nfunction chainToolCallHandlers(\n  handlers: WrapToolCallHook[]\n): WrapToolCallHook | undefined {\n  if (handlers.length === 0) {\n    return undefined;\n  }\n\n  if (handlers.length === 1) {\n    return handlers[0];\n  }\n\n  // Compose two handlers where outer wraps inner\n  // The key is to properly propagate request modifications through the chain\n  function composeTwo(\n    outer: WrapToolCallHook,\n    inner: WrapToolCallHook\n  ): WrapToolCallHook {\n    return async (request, handler) => {\n      // Create a wrapper that calls inner with the base handler\n      // The innerHandler receives the (possibly modified) request from outer\n      // and passes it to inner, which then calls the base handler\n      const innerHandler: ToolCallHandler = async (passedRequest) => {\n        // inner receives the request passed by outer (which may be modified)\n        return inner(passedRequest, handler);\n      };\n\n      // Call outer with the wrapped inner as its handler\n      return outer(request, innerHandler);\n    };\n  }\n\n  // Compose right-to-left: outer(inner(innermost(handler)))\n  let result = handlers[handlers.length - 1];\n  for (let i = handlers.length - 2; i >= 0; i--) {\n    result = composeTwo(handlers[i], result);\n  }\n\n  return result;\n}\n\n/**\n * Wrapping `wrapToolCall` invocation so we can inject middleware name into\n * the error message.\n *\n * @param middleware list of middleware passed to the agent\n * @param state state of the agent\n * @returns single wrap function\n */\nexport function wrapToolCall(\n  middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]\n) {\n  const middlewareWithWrapToolCall = middleware.filter((m) => m.wrapToolCall);\n\n  if (middlewareWithWrapToolCall.length === 0) {\n    return;\n  }\n\n  return chainToolCallHandlers(\n    middlewareWithWrapToolCall.map((m) => {\n      const originalHandler = m.wrapToolCall!;\n      /**\n       * Wrap with error handling and validation\n       */\n      const wrappedHandler: WrapToolCallHook = async (request, handler) => {\n        /**\n         * Capture the original state for this middleware's schema parsing.\n         * This is important because the request may be modified (via override)\n         * as it passes through the middleware chain, but each middleware\n         * should always see the full original state for its schema parsing.\n         */\n        const originalState = request.state;\n\n        /**\n         * Create a handler that preserves state parsing for this middleware\n         * while allowing tool/toolCall/state modifications from inner middleware\n         */\n        const wrappedInnerHandler: ToolCallHandler = async (passedRequest) => {\n          /**\n           * Merge the passed request with the original state for parsing.\n           * This ensures middleware can override tool/toolCall while\n           * maintaining proper state parsing for each middleware in the chain.\n           */\n          const mergedState = {\n            ...originalState,\n            ...passedRequest.state,\n          };\n          return handler({\n            ...passedRequest,\n            state: mergedState,\n          });\n        };\n\n        try {\n          const result = await originalHandler(\n            {\n              ...request,\n              /**\n               * override state with the state from the specific middleware\n               */\n              state: {\n                messages: originalState.messages,\n                ...(m.stateSchema\n                  ? parseMiddlewareState(m.stateSchema, { ...originalState })\n                  : {}),\n              },\n            } as ToolCallRequest<AgentBuiltInState, unknown>,\n            wrappedInnerHandler\n          );\n\n          /**\n           * Validate return type\n           */\n          if (!ToolMessage.isInstance(result) && !isCommand(result)) {\n            throw new Error(\n              `Invalid response from \"wrapToolCall\" in middleware \"${m.name}\": ` +\n                `expected ToolMessage or Command, got ${typeof result}`\n            );\n          }\n\n          return result;\n        } catch (error) {\n          throw MiddlewareError.wrap(error, m.name);\n        }\n      };\n      return wrappedHandler;\n    })\n  );\n}\n"],"mappings":"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"}

package/dist/agents/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["stateSchema: unknown","state: Record<string, unknown>","result: Record<string, unknown>","message: T","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","llm: LanguageModelLike","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","step: RunnableLike","message?: BaseMessage","systemPrompt?: string | SystemMessage","model","nextSteps: unknown[]","handlers: WrapToolCallHook[]","outer: WrapToolCallHook","inner: WrapToolCallHook","innerHandler: ToolCallHandler","middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]","wrappedHandler: WrapToolCallHook","wrappedInnerHandler: ToolCallHandler"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  BaseMessageLike,\n  SystemMessage,\n  MessageContent,\n  ToolMessage,\n} from \"@langchain/core/messages\";\nimport { isCommand, StateSchema } from \"@langchain/langgraph\";\nimport {\n  type InteropZodObject,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseChatModel,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { isBaseChatModel, isConfigurableModel } from \"./model.js\";\nimport { MultipleToolsBoundError, MiddlewareError } from \"./errors.js\";\nimport type { AgentBuiltInState } from \"./runtime.js\";\nimport type {\n  ToolCallHandler,\n  AgentMiddleware,\n  ToolCallRequest,\n  WrapToolCallHook,\n} from \"./middleware/types.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\n/**\n * Parse middleware state from the full agent state based on the middleware's stateSchema.\n *\n * Handles two types of state schemas:\n * 1. Zod schemas (v3 or v4) - parsed using interopParse\n * 2. LangGraph StateSchema - extracts only the keys defined in `fields`\n *\n * @param stateSchema - The middleware's state schema (Zod or LangGraph StateSchema)\n * @param state - The full agent state to parse from\n * @returns Parsed state containing only the keys defined in the schema\n */\nfunction parseMiddlewareState(\n  stateSchema: unknown,\n  state: Record<string, unknown>\n): Record<string, unknown> {\n  // Handle LangGraph StateSchema (has `fields` property)\n  if (StateSchema.isInstance(stateSchema)) {\n    const result: Record<string, unknown> = {};\n    for (const key of Object.keys(stateSchema.fields)) {\n      if (key in state) {\n        result[key] = state[key];\n      }\n    }\n    return result;\n  }\n\n  // Handle Zod schemas using interopParse\n  if (isInteropZodSchema(stateSchema)) {\n    return interopParse(stateSchema as InteropZodObject, state);\n  }\n\n  throw new Error(`Invalid state schema type: ${typeof stateSchema}`);\n}\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) {\n    return message;\n  }\n\n  if (!message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...message.lc_kwargs,\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!AIMessage.isInstance(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    updatedName = nameMatch[1];\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\n/**\n * Helper function to check if a language model has a bindTools method.\n * @param llm - The language model to check if it has a bindTools method.\n * @returns True if the language model has a bindTools method, false otherwise.\n */\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(message?: BaseMessage): boolean {\n  return Boolean(\n    AIMessage.isInstance(message) &&\n      message.tool_calls &&\n      message.tool_calls.length > 0\n  );\n}\n\n/**\n * Normalizes a system prompt to a SystemMessage object.\n * If it's already a SystemMessage, returns it as-is.\n * If it's a string, converts it to a SystemMessage.\n * If it's undefined, creates an empty system message so it is easier to append to it later.\n */\nexport function normalizeSystemPrompt(\n  systemPrompt?: string | SystemMessage\n): SystemMessage {\n  if (systemPrompt == null) {\n    return new SystemMessage(\"\");\n  }\n  if (SystemMessage.isInstance(systemPrompt)) {\n    return systemPrompt;\n  }\n  if (typeof systemPrompt === \"string\") {\n    return new SystemMessage({\n      content: [{ type: \"text\", text: systemPrompt }],\n    });\n  }\n  throw new Error(\n    `Invalid systemPrompt type: expected string or SystemMessage, got ${typeof systemPrompt}`\n  );\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<unknown, unknown>\n  | RunnableBinding<unknown, unknown, RunnableConfig<Record<string, unknown>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(\n      await llm._getModelInstance(),\n      toolClasses,\n      options\n    );\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Compose multiple wrapToolCall handlers into a single middleware stack.\n *\n * Composes handlers so the first in the list becomes the outermost layer.\n * Each handler receives a handler callback to execute inner layers.\n *\n * @param handlers - List of handlers. First handler wraps all others.\n * @returns Composed handler, or undefined if handlers array is empty.\n *\n * @example\n * ```typescript\n * // handlers=[auth, retry] means: auth wraps retry\n * // Flow: auth calls retry, retry calls base handler\n * const auth: ToolCallWrapper = async (request, handler) => {\n *   try {\n *     return await handler(request);\n *   } catch (error) {\n *     if (error.message === \"Unauthorized\") {\n *       await refreshToken();\n *       return await handler(request);\n *     }\n *     throw error;\n *   }\n * };\n *\n * const retry: ToolCallWrapper = async (request, handler) => {\n *   for (let attempt = 0; attempt < 3; attempt++) {\n *     try {\n *       return await handler(request);\n *     } catch (error) {\n *       if (attempt === 2) throw error;\n *     }\n *   }\n *   throw new Error(\"Unreachable\");\n * };\n *\n * const composedHandler = chainToolCallHandlers([auth, retry]);\n * ```\n */\nfunction chainToolCallHandlers(\n  handlers: WrapToolCallHook[]\n): WrapToolCallHook | undefined {\n  if (handlers.length === 0) {\n    return undefined;\n  }\n\n  if (handlers.length === 1) {\n    return handlers[0];\n  }\n\n  // Compose two handlers where outer wraps inner\n  // The key is to properly propagate request modifications through the chain\n  function composeTwo(\n    outer: WrapToolCallHook,\n    inner: WrapToolCallHook\n  ): WrapToolCallHook {\n    return async (request, handler) => {\n      // Create a wrapper that calls inner with the base handler\n      // The innerHandler receives the (possibly modified) request from outer\n      // and passes it to inner, which then calls the base handler\n      const innerHandler: ToolCallHandler = async (passedRequest) => {\n        // inner receives the request passed by outer (which may be modified)\n        return inner(passedRequest, handler);\n      };\n\n      // Call outer with the wrapped inner as its handler\n      return outer(request, innerHandler);\n    };\n  }\n\n  // Compose right-to-left: outer(inner(innermost(handler)))\n  let result = handlers[handlers.length - 1];\n  for (let i = handlers.length - 2; i >= 0; i--) {\n    result = composeTwo(handlers[i], result);\n  }\n\n  return result;\n}\n\n/**\n * Wrapping `wrapToolCall` invocation so we can inject middleware name into\n * the error message.\n *\n * @param middleware list of middleware passed to the agent\n * @param state state of the agent\n * @returns single wrap function\n */\nexport function wrapToolCall(\n  middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]\n) {\n  const middlewareWithWrapToolCall = middleware.filter((m) => m.wrapToolCall);\n\n  if (middlewareWithWrapToolCall.length === 0) {\n    return;\n  }\n\n  return chainToolCallHandlers(\n    middlewareWithWrapToolCall.map((m) => {\n      const originalHandler = m.wrapToolCall!;\n      /**\n       * Wrap with error handling and validation\n       */\n      const wrappedHandler: WrapToolCallHook = async (request, handler) => {\n        /**\n         * Capture the original state for this middleware's schema parsing.\n         * This is important because the request may be modified (via override)\n         * as it passes through the middleware chain, but each middleware\n         * should always see the full original state for its schema parsing.\n         */\n        const originalState = request.state;\n\n        /**\n         * Create a handler that preserves state parsing for this middleware\n         * while allowing tool/toolCall/state modifications from inner middleware\n         */\n        const wrappedInnerHandler: ToolCallHandler = async (passedRequest) => {\n          /**\n           * Merge the passed request with the original state for parsing.\n           * This ensures middleware can override tool/toolCall while\n           * maintaining proper state parsing for each middleware in the chain.\n           */\n          const mergedState = {\n            ...originalState,\n            ...passedRequest.state,\n          };\n          return handler({\n            ...passedRequest,\n            state: mergedState,\n          });\n        };\n\n        try {\n          const result = await originalHandler(\n            {\n              ...request,\n              /**\n               * override state with the state from the specific middleware\n               */\n              state: {\n                messages: originalState.messages,\n                ...(m.stateSchema\n                  ? parseMiddlewareState(m.stateSchema, { ...originalState })\n                  : {}),\n              },\n            } as ToolCallRequest<AgentBuiltInState, unknown>,\n            wrappedInnerHandler\n          );\n\n          /**\n           * Validate return type\n           */\n          if (!ToolMessage.isInstance(result) && !isCommand(result)) {\n            throw new Error(\n              `Invalid response from \"wrapToolCall\" in middleware \"${m.name}\": ` +\n                `expected ToolMessage or Command, got ${typeof result}`\n            );\n          }\n\n          return result;\n        } catch (error) {\n          throw MiddlewareError.wrap(error, m.name);\n        }\n      };\n      return wrappedHandler;\n    })\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"utils.js","names":["stateSchema: unknown","state: Record<string, unknown>","result: Record<string, unknown>","message: T","updatedContent: MessageContent","updatedName: string | undefined","tool: ClientTool | ServerTool","llm: LanguageModelLike","toolClasses: (ClientTool | ServerTool)[]","options: Partial<BaseChatModelCallOptions>","step: RunnableLike","message?: BaseMessage","systemPrompt?: string | SystemMessage","model","nextSteps: unknown[]","handlers: WrapToolCallHook[]","outer: WrapToolCallHook","inner: WrapToolCallHook","innerHandler: ToolCallHandler","middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]","wrappedHandler: WrapToolCallHook","wrappedInnerHandler: ToolCallHandler"],"sources":["../../src/agents/utils.ts"],"sourcesContent":["import {\n  AIMessage,\n  AIMessageChunk,\n  BaseMessage,\n  BaseMessageLike,\n  SystemMessage,\n  MessageContent,\n  ToolMessage,\n} from \"@langchain/core/messages\";\nimport { isCommand, StateSchema } from \"@langchain/langgraph\";\nimport {\n  type InteropZodObject,\n  interopParse,\n  isInteropZodSchema,\n} from \"@langchain/core/utils/types\";\nimport {\n  BaseChatModel,\n  type BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport {\n  LanguageModelLike,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport {\n  Runnable,\n  RunnableLike,\n  RunnableConfig,\n  RunnableSequence,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { isBaseChatModel, isConfigurableModel } from \"./model.js\";\nimport { MultipleToolsBoundError, MiddlewareError } from \"./errors.js\";\nimport type { AgentBuiltInState } from \"./runtime.js\";\nimport type {\n  ToolCallHandler,\n  AgentMiddleware,\n  ToolCallRequest,\n  WrapToolCallHook,\n} from \"./middleware/types.js\";\n\nconst NAME_PATTERN = /<name>(.*?)<\\/name>/s;\nconst CONTENT_PATTERN = /<content>(.*?)<\\/content>/s;\n\n/**\n * Parse middleware state from the full agent state based on the middleware's stateSchema.\n *\n * Handles two types of state schemas:\n * 1. Zod schemas (v3 or v4) - parsed using interopParse\n * 2. LangGraph StateSchema - extracts only the keys defined in `fields`\n *\n * @param stateSchema - The middleware's state schema (Zod or LangGraph StateSchema)\n * @param state - The full agent state to parse from\n * @returns Parsed state containing only the keys defined in the schema\n */\nfunction parseMiddlewareState(\n  stateSchema: unknown,\n  state: Record<string, unknown>\n): Record<string, unknown> {\n  // Handle LangGraph StateSchema (has `fields` property)\n  if (StateSchema.isInstance(stateSchema)) {\n    const result: Record<string, unknown> = {};\n    for (const key of Object.keys(stateSchema.fields)) {\n      if (key in state) {\n        result[key] = state[key];\n      }\n    }\n    return result;\n  }\n\n  // Handle Zod schemas using interopParse\n  if (isInteropZodSchema(stateSchema)) {\n    return interopParse(stateSchema as InteropZodObject, state);\n  }\n\n  throw new Error(`Invalid state schema type: ${typeof stateSchema}`);\n}\n\nexport type AgentNameMode = \"inline\";\n\n/**\n * Attach formatted agent names to the messages passed to and from a language model.\n *\n * This is useful for making a message history with multiple agents more coherent.\n *\n * NOTE: agent name is consumed from the message.name field.\n * If you're using an agent built with createAgent, name is automatically set.\n * If you're building a custom agent, make sure to set the name on the AI message returned by the LLM.\n *\n * @param message - Message to add agent name formatting to\n * @returns Message with agent name formatting\n *\n * @internal\n */\nexport function _addInlineAgentName<T extends BaseMessageLike>(\n  message: T\n): T | AIMessage {\n  if (!AIMessage.isInstance(message) || AIMessageChunk.isInstance(message)) {\n    return message;\n  }\n\n  if (!message.name) {\n    return message;\n  }\n\n  const { name } = message;\n\n  if (typeof message.content === \"string\") {\n    return new AIMessage({\n      ...message.lc_kwargs,\n      content: `<name>${name}</name><content>${message.content}</content>`,\n      name: undefined,\n    });\n  }\n\n  const updatedContent = [];\n  let textBlockCount = 0;\n\n  for (const contentBlock of message.content) {\n    if (typeof contentBlock === \"string\") {\n      textBlockCount += 1;\n      updatedContent.push(\n        `<name>${name}</name><content>${contentBlock}</content>`\n      );\n    } else if (\n      typeof contentBlock === \"object\" &&\n      \"type\" in contentBlock &&\n      contentBlock.type === \"text\"\n    ) {\n      textBlockCount += 1;\n      updatedContent.push({\n        ...contentBlock,\n        text: `<name>${name}</name><content>${contentBlock.text}</content>`,\n      });\n    } else {\n      updatedContent.push(contentBlock);\n    }\n  }\n\n  if (!textBlockCount) {\n    updatedContent.unshift({\n      type: \"text\",\n      text: `<name>${name}</name><content></content>`,\n    });\n  }\n  return new AIMessage({\n    ...message.lc_kwargs,\n    content: updatedContent as MessageContent,\n    name: undefined,\n  });\n}\n\n/**\n * Remove explicit name and content XML tags from the AI message content.\n *\n * Examples:\n *\n * @example\n * ```typescript\n * removeInlineAgentName(new AIMessage({ content: \"<name>assistant</name><content>Hello</content>\", name: \"assistant\" }))\n * // AIMessage with content: \"Hello\"\n *\n * removeInlineAgentName(new AIMessage({ content: [{type: \"text\", text: \"<name>assistant</name><content>Hello</content>\"}], name: \"assistant\" }))\n * // AIMessage with content: [{type: \"text\", text: \"Hello\"}]\n * ```\n *\n * @internal\n */\nexport function _removeInlineAgentName<T extends BaseMessage>(message: T): T {\n  if (!AIMessage.isInstance(message) || !message.content) {\n    return message;\n  }\n\n  let updatedContent: MessageContent = [];\n  let updatedName: string | undefined;\n\n  if (Array.isArray(message.content)) {\n    updatedContent = message.content\n      .filter((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n          // don't include empty content blocks that were added because there was no text block to modify\n          if (nameMatch && (!contentMatch || contentMatch[1] === \"\")) {\n            // capture name from text block\n            updatedName = nameMatch[1];\n            return false;\n          }\n          return true;\n        }\n        return true;\n      })\n      .map((block) => {\n        if (block.type === \"text\" && typeof block.text === \"string\") {\n          const nameMatch = block.text.match(NAME_PATTERN);\n          const contentMatch = block.text.match(CONTENT_PATTERN);\n\n          if (!nameMatch || !contentMatch) {\n            return block;\n          }\n\n          // capture name from text block\n          updatedName = nameMatch[1];\n\n          return {\n            ...block,\n            text: contentMatch[1],\n          };\n        }\n        return block;\n      });\n  } else {\n    const content = message.content as string;\n    const nameMatch = content.match(NAME_PATTERN);\n    const contentMatch = content.match(CONTENT_PATTERN);\n\n    if (!nameMatch || !contentMatch) {\n      return message;\n    }\n\n    updatedName = nameMatch[1];\n    updatedContent = contentMatch[1];\n  }\n\n  return new AIMessage({\n    ...(Object.keys(message.lc_kwargs ?? {}).length > 0\n      ? message.lc_kwargs\n      : message),\n    content: updatedContent,\n    name: updatedName,\n  }) as T;\n}\n\nexport function isClientTool(\n  tool: ClientTool | ServerTool\n): tool is ClientTool {\n  return Runnable.isRunnable(tool);\n}\n\n/**\n * Helper function to check if a language model has a bindTools method.\n * @param llm - The language model to check if it has a bindTools method.\n * @returns True if the language model has a bindTools method, false otherwise.\n */\nfunction _isChatModelWithBindTools(\n  llm: LanguageModelLike\n): llm is BaseChatModel & Required<Pick<BaseChatModel, \"bindTools\">> {\n  if (!isBaseChatModel(llm)) return false;\n  return \"bindTools\" in llm && typeof llm.bindTools === \"function\";\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nconst _simpleBindTools = (\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n) => {\n  if (_isChatModelWithBindTools(llm)) {\n    return llm.bindTools(toolClasses, options);\n  }\n\n  if (\n    RunnableBinding.isRunnableBinding(llm) &&\n    _isChatModelWithBindTools(llm.bound)\n  ) {\n    const newBound = llm.bound.bindTools(toolClasses, options);\n\n    if (RunnableBinding.isRunnableBinding(newBound)) {\n      return new RunnableBinding({\n        bound: newBound.bound,\n        config: { ...llm.config, ...newBound.config },\n        kwargs: { ...llm.kwargs, ...newBound.kwargs },\n        configFactories: newBound.configFactories ?? llm.configFactories,\n      });\n    }\n\n    return new RunnableBinding({\n      bound: newBound,\n      config: llm.config,\n      kwargs: llm.kwargs,\n      configFactories: llm.configFactories,\n    });\n  }\n\n  return null;\n};\n\n/**\n * Check if the LLM already has bound tools and throw if it does.\n *\n * @param llm - The LLM to check.\n * @returns void\n */\nexport function validateLLMHasNoBoundTools(llm: LanguageModelLike): void {\n  /**\n   * If llm is a function, we can't validate until runtime, so skip\n   */\n  if (typeof llm === \"function\") {\n    return;\n  }\n\n  let model = llm;\n\n  /**\n   * If model is a RunnableSequence, find a RunnableBinding in its steps\n   */\n  if (RunnableSequence.isRunnableSequence(model)) {\n    model =\n      model.steps.find((step: RunnableLike) =>\n        RunnableBinding.isRunnableBinding(step)\n      ) || model;\n  }\n\n  /**\n   * If model is configurable, get the underlying model\n   */\n  if (isConfigurableModel(model)) {\n    /**\n     * Can't validate async model retrieval in constructor\n     */\n    return;\n  }\n\n  /**\n   * Check if model is a RunnableBinding with bound tools\n   */\n  if (RunnableBinding.isRunnableBinding(model)) {\n    const hasToolsInKwargs =\n      model.kwargs != null &&\n      typeof model.kwargs === \"object\" &&\n      \"tools\" in model.kwargs &&\n      Array.isArray(model.kwargs.tools) &&\n      model.kwargs.tools.length > 0;\n\n    const hasToolsInConfig =\n      model.config != null &&\n      typeof model.config === \"object\" &&\n      \"tools\" in model.config &&\n      Array.isArray(model.config.tools) &&\n      model.config.tools.length > 0;\n\n    if (hasToolsInKwargs || hasToolsInConfig) {\n      throw new MultipleToolsBoundError();\n    }\n  }\n\n  /**\n   * Also check if model has tools property directly (e.g., FakeToolCallingModel)\n   */\n  if (\n    \"tools\" in model &&\n    model.tools !== undefined &&\n    Array.isArray(model.tools) &&\n    model.tools.length > 0\n  ) {\n    throw new MultipleToolsBoundError();\n  }\n}\n\n/**\n * Check if the last message in the messages array has tool calls.\n *\n * @param messages - The messages to check.\n * @returns True if the last message has tool calls, false otherwise.\n */\nexport function hasToolCalls(message?: BaseMessage): boolean {\n  return Boolean(\n    AIMessage.isInstance(message) &&\n    message.tool_calls &&\n    message.tool_calls.length > 0\n  );\n}\n\n/**\n * Normalizes a system prompt to a SystemMessage object.\n * If it's already a SystemMessage, returns it as-is.\n * If it's a string, converts it to a SystemMessage.\n * If it's undefined, creates an empty system message so it is easier to append to it later.\n */\nexport function normalizeSystemPrompt(\n  systemPrompt?: string | SystemMessage\n): SystemMessage {\n  if (systemPrompt == null) {\n    return new SystemMessage(\"\");\n  }\n  if (SystemMessage.isInstance(systemPrompt)) {\n    return systemPrompt;\n  }\n  if (typeof systemPrompt === \"string\") {\n    return new SystemMessage({\n      content: [{ type: \"text\", text: systemPrompt }],\n    });\n  }\n  throw new Error(\n    `Invalid systemPrompt type: expected string or SystemMessage, got ${typeof systemPrompt}`\n  );\n}\n\n/**\n * Helper function to bind tools to a language model.\n * @param llm - The language model to bind tools to.\n * @param toolClasses - The tools to bind to the language model.\n * @param options - The options to pass to the language model.\n * @returns The language model with the tools bound to it.\n */\nexport async function bindTools(\n  llm: LanguageModelLike,\n  toolClasses: (ClientTool | ServerTool)[],\n  options: Partial<BaseChatModelCallOptions> = {}\n): Promise<\n  | RunnableSequence<unknown, unknown>\n  | RunnableBinding<unknown, unknown, RunnableConfig<Record<string, unknown>>>\n  | Runnable<BaseLanguageModelInput, AIMessageChunk, BaseChatModelCallOptions>\n> {\n  const model = _simpleBindTools(llm, toolClasses, options);\n  if (model) return model;\n\n  if (isConfigurableModel(llm)) {\n    const model = _simpleBindTools(\n      await llm._getModelInstance(),\n      toolClasses,\n      options\n    );\n    if (model) return model;\n  }\n\n  if (RunnableSequence.isRunnableSequence(llm)) {\n    const modelStep = llm.steps.findIndex(\n      (step) =>\n        RunnableBinding.isRunnableBinding(step) ||\n        isBaseChatModel(step) ||\n        isConfigurableModel(step)\n    );\n\n    if (modelStep >= 0) {\n      const model = _simpleBindTools(\n        llm.steps[modelStep],\n        toolClasses,\n        options\n      );\n      if (model) {\n        const nextSteps: unknown[] = llm.steps.slice();\n        nextSteps.splice(modelStep, 1, model);\n\n        return RunnableSequence.from(\n          nextSteps as [RunnableLike, ...RunnableLike[], RunnableLike]\n        );\n      }\n    }\n  }\n\n  throw new Error(`llm ${llm} must define bindTools method.`);\n}\n\n/**\n * Compose multiple wrapToolCall handlers into a single middleware stack.\n *\n * Composes handlers so the first in the list becomes the outermost layer.\n * Each handler receives a handler callback to execute inner layers.\n *\n * @param handlers - List of handlers. First handler wraps all others.\n * @returns Composed handler, or undefined if handlers array is empty.\n *\n * @example\n * ```typescript\n * // handlers=[auth, retry] means: auth wraps retry\n * // Flow: auth calls retry, retry calls base handler\n * const auth: ToolCallWrapper = async (request, handler) => {\n *   try {\n *     return await handler(request);\n *   } catch (error) {\n *     if (error.message === \"Unauthorized\") {\n *       await refreshToken();\n *       return await handler(request);\n *     }\n *     throw error;\n *   }\n * };\n *\n * const retry: ToolCallWrapper = async (request, handler) => {\n *   for (let attempt = 0; attempt < 3; attempt++) {\n *     try {\n *       return await handler(request);\n *     } catch (error) {\n *       if (attempt === 2) throw error;\n *     }\n *   }\n *   throw new Error(\"Unreachable\");\n * };\n *\n * const composedHandler = chainToolCallHandlers([auth, retry]);\n * ```\n */\nfunction chainToolCallHandlers(\n  handlers: WrapToolCallHook[]\n): WrapToolCallHook | undefined {\n  if (handlers.length === 0) {\n    return undefined;\n  }\n\n  if (handlers.length === 1) {\n    return handlers[0];\n  }\n\n  // Compose two handlers where outer wraps inner\n  // The key is to properly propagate request modifications through the chain\n  function composeTwo(\n    outer: WrapToolCallHook,\n    inner: WrapToolCallHook\n  ): WrapToolCallHook {\n    return async (request, handler) => {\n      // Create a wrapper that calls inner with the base handler\n      // The innerHandler receives the (possibly modified) request from outer\n      // and passes it to inner, which then calls the base handler\n      const innerHandler: ToolCallHandler = async (passedRequest) => {\n        // inner receives the request passed by outer (which may be modified)\n        return inner(passedRequest, handler);\n      };\n\n      // Call outer with the wrapped inner as its handler\n      return outer(request, innerHandler);\n    };\n  }\n\n  // Compose right-to-left: outer(inner(innermost(handler)))\n  let result = handlers[handlers.length - 1];\n  for (let i = handlers.length - 2; i >= 0; i--) {\n    result = composeTwo(handlers[i], result);\n  }\n\n  return result;\n}\n\n/**\n * Wrapping `wrapToolCall` invocation so we can inject middleware name into\n * the error message.\n *\n * @param middleware list of middleware passed to the agent\n * @param state state of the agent\n * @returns single wrap function\n */\nexport function wrapToolCall(\n  middleware: readonly AgentMiddleware<InteropZodObject | undefined>[]\n) {\n  const middlewareWithWrapToolCall = middleware.filter((m) => m.wrapToolCall);\n\n  if (middlewareWithWrapToolCall.length === 0) {\n    return;\n  }\n\n  return chainToolCallHandlers(\n    middlewareWithWrapToolCall.map((m) => {\n      const originalHandler = m.wrapToolCall!;\n      /**\n       * Wrap with error handling and validation\n       */\n      const wrappedHandler: WrapToolCallHook = async (request, handler) => {\n        /**\n         * Capture the original state for this middleware's schema parsing.\n         * This is important because the request may be modified (via override)\n         * as it passes through the middleware chain, but each middleware\n         * should always see the full original state for its schema parsing.\n         */\n        const originalState = request.state;\n\n        /**\n         * Create a handler that preserves state parsing for this middleware\n         * while allowing tool/toolCall/state modifications from inner middleware\n         */\n        const wrappedInnerHandler: ToolCallHandler = async (passedRequest) => {\n          /**\n           * Merge the passed request with the original state for parsing.\n           * This ensures middleware can override tool/toolCall while\n           * maintaining proper state parsing for each middleware in the chain.\n           */\n          const mergedState = {\n            ...originalState,\n            ...passedRequest.state,\n          };\n          return handler({\n            ...passedRequest,\n            state: mergedState,\n          });\n        };\n\n        try {\n          const result = await originalHandler(\n            {\n              ...request,\n              /**\n               * override state with the state from the specific middleware\n               */\n              state: {\n                messages: originalState.messages,\n                ...(m.stateSchema\n                  ? parseMiddlewareState(m.stateSchema, { ...originalState })\n                  : {}),\n              },\n            } as ToolCallRequest<AgentBuiltInState, unknown>,\n            wrappedInnerHandler\n          );\n\n          /**\n           * Validate return type\n           */\n          if (!ToolMessage.isInstance(result) && !isCommand(result)) {\n            throw new Error(\n              `Invalid response from \"wrapToolCall\" in middleware \"${m.name}\": ` +\n                `expected ToolMessage or Command, got ${typeof result}`\n            );\n          }\n\n          return result;\n        } catch (error) {\n          throw MiddlewareError.wrap(error, m.name);\n        }\n      };\n      return wrappedHandler;\n    })\n  );\n}\n"],"mappings":"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"}