langchain 1.1.6-dev-1765433794876 → 1.1.6

package/dist/agents/responses.d.ts

@@ -39,15 +39,23 @@ declare class ToolStrategy<_T = unknown> {
   parse(toolArgs: Record<string, unknown>): Record<string, unknown>;
 }
 declare class ProviderStrategy<T = unknown> {
-  readonly schema: Record<string, unknown>;
   private _schemaType?;
+  /**
+   * The schema to use for the provider strategy
+   */
+  readonly schema: Record<string, unknown>;
+  /**
+   * Whether to use strict mode for the provider strategy
+   */
+  readonly strict: boolean;
+  private constructor();
   private constructor();
-  static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;
-  static fromSchema(schema: Record<string, unknown>): ProviderStrategy<Record<string, unknown>>;
+  static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;
+  static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;
   /**
    * Parse tool arguments according to the schema. If the response is not valid, return undefined.
    *
-   * @param toolArgs - The arguments from the tool call
+   * @param response - The AI message response to parse
    * @returns The parsed response according to the schema type
    */
   parse(response: AIMessage): any;
@@ -86,8 +94,61 @@ declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T,
 declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{ [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never }[number]>;
 declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
 declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;
-declare function providerStrategy<T extends InteropZodType<any>>(responseFormat: T): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;
-declare function providerStrategy(responseFormat: JsonSchemaFormat): ProviderStrategy<Record<string, unknown>>;
+/**
+ * Creates a provider strategy for structured output using native JSON schema support.
+ *
+ * This function is used to configure structured output for agents when the underlying model
+ * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).
+ * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`
+ * leverages the provider's native structured output capabilities, resulting in more efficient
+ * and reliable schema enforcement.
+ *
+ * When used with a model that supports JSON schema output, the model will return responses
+ * that directly conform to the provided schema without requiring tool calls. This is the
+ * recommended approach for structured output when your model supports it.
+ *
+ * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag
+ * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`
+ *
+ * @example
+ * ```ts
+ * import { providerStrategy, createAgent } from "langchain";
+ * import { z } from "zod";
+ *
+ * const agent = createAgent({
+ *   model: "claude-haiku-4-5",
+ *   responseFormat: providerStrategy(
+ *     z.object({
+ *       answer: z.string().describe("The answer to the question"),
+ *       confidence: z.number().min(0).max(1),
+ *     })
+ *   ),
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using strict mode for stricter schema enforcement
+ * const agent = createAgent({
+ *   model: "claude-haiku-4-5",
+ *   responseFormat: providerStrategy({
+ *     schema: z.object({
+ *       name: z.string(),
+ *       age: z.number(),
+ *     }),
+ *     strict: true
+ *   }),
+ * });
+ * ```
+ */
+declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {
+  schema: T;
+  strict?: boolean;
+}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;
+declare function providerStrategy(responseFormat: JsonSchemaFormat | {
+  schema: JsonSchemaFormat;
+  strict?: boolean;
+}): ProviderStrategy<Record<string, unknown>>;
 /**
  * Type representing a JSON Schema object format.
  * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.

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    readonly schema: Record<string, unknown>;\n    private _schemaType?;\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param toolArgs - The arguments from the tool call\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>>;\nexport declare function providerStrategy<T extends InteropZodType<any>>(responseFormat: T): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat): 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    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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"}

package/dist/agents/responses.js

@@ -74,26 +74,54 @@ var ToolStrategy = class ToolStrategy {
 };
 var ProviderStrategy = class ProviderStrategy {
 	_schemaType;
-	constructor(schema) {
-		this.schema = schema;
+	/**
+	* The schema to use for the provider strategy
+	*/
+	schema;
+	/**
+	* Whether to use strict mode for the provider strategy
+	*/
+	strict;
+	constructor(schemaOrOptions, strict) {
+		if ("schema" in schemaOrOptions && typeof schemaOrOptions.schema === "object" && schemaOrOptions.schema !== null && !("type" in schemaOrOptions)) {
+			const options = schemaOrOptions;
+			this.schema = options.schema;
+			this.strict = options.strict ?? false;
+		} else {
+			this.schema = schemaOrOptions;
+			this.strict = strict ?? false;
+		}
 	}
-	static fromSchema(schema) {
+	static fromSchema(schema, strict = false) {
 		const asJsonSchema = toJsonSchema(schema);
-		return new ProviderStrategy(asJsonSchema);
+		return new ProviderStrategy(asJsonSchema, strict);
 	}
 	/**
 	* Parse tool arguments according to the schema. If the response is not valid, return undefined.
 	*
-	* @param toolArgs - The arguments from the tool call
+	* @param response - The AI message response to parse
 	* @returns The parsed response according to the schema type
 	*/
 	parse(response) {
 		/**
-		* return if the response doesn't contain valid content
+		* Extract text content from the response.
+		* Handles both string content and array content (e.g., from thinking models).
 		*/
-		if (typeof response.content !== "string" || response.content === "") return;
+		let textContent;
+		if (typeof response.content === "string") textContent = response.content;
+		else if (Array.isArray(response.content)) {
+			/**
+			* For thinking models, content is an array with thinking blocks and text blocks.
+			* Extract the text from text blocks.
+			*/
+			for (const block of response.content) if (typeof block === "object" && block !== null && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") {
+				textContent = block.text;
+				break;
+			}
+		}
+		if (!textContent || textContent === "") return;
 		try {
-			const content = JSON.parse(response.content);
+			const content = JSON.parse(textContent);
 			const validator = new Validator(this.schema);
 			const result = validator.validate(content);
 			if (!result.valid) return;
@@ -149,18 +177,70 @@ function transformResponseFormat(responseFormat, options, model) {
 	throw new Error(`Invalid response format: ${String(responseFormat)}`);
 }
 /**
-* Define how to transform the response format from a tool call.
+* Creates a tool strategy for structured output using function calling.
+*
+* This function configures structured output by converting schemas into function tools that
+* the model calls. Unlike `providerStrategy`, which uses native JSON schema support,
+* `toolStrategy` works with any model that supports function calling, making it more
+* widely compatible across providers and model versions.
 *
-* @param responseFormat - The response format to transform
-* @param options - The options to use for the transformation
-* @param options.handleError - Whether to handle errors from the tool call
-* @returns The transformed response format
+* The model will call a function with arguments matching your schema, and the agent will
+* extract and validate the structured output from the tool call. This approach is automatically
+* used when your model doesn't support native JSON schema output.
+*
+* @param responseFormat - The schema(s) to enforce. Can be a single Zod schema, an array of Zod schemas,
+*   a JSON schema object, or an array of JSON schema objects.
+* @param options - Optional configuration for the tool strategy
+* @param options.handleError - How to handle errors when the model calls multiple structured output tools
+*   or when the output doesn't match the schema. Defaults to `true` (auto-retry). Can be `false` (throw),
+*   a `string` (retry with message), or a `function` (custom handler).
+* @param options.toolMessageContent - Custom message content to include in conversation history
+*   when structured output is generated via tool call
+* @returns A `TypedToolStrategy` instance that can be used as the `responseFormat` in `createAgent`
+*
+* @example
+* ```ts
+* import { toolStrategy, createAgent } from "langchain";
+* import { z } from "zod";
+*
+* const agent = createAgent({
+*   model: "claude-haiku-4-5",
+*   responseFormat: toolStrategy(
+*     z.object({
+*       answer: z.string(),
+*       confidence: z.number().min(0).max(1),
+*     })
+*   ),
+* });
+* ```
+*
+* @example
+* ```ts
+* // Multiple schemas - model can choose which one to use
+* const agent = createAgent({
+*   model: "claude-haiku-4-5",
+*   responseFormat: toolStrategy([
+*     z.object({ name: z.string(), age: z.number() }),
+*     z.object({ email: z.string(), phone: z.string() }),
+*   ]),
+* });
+* ```
 */
 function toolStrategy(responseFormat, options) {
 	return transformResponseFormat(responseFormat, options);
 }
 function providerStrategy(responseFormat) {
-	return ProviderStrategy.fromSchema(responseFormat);
+	/**
+	* Handle options object format
+	*/
+	if (typeof responseFormat === "object" && responseFormat !== null && "schema" in responseFormat && !isInteropZodSchema(responseFormat) && !("type" in responseFormat)) {
+		const { schema, strict: strictFlag } = responseFormat;
+		return ProviderStrategy.fromSchema(schema, strictFlag ?? false);
+	}
+	/**
+	* Handle direct schema format
+	*/
+	return ProviderStrategy.fromSchema(responseFormat, false);
 }
 const CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = ["ChatOpenAI", "ChatXAI"];
 const MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [

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>","schema: InteropZodType<T> | Record<string, unknown>","response: AIMessage","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: InteropZodType<any> | JsonSchemaFormat"],"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 * 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(),\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  private constructor(public readonly schema: Record<string, unknown>) {}\n\n  static fromSchema<T>(schema: InteropZodType<T>): ProviderStrategy<T>;\n\n  static fromSchema(\n    schema: Record<string, unknown>\n  ): ProviderStrategy<Record<string, unknown>>;\n\n  static fromSchema<T = unknown>(\n    schema: InteropZodType<T> | Record<string, unknown>\n  ): ProviderStrategy<T> | ProviderStrategy<Record<string, unknown>> {\n    const asJsonSchema = toJsonSchema(schema);\n    return new ProviderStrategy(asJsonSchema) 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 toolArgs - The arguments from the tool call\n   * @returns The parsed response according to the schema type\n   */\n  parse(response: AIMessage) {\n    /**\n     * return if the response doesn't contain valid content\n     */\n    if (typeof response.content !== \"string\" || response.content === \"\") {\n      return;\n    }\n\n    try {\n      const content = JSON.parse(response.content);\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 * Define how to transform the response format from a tool call.\n *\n * @param responseFormat - The response format to transform\n * @param options - The options to use for the transformation\n * @param options.handleError - Whether to handle errors from the tool call\n * @returns The transformed response format\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\nexport function providerStrategy<T extends InteropZodType<any>>(\n  responseFormat: T\n): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport function providerStrategy(\n  responseFormat: JsonSchemaFormat\n): ProviderStrategy<Record<string, unknown>>;\nexport function providerStrategy(\n  responseFormat: InteropZodType<any> | JsonSchemaFormat\n): ProviderStrategy<any> {\n  return ProviderStrategy.fromSchema(\n    responseFormat as any\n  ) as ProviderStrategy<any>;\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>","strict: boolean","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 * 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(),\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 ?? false;\n    } else {\n      this.schema = schemaOrOptions as Record<string, unknown>;\n      this.strict = strict ?? false;\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 = false\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 ?? false\n    ) as ProviderStrategy<unknown>;\n  }\n\n  /**\n   * Handle direct schema format\n   */\n  return ProviderStrategy.fromSchema(\n    responseFormat as InteropZodType<unknown>,\n    false\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/tests/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["BaseChatModel","value: number","tools: StructuredTool[]","_schema: any","RunnableLambda","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun","HumanMessage","AIMessage"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable import/no-extraneous-dependencies */\nimport { expect } from \"vitest\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: expect.any(String) as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.withConfig({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const loaded = await this.serde.loadsTyped(\n          \"json\",\n          this.storageForCopies[thread_id][savedId]\n        );\n\n        expect(\n          saved,\n          `Checkpoint [${savedId}] has been modified since last written`\n        ).toEqual(loaded);\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  // Use a shared reference object so the index persists across bindTools calls\n  private indexRef: { current: number };\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    indexRef,\n    ...rest\n  }: FakeToolCallingModelFields & { indexRef?: { current: number } } = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    // Share the same index reference across instances\n    this.indexRef = indexRef ?? { current: index };\n    this.structuredResponse = structuredResponse;\n  }\n\n  // Getter/setter for backwards compatibility\n  get index(): number {\n    return this.indexRef.current;\n  }\n\n  set index(value: number) {\n    this.indexRef.current = value;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      structuredResponse: this.structuredResponse,\n      // Pass the same indexRef so all instances share the same index state\n      indexRef: this.indexRef,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content).filter(Boolean);\n      content = parts\n        .map((part) => {\n          if (typeof part === \"string\") {\n            return part;\n          } else if (typeof part === \"object\" && \"text\" in part) {\n            return part.text;\n          } else if (Array.isArray(part)) {\n            return part\n              .map((p) => {\n                if (typeof p === \"string\") {\n                  return p;\n                } else if (typeof p === \"object\" && \"text\" in p) {\n                  return p.text;\n                }\n                return \"\";\n              })\n              .join(\"-\");\n          } else {\n            return JSON.stringify(part);\n          }\n        })\n        .join(\"-\");\n    }\n\n    // Reset index at the start of a new conversation (only human message)\n    // This allows the model to be reused across multiple agent.invoke() calls\n    const isStartOfConversation =\n      messages.length === 1 ||\n      (messages.length === 2 && messages.every(HumanMessage.isInstance));\n    if (isStartOfConversation && this.index !== 0) {\n      this.index = 0;\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuUA,IAAa,uBAAb,MAAa,6BAA6BA,2DAAc;CACtD;CAEA;CAGA,AAAQ;CAER;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,oBACA,SACA,GAAG,MAC6D,GAAG,CAAE,GAAE;EACvE,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EAEjB,KAAK,WAAW,YAAY,EAAE,SAAS,MAAO;EAC9C,KAAK,qBAAqB;CAC3B;CAGD,IAAI,QAAgB;AAClB,SAAO,KAAK,SAAS;CACtB;CAED,IAAI,MAAMC,OAAe;EACvB,KAAK,SAAS,UAAU;CACzB;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEC,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,oBAAoB,KAAK;GAEzB,UAAU,KAAK;EAChB;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAIC,0CAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,QAAQ;GAC5D,UAAU,MACP,IAAI,CAAC,SAAS;AACb,QAAI,OAAO,SAAS,SAClB,QAAO;aACE,OAAO,SAAS,YAAY,UAAU,KAC/C,QAAO,KAAK;aACH,MAAM,QAAQ,KAAK,CAC5B,QAAO,KACJ,IAAI,CAAC,MAAM;AACV,SAAI,OAAO,MAAM,SACf,QAAO;cACE,OAAO,MAAM,YAAY,UAAU,EAC5C,QAAO,EAAE;AAEX,YAAO;IACR,EAAC,CACD,KAAK,IAAI;QAEZ,QAAO,KAAK,UAAU,KAAK;GAE9B,EAAC,CACD,KAAK,IAAI;EACb;EAID,MAAM,wBACJ,SAAS,WAAW,KACnB,SAAS,WAAW,KAAK,SAAS,MAAMC,uCAAa,WAAW;AACnE,MAAI,yBAAyB,KAAK,UAAU,GAC1C,KAAK,QAAQ;EAGf,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAIC,oCAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}
+{"version":3,"file":"utils.cjs","names":["BaseChatModel","value: number","tools: StructuredTool[]","_schema: any","RunnableLambda","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun","HumanMessage","AIMessage"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\n/**\n * Custom asymmetric matcher that matches any string value.\n * Works with both Jest and Vitest's toEqual() assertions.\n */\nclass AnyString {\n  asymmetricMatch(other: unknown): boolean {\n    return typeof other === \"string\";\n  }\n\n  toString(): string {\n    return \"Any<String>\";\n  }\n\n  toAsymmetricMatcher(): string {\n    return \"Any<String>\";\n  }\n}\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: new AnyString() as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: new AnyString() as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: new AnyString() as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.withConfig({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const [, serializedSaved] = await this.serde.dumpsTyped(saved);\n        const serializedCopy = this.storageForCopies[thread_id][savedId];\n\n        // Compare Uint8Array contents by converting to string\n        const savedStr = new TextDecoder().decode(serializedSaved);\n        const copyStr = new TextDecoder().decode(serializedCopy);\n        if (savedStr !== copyStr) {\n          throw new Error(\n            `Checkpoint [${savedId}] has been modified since last written`\n          );\n        }\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  // Use a shared reference object so the index persists across bindTools calls\n  private indexRef: { current: number };\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    indexRef,\n    ...rest\n  }: FakeToolCallingModelFields & { indexRef?: { current: number } } = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    // Share the same index reference across instances\n    this.indexRef = indexRef ?? { current: index };\n    this.structuredResponse = structuredResponse;\n  }\n\n  // Getter/setter for backwards compatibility\n  get index(): number {\n    return this.indexRef.current;\n  }\n\n  set index(value: number) {\n    this.indexRef.current = value;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      structuredResponse: this.structuredResponse,\n      // Pass the same indexRef so all instances share the same index state\n      indexRef: this.indexRef,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content).filter(Boolean);\n      content = parts\n        .map((part) => {\n          if (typeof part === \"string\") {\n            return part;\n          } else if (typeof part === \"object\" && \"text\" in part) {\n            return part.text;\n          } else if (Array.isArray(part)) {\n            return part\n              .map((p) => {\n                if (typeof p === \"string\") {\n                  return p;\n                } else if (typeof p === \"object\" && \"text\" in p) {\n                  return p.text;\n                }\n                return \"\";\n              })\n              .join(\"-\");\n          } else {\n            return JSON.stringify(part);\n          }\n        })\n        .join(\"-\");\n    }\n\n    // Reset index at the start of a new conversation (only human message)\n    // This allows the model to be reused across multiple agent.invoke() calls\n    const isStartOfConversation =\n      messages.length === 1 ||\n      (messages.length === 2 && messages.every(HumanMessage.isInstance));\n    if (isStartOfConversation && this.index !== 0) {\n      this.index = 0;\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAyVA,IAAa,uBAAb,MAAa,6BAA6BA,2DAAc;CACtD;CAEA;CAGA,AAAQ;CAER;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,oBACA,SACA,GAAG,MAC6D,GAAG,CAAE,GAAE;EACvE,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EAEjB,KAAK,WAAW,YAAY,EAAE,SAAS,MAAO;EAC9C,KAAK,qBAAqB;CAC3B;CAGD,IAAI,QAAgB;AAClB,SAAO,KAAK,SAAS;CACtB;CAED,IAAI,MAAMC,OAAe;EACvB,KAAK,SAAS,UAAU;CACzB;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEC,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,oBAAoB,KAAK;GAEzB,UAAU,KAAK;EAChB;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAIC,0CAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,QAAQ;GAC5D,UAAU,MACP,IAAI,CAAC,SAAS;AACb,QAAI,OAAO,SAAS,SAClB,QAAO;aACE,OAAO,SAAS,YAAY,UAAU,KAC/C,QAAO,KAAK;aACH,MAAM,QAAQ,KAAK,CAC5B,QAAO,KACJ,IAAI,CAAC,MAAM;AACV,SAAI,OAAO,MAAM,SACf,QAAO;cACE,OAAO,MAAM,YAAY,UAAU,EAC5C,QAAO,EAAE;AAEX,YAAO;IACR,EAAC,CACD,KAAK,IAAI;QAEZ,QAAO,KAAK,UAAU,KAAK;GAE9B,EAAC,CACD,KAAK,IAAI;EACb;EAID,MAAM,wBACJ,SAAS,WAAW,KACnB,SAAS,WAAW,KAAK,SAAS,MAAMC,uCAAa,WAAW;AACnE,MAAI,yBAAyB,KAAK,UAAU,GAC1C,KAAK,QAAQ;EAGf,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAIC,oCAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}

package/dist/agents/tests/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["value: number","tools: StructuredTool[]","_schema: any","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable import/no-extraneous-dependencies */\nimport { expect } from \"vitest\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: expect.any(String) as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: expect.any(String) as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.withConfig({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const loaded = await this.serde.loadsTyped(\n          \"json\",\n          this.storageForCopies[thread_id][savedId]\n        );\n\n        expect(\n          saved,\n          `Checkpoint [${savedId}] has been modified since last written`\n        ).toEqual(loaded);\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  // Use a shared reference object so the index persists across bindTools calls\n  private indexRef: { current: number };\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    indexRef,\n    ...rest\n  }: FakeToolCallingModelFields & { indexRef?: { current: number } } = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    // Share the same index reference across instances\n    this.indexRef = indexRef ?? { current: index };\n    this.structuredResponse = structuredResponse;\n  }\n\n  // Getter/setter for backwards compatibility\n  get index(): number {\n    return this.indexRef.current;\n  }\n\n  set index(value: number) {\n    this.indexRef.current = value;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      structuredResponse: this.structuredResponse,\n      // Pass the same indexRef so all instances share the same index state\n      indexRef: this.indexRef,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content).filter(Boolean);\n      content = parts\n        .map((part) => {\n          if (typeof part === \"string\") {\n            return part;\n          } else if (typeof part === \"object\" && \"text\" in part) {\n            return part.text;\n          } else if (Array.isArray(part)) {\n            return part\n              .map((p) => {\n                if (typeof p === \"string\") {\n                  return p;\n                } else if (typeof p === \"object\" && \"text\" in p) {\n                  return p.text;\n                }\n                return \"\";\n              })\n              .join(\"-\");\n          } else {\n            return JSON.stringify(part);\n          }\n        })\n        .join(\"-\");\n    }\n\n    // Reset index at the start of a new conversation (only human message)\n    // This allows the model to be reused across multiple agent.invoke() calls\n    const isStartOfConversation =\n      messages.length === 1 ||\n      (messages.length === 2 && messages.every(HumanMessage.isInstance));\n    if (isStartOfConversation && this.index !== 0) {\n      this.index = 0;\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAuUA,IAAa,uBAAb,MAAa,6BAA6B,cAAc;CACtD;CAEA;CAGA,AAAQ;CAER;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,oBACA,SACA,GAAG,MAC6D,GAAG,CAAE,GAAE;EACvE,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EAEjB,KAAK,WAAW,YAAY,EAAE,SAAS,MAAO;EAC9C,KAAK,qBAAqB;CAC3B;CAGD,IAAI,QAAgB;AAClB,SAAO,KAAK,SAAS;CACtB;CAED,IAAI,MAAMA,OAAe;EACvB,KAAK,SAAS,UAAU;CACzB;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEC,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,oBAAoB,KAAK;GAEzB,UAAU,KAAK;EAChB;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAI,eAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,QAAQ;GAC5D,UAAU,MACP,IAAI,CAAC,SAAS;AACb,QAAI,OAAO,SAAS,SAClB,QAAO;aACE,OAAO,SAAS,YAAY,UAAU,KAC/C,QAAO,KAAK;aACH,MAAM,QAAQ,KAAK,CAC5B,QAAO,KACJ,IAAI,CAAC,MAAM;AACV,SAAI,OAAO,MAAM,SACf,QAAO;cACE,OAAO,MAAM,YAAY,UAAU,EAC5C,QAAO,EAAE;AAEX,YAAO;IACR,EAAC,CACD,KAAK,IAAI;QAEZ,QAAO,KAAK,UAAU,KAAK;GAE9B,EAAC,CACD,KAAK,IAAI;EACb;EAID,MAAM,wBACJ,SAAS,WAAW,KACnB,SAAS,WAAW,KAAK,SAAS,MAAM,aAAa,WAAW;AACnE,MAAI,yBAAyB,KAAK,UAAU,GAC1C,KAAK,QAAQ;EAGf,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAI,UAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}
+{"version":3,"file":"utils.js","names":["value: number","tools: StructuredTool[]","_schema: any","messages: BaseMessage[]","_options?: this[\"ParsedCallOptions\"]","_runManager?: CallbackManagerForLLMRun"],"sources":["../../../src/agents/tests/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseChatModel,\n  BaseChatModelParams,\n  BaseChatModelCallOptions,\n  BindToolsInput,\n  ToolChoice,\n} from \"@langchain/core/language_models/chat_models\";\nimport { StructuredTool } from \"@langchain/core/tools\";\nimport {\n  BaseMessage,\n  AIMessage,\n  HumanMessage,\n  BaseMessageFields,\n  AIMessageFields,\n  ToolMessage,\n  ToolMessageFields,\n} from \"@langchain/core/messages\";\nimport { ChatResult } from \"@langchain/core/outputs\";\nimport {\n  Runnable,\n  RunnableConfig,\n  RunnableLambda,\n  RunnableBinding,\n} from \"@langchain/core/runnables\";\nimport {\n  MemorySaver,\n  Checkpoint,\n  CheckpointMetadata,\n  type BaseCheckpointSaver,\n} from \"@langchain/langgraph-checkpoint\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { z } from \"zod/v3\";\n\n/**\n * Custom asymmetric matcher that matches any string value.\n * Works with both Jest and Vitest's toEqual() assertions.\n */\nclass AnyString {\n  asymmetricMatch(other: unknown): boolean {\n    return typeof other === \"string\";\n  }\n\n  toString(): string {\n    return \"Any<String>\";\n  }\n\n  toAsymmetricMatcher(): string {\n    return \"Any<String>\";\n  }\n}\n\nexport class _AnyIdAIMessage extends AIMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"AIMessage\"];\n  }\n\n  constructor(fields: AIMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<AIMessageFields> = {\n      id: new AnyString() as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as AIMessageFields);\n  }\n}\n\nexport class _AnyIdHumanMessage extends HumanMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"HumanMessage\"];\n  }\n\n  constructor(fields: BaseMessageFields | string) {\n    let fieldsWithJestMatcher: Partial<BaseMessageFields> = {\n      id: new AnyString() as unknown as string,\n    };\n    if (typeof fields === \"string\") {\n      fieldsWithJestMatcher = {\n        content: fields,\n        ...fieldsWithJestMatcher,\n      };\n    } else {\n      fieldsWithJestMatcher = {\n        ...fields,\n        ...fieldsWithJestMatcher,\n      };\n    }\n    super(fieldsWithJestMatcher as BaseMessageFields);\n  }\n}\n\nexport class _AnyIdToolMessage extends ToolMessage {\n  get lc_id() {\n    return [\"langchain_core\", \"messages\", \"ToolMessage\"];\n  }\n\n  constructor(fields: ToolMessageFields) {\n    const fieldsWithJestMatcher: Partial<ToolMessageFields> = {\n      id: new AnyString() as unknown as string,\n      ...fields,\n    };\n    super(fieldsWithJestMatcher as ToolMessageFields);\n  }\n}\n\nexport class FakeConfigurableModel extends BaseChatModel {\n  _queuedMethodOperations: Record<string, any> = {};\n\n  _chatModel: LanguageModelLike;\n\n  constructor(\n    fields: {\n      model: LanguageModelLike;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this._chatModel = fields.model;\n  }\n\n  _llmType() {\n    return \"fake_configurable\";\n  }\n\n  async _generate(\n    _messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    throw new Error(\"Not implemented\");\n  }\n\n  async _model() {\n    return this._chatModel;\n  }\n\n  bindTools(tools: BindToolsInput[]) {\n    const modelWithTools = new FakeConfigurableModel({\n      model: (this._chatModel as FakeToolCallingChatModel).bindTools(tools),\n    });\n    modelWithTools._queuedMethodOperations.bindTools = tools;\n    return modelWithTools;\n  }\n}\n\nexport class FakeToolCallingChatModel extends BaseChatModel {\n  sleep?: number = 50;\n\n  responses?: BaseMessage[];\n\n  thrownErrorString?: string;\n\n  idx: number;\n\n  toolStyle: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\" = \"openai\";\n\n  structuredResponse?: Record<string, unknown>;\n\n  // Track messages passed to structured output calls\n  structuredOutputMessages: BaseMessage[][] = [];\n\n  constructor(\n    fields: {\n      sleep?: number;\n      responses?: BaseMessage[];\n      thrownErrorString?: string;\n      toolStyle?: \"openai\" | \"anthropic\" | \"bedrock\" | \"google\";\n      structuredResponse?: Record<string, unknown>;\n    } & BaseChatModelParams\n  ) {\n    super(fields);\n    this.sleep = fields.sleep ?? this.sleep;\n    this.responses = fields.responses;\n    this.thrownErrorString = fields.thrownErrorString;\n    this.idx = 0;\n    this.toolStyle = fields.toolStyle ?? this.toolStyle;\n    this.structuredResponse = fields.structuredResponse;\n    this.structuredOutputMessages = [];\n  }\n\n  _llmType() {\n    return \"fake\";\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options: this[\"ParsedCallOptions\"],\n    runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    if (this.thrownErrorString) {\n      throw new Error(this.thrownErrorString);\n    }\n    if (this.sleep !== undefined) {\n      await new Promise((resolve) => setTimeout(resolve, this.sleep));\n    }\n    const responses = this.responses?.length ? this.responses : messages;\n    const msg = responses[this.idx % responses.length];\n    const generation: ChatResult = {\n      generations: [\n        {\n          text: \"\",\n          message: msg,\n        },\n      ],\n    };\n    this.idx += 1;\n\n    if (typeof msg.content === \"string\") {\n      await runManager?.handleLLMNewToken(msg.content);\n    }\n    return generation;\n  }\n\n  bindTools(tools: BindToolsInput[]): Runnable<any> {\n    const toolDicts = [];\n    const serverTools = [];\n    for (const tool of tools) {\n      if (!(\"name\" in tool)) {\n        serverTools.push(tool);\n        continue;\n      }\n\n      // NOTE: this is a simplified tool spec for testing purposes only\n      if (this.toolStyle === \"openai\") {\n        toolDicts.push({\n          type: \"function\",\n          function: {\n            name: tool.name,\n          },\n        });\n      } else if ([\"anthropic\", \"google\"].includes(this.toolStyle)) {\n        toolDicts.push({\n          name: tool.name,\n        });\n      } else if (this.toolStyle === \"bedrock\") {\n        toolDicts.push({\n          toolSpec: {\n            name: tool.name,\n          },\n        });\n      }\n    }\n    let toolsToBind: BindToolsInput[] = toolDicts;\n    if (this.toolStyle === \"google\") {\n      toolsToBind = [{ functionDeclarations: toolDicts }];\n    }\n    return this.withConfig({\n      tools: [...toolsToBind, ...serverTools],\n    } as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>\n  >(_: unknown): Runnable<any> {\n    if (!this.structuredResponse) {\n      throw new Error(\"No structured response provided\");\n    }\n    // Create a runnable that returns the proper structured format\n    return RunnableLambda.from(async (messages: BaseMessage[]) => {\n      if (this.sleep) {\n        await new Promise((resolve) => setTimeout(resolve, this.sleep));\n      }\n\n      // Store the messages that were sent to generate structured output\n      this.structuredOutputMessages.push([...messages]);\n\n      // Return in the format expected: { raw: BaseMessage, parsed: RunOutput }\n      return this.structuredResponse as RunOutput;\n    });\n  }\n}\n\nexport class MemorySaverAssertImmutable extends MemorySaver {\n  storageForCopies: Record<string, Record<string, Uint8Array>> = {};\n\n  constructor() {\n    super();\n    this.storageForCopies = {};\n  }\n\n  async put(\n    config: RunnableConfig,\n    checkpoint: Checkpoint,\n    metadata: CheckpointMetadata\n  ): Promise<RunnableConfig> {\n    const thread_id = config.configurable?.thread_id;\n    this.storageForCopies[thread_id] ??= {};\n\n    // assert checkpoint hasn't been modified since last written\n    const saved = await this.get(config);\n    if (saved) {\n      const savedId = saved.id;\n      if (this.storageForCopies[thread_id][savedId]) {\n        const [, serializedSaved] = await this.serde.dumpsTyped(saved);\n        const serializedCopy = this.storageForCopies[thread_id][savedId];\n\n        // Compare Uint8Array contents by converting to string\n        const savedStr = new TextDecoder().decode(serializedSaved);\n        const copyStr = new TextDecoder().decode(serializedCopy);\n        if (savedStr !== copyStr) {\n          throw new Error(\n            `Checkpoint [${savedId}] has been modified since last written`\n          );\n        }\n      }\n    }\n    const [, serializedCheckpoint] = await this.serde.dumpsTyped(checkpoint);\n    // save a copy of the checkpoint\n    this.storageForCopies[thread_id][checkpoint.id] = serializedCheckpoint;\n\n    return super.put(config, checkpoint, metadata);\n  }\n}\n\ninterface ToolCall {\n  name: string;\n  args: Record<string, any>;\n  id: string;\n  type?: \"tool_call\";\n}\n\ninterface FakeToolCallingModelFields {\n  toolCalls?: ToolCall[][];\n  toolStyle?: \"openai\" | \"anthropic\";\n  index?: number;\n  structuredResponse?: any;\n}\n\n// Helper function to create checkpointer\nexport function createCheckpointer(): BaseCheckpointSaver {\n  return new MemorySaver();\n}\n\n/**\n * Fake chat model for testing tool calling functionality\n */\nexport class FakeToolCallingModel extends BaseChatModel {\n  toolCalls: ToolCall[][];\n\n  toolStyle: \"openai\" | \"anthropic\";\n\n  // Use a shared reference object so the index persists across bindTools calls\n  private indexRef: { current: number };\n\n  structuredResponse?: any;\n\n  private tools: StructuredTool[] = [];\n\n  constructor({\n    toolCalls = [],\n    toolStyle = \"openai\",\n    index = 0,\n    structuredResponse,\n    indexRef,\n    ...rest\n  }: FakeToolCallingModelFields & { indexRef?: { current: number } } = {}) {\n    super(rest);\n    this.toolCalls = toolCalls;\n    this.toolStyle = toolStyle;\n    // Share the same index reference across instances\n    this.indexRef = indexRef ?? { current: index };\n    this.structuredResponse = structuredResponse;\n  }\n\n  // Getter/setter for backwards compatibility\n  get index(): number {\n    return this.indexRef.current;\n  }\n\n  set index(value: number) {\n    this.indexRef.current = value;\n  }\n\n  _llmType(): string {\n    return \"fake-tool-calling\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  bindTools(\n    tools: StructuredTool[]\n  ):\n    | FakeToolCallingModel\n    | RunnableBinding<\n        any,\n        any,\n        any & { tool_choice?: ToolChoice | undefined }\n      > {\n    const newInstance = new FakeToolCallingModel({\n      toolCalls: this.toolCalls,\n      toolStyle: this.toolStyle,\n      structuredResponse: this.structuredResponse,\n      // Pass the same indexRef so all instances share the same index state\n      indexRef: this.indexRef,\n    });\n    newInstance.tools = [...this.tools, ...tools];\n    return newInstance;\n  }\n\n  withStructuredOutput(_schema: any) {\n    return new RunnableLambda({\n      func: async () => {\n        return this.structuredResponse;\n      },\n    });\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    _options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    const lastMessage = messages[messages.length - 1];\n    let content = lastMessage.content as string;\n\n    // Handle prompt concatenation\n    if (messages.length > 1) {\n      const parts = messages.map((m) => m.content).filter(Boolean);\n      content = parts\n        .map((part) => {\n          if (typeof part === \"string\") {\n            return part;\n          } else if (typeof part === \"object\" && \"text\" in part) {\n            return part.text;\n          } else if (Array.isArray(part)) {\n            return part\n              .map((p) => {\n                if (typeof p === \"string\") {\n                  return p;\n                } else if (typeof p === \"object\" && \"text\" in p) {\n                  return p.text;\n                }\n                return \"\";\n              })\n              .join(\"-\");\n          } else {\n            return JSON.stringify(part);\n          }\n        })\n        .join(\"-\");\n    }\n\n    // Reset index at the start of a new conversation (only human message)\n    // This allows the model to be reused across multiple agent.invoke() calls\n    const isStartOfConversation =\n      messages.length === 1 ||\n      (messages.length === 2 && messages.every(HumanMessage.isInstance));\n    if (isStartOfConversation && this.index !== 0) {\n      this.index = 0;\n    }\n\n    const currentToolCalls = this.toolCalls[this.index] || [];\n    const messageId = this.index.toString();\n\n    // Move to next set of tool calls for subsequent invocations\n    this.index = (this.index + 1) % Math.max(1, this.toolCalls.length);\n\n    const message = new AIMessage({\n      content,\n      id: messageId,\n      tool_calls:\n        currentToolCalls.length > 0\n          ? currentToolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [\n        {\n          text: content,\n          message,\n        },\n      ],\n      llmOutput: {},\n    };\n  }\n}\n\nexport class SearchAPI extends StructuredTool {\n  name = \"search_api\";\n\n  description = \"A simple API that returns the input string.\";\n\n  schema = z.object({\n    query: z.string().describe(\"The query to search for.\"),\n  });\n\n  async _call(input: z.infer<typeof this.schema>) {\n    if (input?.query === \"error\") {\n      throw new Error(\"Error\");\n    }\n    return `result for ${input?.query}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAyVA,IAAa,uBAAb,MAAa,6BAA6B,cAAc;CACtD;CAEA;CAGA,AAAQ;CAER;CAEA,AAAQ,QAA0B,CAAE;CAEpC,YAAY,EACV,YAAY,CAAE,GACd,YAAY,UACZ,QAAQ,GACR,oBACA,SACA,GAAG,MAC6D,GAAG,CAAE,GAAE;EACvE,MAAM,KAAK;EACX,KAAK,YAAY;EACjB,KAAK,YAAY;EAEjB,KAAK,WAAW,YAAY,EAAE,SAAS,MAAO;EAC9C,KAAK,qBAAqB;CAC3B;CAGD,IAAI,QAAgB;AAClB,SAAO,KAAK,SAAS;CACtB;CAED,IAAI,MAAMA,OAAe;EACvB,KAAK,SAAS,UAAU;CACzB;CAED,WAAmB;AACjB,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO,CAAE;CACV;CAED,UACEC,OAOI;EACJ,MAAM,cAAc,IAAI,qBAAqB;GAC3C,WAAW,KAAK;GAChB,WAAW,KAAK;GAChB,oBAAoB,KAAK;GAEzB,UAAU,KAAK;EAChB;EACD,YAAY,QAAQ,CAAC,GAAG,KAAK,OAAO,GAAG,KAAM;AAC7C,SAAO;CACR;CAED,qBAAqBC,SAAc;AACjC,SAAO,IAAI,eAAe,EACxB,MAAM,YAAY;AAChB,UAAO,KAAK;EACb,EACF;CACF;CAED,MAAM,UACJC,UACAC,UACAC,aACqB;EACrB,MAAM,cAAc,SAAS,SAAS,SAAS;EAC/C,IAAI,UAAU,YAAY;AAG1B,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,QAAQ;GAC5D,UAAU,MACP,IAAI,CAAC,SAAS;AACb,QAAI,OAAO,SAAS,SAClB,QAAO;aACE,OAAO,SAAS,YAAY,UAAU,KAC/C,QAAO,KAAK;aACH,MAAM,QAAQ,KAAK,CAC5B,QAAO,KACJ,IAAI,CAAC,MAAM;AACV,SAAI,OAAO,MAAM,SACf,QAAO;cACE,OAAO,MAAM,YAAY,UAAU,EAC5C,QAAO,EAAE;AAEX,YAAO;IACR,EAAC,CACD,KAAK,IAAI;QAEZ,QAAO,KAAK,UAAU,KAAK;GAE9B,EAAC,CACD,KAAK,IAAI;EACb;EAID,MAAM,wBACJ,SAAS,WAAW,KACnB,SAAS,WAAW,KAAK,SAAS,MAAM,aAAa,WAAW;AACnE,MAAI,yBAAyB,KAAK,UAAU,GAC1C,KAAK,QAAQ;EAGf,MAAM,mBAAmB,KAAK,UAAU,KAAK,UAAU,CAAE;EACzD,MAAM,YAAY,KAAK,MAAM,UAAU;EAGvC,KAAK,SAAS,KAAK,QAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,UAAU,OAAO;EAElE,MAAM,UAAU,IAAI,UAAU;GAC5B;GACA,IAAI;GACJ,YACE,iBAAiB,SAAS,IACtB,iBAAiB,IAAI,CAAC,QAAQ;IAC5B,GAAG;IACH,MAAM;GACP,GAAE,GACH;EACP;AAED,SAAO;GACL,aAAa,CACX;IACE,MAAM;IACN;GACD,CACF;GACD,WAAW,CAAE;EACd;CACF;AACF"}

package/dist/index.cjs

@@ -3,6 +3,7 @@ const require_chat_models_universal = require('./chat_models/universal.cjs');
 const require_errors = require('./agents/errors.cjs');
 const require_responses = require('./agents/responses.cjs');
 const require_utils = require('./agents/middleware/utils.cjs');
+const require_types = require('./agents/middleware/types.cjs');
 const require_middleware = require('./agents/middleware.cjs');
 const require_utils$1 = require('./agents/tests/utils.cjs');
 const require_index = require('./agents/index.cjs');
@@ -43,6 +44,7 @@ require_rolldown_runtime.__export(src_exports, {
 	HumanMessage: () => __langchain_core_messages.HumanMessage,
 	HumanMessageChunk: () => __langchain_core_messages.HumanMessageChunk,
 	InMemoryStore: () => __langchain_core_stores.InMemoryStore,
+	MIDDLEWARE_BRAND: () => require_types.MIDDLEWARE_BRAND,
 	MultipleStructuredOutputsError: () => require_errors.MultipleStructuredOutputsError,
 	MultipleToolsBoundError: () => require_errors.MultipleToolsBoundError,
 	PIIDetectionError: () => require_pii.PIIDetectionError,
@@ -155,6 +157,7 @@ Object.defineProperty(exports, 'InMemoryStore', {
     return __langchain_core_stores.InMemoryStore;
   }
 });
+exports.MIDDLEWARE_BRAND = require_types.MIDDLEWARE_BRAND;
 exports.MultipleStructuredOutputsError = require_errors.MultipleStructuredOutputsError;
 exports.MultipleToolsBoundError = require_errors.MultipleToolsBoundError;
 exports.PIIDetectionError = require_pii.PIIDetectionError;