@langchain/core 1.1.30 → 1.1.32

package/dist/tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/tools/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/tools/types.ts"],"mappings":";;;;;;;;;;;;;;KA6BY,cAAA;AAAA,KAGA,cAAA;AAAA,KAEA,aAAA;AAAA,KAGA,sBAAA,MAA4B,CAAA,cACnC,IAAA,YACA,cAAA,uBACD,CAAA,GACA,aAAA;AAAA,KAEQ,uBAAA,MAA6B,CAAA,cACpC,IAAA,YACA,cAAA,uBACD,CAAA,GACA,CAAA,cAAc,IAAA,YAAgB,OAAA,aAC5B,CAAA,GACA,CAAA,cAAc,IAAA,uBACZ,CAAA,GACA,cAAA;AAAA,KAII,kBAAA,IAAsB,cAAA;;;;AAvBlC;;;KA+BY,cAAA,6BACV,OAAA,SAAgB,gBAAA,GACZ,OAAA,GACA,OAAA;EAAkB,QAAA;IAAY,EAAA;EAAA;AAAA,IAC5B,WAAA,GACA,OAAA;EAAkB,QAAA;IAAY,EAAA;EAAA;AAAA,IAC5B,OAAA,GACA,OAAA;EAAkB,QAAA;IAAY,EAAA;EAAA;AAAA,IAC5B,OAAA,GAAU,WAAA,GACV,MAAA,SAAe,QAAA,GACb,WAAA,GACA,OAAA;;;;;KAMF,mBAAA,GAAsB,CAAA,CAAG,UAAA,GAAa,eAAA;;;;UAKjC,UAAA,SAAmB,mBAAA;EA5CnB;;AAEjB;;;;;;;EAoDE,cAAA,GAAiB,cAAA;EA5CX;;;EAgDN,aAAA,GAAgB,kBAAA;EAxDuB;;;;;EA8DvC,oBAAA;EA1DgB;;;EA8DhB,QAAA,GAAW,MAAA;EA5DP;;;;;;EAmEJ,MAAA,GAAS,MAAA;AAAA;AAAA,KAGC,kBAAA,+BAEoB,MAAA,gBAAsB,MAAA,sCAGlD,cAAA,CAAe,qBAAA;EACjB,QAAA,GAAW,QAAA;EACX,OAAA,GAAU,aAAA;AAAA;AA/DZ;;;;;AAAA,UAuEiB,oBAAA,SAA6B,IAAA,CAC5C,uBAAA;EArEI;;;EA2EJ,WAAA;AAAA;;;;;;;;;;;;KAcU,yBAAA,MAA+B,CAAA,SAAU,cAAA,GACjD,qBAAA,CAAsB,CAAA,IACtB,CAAA,SAAU,eAAA;;;;;;;;;;;;KAeF,wBAAA,MAA8B,CAAA,SAAU,cAAA,GAChD,oBAAA,CAAqB,CAAA,IACrB,CAAA,SAAU,eAAA;;;;;;;KAUF,uBAAA,WACA,mBAAA,iBACK,wBAAA,CAAyB,OAAA,MAErC,yBAAA,CAA0B,OAAA,qCAC3B,YAAA,GACA,QAAA;;;AA9GJ;;;;;;;KAyHY,qBAAA,GAAwB,CAAA,CAAG,OAAA,qBAErC,CAAA,CAAG,UAAA;;;;;;;;;;UA6BY,uBAAA,WACL,mBAAA,iBACK,wBAAA,CAAyB,OAAA,iBAC1B,cAAA,UACN,iBAAA,CACR,uBAAA,CAAwB,OAAA,EAAS,YAAA,GACjC,WAAA,GAAc,WAAA;EAEd,YAAA;EAzH4B;;;EA8H5B,MAAA,EAAQ,OAAA;EAzHS;;;;;;EAiIjB,MAAA,cACe,uBAAA,CAAwB,OAAA,EAAS,YAAA,mBAC9B,kBAAA,cAEhB,GAAA,EAAK,IAAA,EACL,SAAA,GAAY,OAAA,GACX,OAAA,CAAQ,cAAA,CAAe,IAAA,EAAM,OAAA,EAAS,WAAA;EA1IX;;;;;;;;;;;EAuJ9B,IAAA,cACe,uBAAA,CAAwB,OAAA,EAAS,YAAA,mBAC9B,kBAAA,cAEhB,GAAA,EAAK,IAAA,EACL,SAAA,GAAY,OAAA,EA/IsB;;EAiJlC,IAAA,cACC,OAAA,CAAQ,cAAA,CAAe,IAAA,EAAM,OAAA,EAAS,WAAA;EAlJO;;;EAuJhD,IAAA;EAhJW;;AAcb;EAuIE,WAAA;EAvImC;;;;;;EA+InC,YAAA;EA7IsB;;;;;;EAqJtB,MAAA,GAAS,MAAA;AAAA;;;;AAtIX;;;UA+IiB,aAAA,WACL,qBAAA,iBACK,wBAAA,CAAyB,OAAA,iBAC1B,cAAA,UACN,uBAAA,CAAwB,OAAA,EAAS,YAAA,EAAc,WAAA;EAnJL;;;;;;;;;EA6JlD,IAAA,cACe,uBAAA,CAAwB,OAAA,EAAS,YAAA,mBAC9B,kBAAA,cAGhB,GAAA,EAAK,IAAA,EACL,SAAA,GAAY,OAAA,GACX,OAAA,CAAQ,cAAA,CAAe,WAAA,CAAY,IAAA,GAAO,OAAA,EAAS,WAAA;AAAA;;;;;UAOvC,oBAAA,SAA6B,UAAA;EAC5C,IAAA;EACA,WAAA;EAjKiC;;;;;;EAwKjC,YAAA;AAAA;;;;;;;UASe,gBAAA,eACD,cAAA,eACD,aAAA,UACL,oBAAA;EACR,IAAA,GACE,KAAA,UACA,UAAA,GAAa,yBAAA,EACb,MAAA,GAAS,kBAAA,KACN,OAAA,CAAQ,WAAA,IAAe,cAAA,CAAe,UAAA,EAAY,WAAA;AAAA;;;;;AAxKzD;;;;UAmLiB,0BAAA,WACL,mBAAA,kBACM,yBAAA,CAA0B,OAAA,iBAC5B,cAAA,eACD,aAAA,UACL,oBAAA;EAxL6B;;;;;AA+BvC;;;EAkKE,IAAA,GACE,KAAA,EAAO,aAAA,EACP,UAAA,GAAa,yBAAA,EACb,MAAA,GAAS,cAAA,KACN,OAAA,CAAQ,WAAA,IAAe,cAAA,CAAe,UAAA,EAAY,WAAA;EACvD,MAAA,EAAQ,OAAA;AAAA;;;;;;;iBASM,gBAAA,CACd,IAAA,GAAO,uBAAA,GAA0B,cAAA,GAAiB,eAAA,GACjD,IAAA,IAAQ,uBAAA;;;;;;;iBAaK,kBAAA,CAAmB,IAAA,aAAiB,IAAA,IAAQ,gBAAA;;;;;;;iBAgB5C,sBAAA,CACd,IAAA,aACC,IAAA,IAAQ,oBAAA;;;;;;;;;iBA0BK,eAAA,CAAgB,IAAA,aAAiB,IAAA,IAAQ,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAxJzD;;;;;;;;;KAqOY,WAAA,yCAGR,cAAA;EAzNqC;;;EA6NvC,KAAA,EAAO,MAAA,SAAe,gBAAA,GAClB,qBAAA,CAAsB,MAAA,IACtB,MAAA,SAAe,MAAA,oBACb,MAAA;EA5NC;;;EAiOP,UAAA;EA/N6C;;;EAmO7C,QAAA,GAAW,QAAA;EApPH;;;EAwPR,MAAA,EAAQ,kBAAA;EA3PE;;;EA+PV,OAAA,EAAS,QAAA,SAAiB,gBAAA,GACtB,qBAAA,CAAsB,QAAA,IACtB,QAAA,SAAiB,MAAA,oBACf,QAAA;EAhQN;;;EAqQA,KAAA,EAAO,SAAA;EApQkC;;;EAwQzC,MAAA,IAAU,KAAA;AAAA"}

package/dist/tools/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../src/tools/types.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type {\n  BaseLangChainParams,\n  ToolDefinition,\n} from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport {\n  Runnable,\n  RunnableToolLike,\n  type RunnableInterface,\n} from \"../runnables/base.js\";\nimport {\n  type DirectToolOutput,\n  type ToolCall,\n  type ToolMessage,\n} from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport {\n  type InferInteropZodInput,\n  type InferInteropZodOutput,\n  type InteropZodType,\n  isInteropZodSchema,\n  type InteropZodObject,\n} from \"../utils/types/zod.js\";\n\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\n\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> =\n  TOutput extends DirectToolOutput\n    ? TOutput\n    : TConfig extends { toolCall: { id: string } }\n      ? ToolMessage\n      : TConfig extends { toolCall: { id: undefined } }\n        ? TOutput\n        : TConfig extends { toolCall: { id?: string } }\n          ? TOutput | ToolMessage\n          : TInput extends ToolCall\n            ? ToolMessage\n            : TOutput;\n\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n  /**\n   * The tool response format.\n   *\n   * If \"content\" then the output of the tool is interpreted as the contents of a\n   * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n   * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n   *\n   * @default \"content\"\n   */\n  responseFormat?: ResponseFormat;\n  /**\n   * Default config object for the tool runnable.\n   */\n  defaultConfig?: ToolRunnableConfig;\n  /**\n   * Whether to show full details in the thrown parsing errors.\n   *\n   * @default false\n   */\n  verboseParsingErrors?: boolean;\n  /**\n   * Metadata for the tool.\n   */\n  metadata?: Record<string, unknown>;\n  /**\n   * Optional provider-specific extra fields for the tool.\n   *\n   * This is used to pass provider-specific configuration that doesn't fit into\n   * standard tool fields.\n   */\n  extras?: Record<string, unknown>;\n}\n\nexport type ToolRunnableConfig<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ConfigurableFieldType extends Record<string, any> = Record<string, any>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ContextSchema = any,\n> = RunnableConfig<ConfigurableFieldType> & {\n  toolCall?: ToolCall;\n  context?: ContextSchema;\n};\n\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<\n  StructuredToolInterface,\n  \"name\" | \"schema\" | \"extras\"\n> {\n  /**\n   * An optional description of the tool to pass to the model.\n   */\n  description?: string;\n}\n\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType\n  ? InferInteropZodOutput<T>\n  : T extends JSONSchema\n    ? unknown\n    : never;\n\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType\n  ? InferInteropZodInput<T>\n  : T extends JSONSchema\n    ? unknown\n    : never;\n\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n> =\n  | (ToolInputSchemaOutputType<SchemaT> extends string ? string : never)\n  | SchemaInputT\n  | ToolCall;\n\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<\n  string | undefined,\n  z3.ZodTypeDef,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> =\n  StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n> extends RunnableInterface<\n  StructuredToolCallInput<SchemaT, SchemaInputT>,\n  ToolOutputT | ToolMessage\n> {\n  lc_namespace: string[];\n\n  /**\n   * A Zod schema representing the parameters of the tool.\n   */\n  schema: SchemaT;\n\n  /**\n   * Invokes the tool with the provided argument and configuration.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration for the tool call.\n   * @returns A Promise that resolves with the tool's output.\n   */\n  invoke<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    arg: TArg,\n    configArg?: TConfig\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument, configuration, and tags. It\n   * parses the input according to the schema, handles any errors, and\n   * manages callbacks.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration or callbacks for the tool.\n   * @param tags Optional tags for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    arg: TArg,\n    configArg?: TConfig,\n    /** @deprecated */\n    tags?: string[]\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * The name of the tool.\n   */\n  name: string;\n\n  /**\n   * A description of the tool.\n   */\n  description: string;\n\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect: boolean;\n\n  /**\n   * Optional provider-specific extra fields for the tool.\n   *\n   * This is used to pass provider-specific configuration that doesn't fit into\n   * standard tool fields.\n   */\n  extras?: Record<string, unknown>;\n}\n\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<\n  SchemaT = StringInputToolSchema,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument and callbacks. It handles\n   * string inputs specifically.\n   * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n   * @param callbacks Optional callbacks for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg,\n    callbacks?: TConfig\n  ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n  name: string;\n  description: string;\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect?: boolean;\n}\n\n/**\n * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<\n  ToolOutputT = ToolOutputType,\n> extends BaseDynamicToolInput {\n  func: (\n    input: string,\n    runManager?: CallbackManagerForToolRun,\n    config?: ToolRunnableConfig\n  ) => Promise<ToolOutputT> | AsyncGenerator<unknown, ToolOutputT>;\n}\n\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n> extends BaseDynamicToolInput {\n  /**\n   * Tool handler function - the function that will be called when the tool is invoked.\n   *\n   * @param input - The input to the tool.\n   * @param runManager - The run manager for the tool.\n   * @param config - The configuration for the tool.\n   * @returns The result of the tool.\n   */\n  func: (\n    input: SchemaOutputT,\n    runManager?: CallbackManagerForToolRun,\n    config?: RunnableConfig\n  ) => Promise<ToolOutputT> | AsyncGenerator<unknown, ToolOutputT>;\n  schema: SchemaT;\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport function isStructuredTool(\n  tool?: StructuredToolInterface | ToolDefinition | JSONSchema\n): tool is StructuredToolInterface {\n  return (\n    tool !== undefined &&\n    Array.isArray((tool as StructuredToolInterface).lc_namespace)\n  );\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike {\n  return (\n    tool !== undefined &&\n    Runnable.isRunnable(tool) &&\n    \"lc_name\" in tool.constructor &&\n    typeof tool.constructor.lc_name === \"function\" &&\n    tool.constructor.lc_name() === \"RunnableToolLike\"\n  );\n}\n\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport function isStructuredToolParams(\n  tool?: unknown\n): tool is StructuredToolParams {\n  return (\n    !!tool &&\n    typeof tool === \"object\" &&\n    \"name\" in tool &&\n    \"schema\" in tool &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (isInteropZodSchema(tool.schema as Record<string, any>) ||\n      (tool.schema != null &&\n        typeof tool.schema === \"object\" &&\n        \"type\" in tool.schema &&\n        typeof tool.schema.type === \"string\" &&\n        [\"null\", \"boolean\", \"object\", \"array\", \"number\", \"string\"].includes(\n          tool.schema.type\n        )))\n  );\n}\n\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport function isLangChainTool(tool?: unknown): tool is StructuredToolParams {\n  return (\n    isStructuredToolParams(tool) ||\n    isRunnableToolLike(tool) ||\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    isStructuredTool(tool as any)\n  );\n}\n\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, type ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime: ToolRuntime<typeof stateSchema>) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n *\n * const agent = createAgent({\n *   model,\n *   tools: [greet],\n *   stateSchema,\n *   contextSchema,\n * });\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<\n  TState = unknown,\n  TContext = unknown,\n> = RunnableConfig & {\n  /**\n   * The current graph state.\n   */\n  state: TState extends InteropZodObject\n    ? InferInteropZodOutput<TState>\n    : TState extends Record<string, unknown>\n      ? TState\n      : unknown;\n  /**\n   * The ID of the current tool call.\n   */\n  toolCallId: string;\n  /**\n   * The current tool call.\n   */\n  toolCall?: ToolCall;\n  /**\n   * RunnableConfig for the current execution.\n   */\n  config: ToolRunnableConfig;\n  /**\n   * Runtime context (from langgraph `Runtime`).\n   */\n  context: TContext extends InteropZodObject\n    ? InferInteropZodOutput<TContext>\n    : TContext extends Record<string, unknown>\n      ? TContext\n      : unknown;\n  /**\n   * BaseStore instance for persistent storage (from langgraph `Runtime`).\n   */\n  store: BaseStore<string, unknown> | null;\n  /**\n   * Stream writer for streaming output (from langgraph `Runtime`).\n   */\n  writer: ((chunk: unknown) => void) | null;\n};\n"],"mappings":";;;;;;;;;;AA6XA,SAAgB,iBACd,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;;;;;;;;AAUjE,SAAgB,mBAAmB,MAA0C;AAC3E,QACE,SAAS,UACT,SAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;;;;;;;;AAUnC,SAAgB,uBACd,MAC8B;AAC9B,QACE,CAAC,CAAC,QACF,OAAO,SAAS,YAChB,UAAU,QACV,YAAY,SAEX,mBAAmB,KAAK,OAA8B,IACpD,KAAK,UAAU,QACd,OAAO,KAAK,WAAW,YACvB,UAAU,KAAK,UACf,OAAO,KAAK,OAAO,SAAS,YAC5B;EAAC;EAAQ;EAAW;EAAU;EAAS;EAAU;EAAS,CAAC,SACzD,KAAK,OAAO,KACb;;;;;;;;;;AAYT,SAAgB,gBAAgB,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY"}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/tools/types.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type {\n  BaseLangChainParams,\n  ToolDefinition,\n} from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport {\n  Runnable,\n  RunnableToolLike,\n  type RunnableInterface,\n} from \"../runnables/base.js\";\nimport {\n  type DirectToolOutput,\n  type ToolCall,\n  type ToolMessage,\n} from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport {\n  type InferInteropZodInput,\n  type InferInteropZodOutput,\n  type InteropZodType,\n  isInteropZodSchema,\n  type InteropZodObject,\n} from \"../utils/types/zod.js\";\n\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\n\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n\nexport type ToolEventType = unknown;\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport type InferToolEventFromFunc<F> = F extends (\n  ...args: any[]\n) => AsyncGenerator<infer Y, any, any>\n  ? Y\n  : ToolEventType;\n\nexport type InferToolOutputFromFunc<F> = F extends (\n  ...args: any[]\n) => AsyncGenerator<any, infer R, any>\n  ? R\n  : F extends (...args: any[]) => Promise<infer R>\n    ? R\n    : F extends (...args: any[]) => infer R\n      ? R\n      : ToolOutputType;\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> =\n  TOutput extends DirectToolOutput\n    ? TOutput\n    : TConfig extends { toolCall: { id: string } }\n      ? ToolMessage\n      : TConfig extends { toolCall: { id: undefined } }\n        ? TOutput\n        : TConfig extends { toolCall: { id?: string } }\n          ? TOutput | ToolMessage\n          : TInput extends ToolCall\n            ? ToolMessage\n            : TOutput;\n\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n  /**\n   * The tool response format.\n   *\n   * If \"content\" then the output of the tool is interpreted as the contents of a\n   * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n   * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n   *\n   * @default \"content\"\n   */\n  responseFormat?: ResponseFormat;\n  /**\n   * Default config object for the tool runnable.\n   */\n  defaultConfig?: ToolRunnableConfig;\n  /**\n   * Whether to show full details in the thrown parsing errors.\n   *\n   * @default false\n   */\n  verboseParsingErrors?: boolean;\n  /**\n   * Metadata for the tool.\n   */\n  metadata?: Record<string, unknown>;\n  /**\n   * Optional provider-specific extra fields for the tool.\n   *\n   * This is used to pass provider-specific configuration that doesn't fit into\n   * standard tool fields.\n   */\n  extras?: Record<string, unknown>;\n}\n\nexport type ToolRunnableConfig<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ConfigurableFieldType extends Record<string, any> = Record<string, any>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ContextSchema = any,\n> = RunnableConfig<ConfigurableFieldType> & {\n  toolCall?: ToolCall;\n  context?: ContextSchema;\n};\n\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<\n  StructuredToolInterface,\n  \"name\" | \"schema\" | \"extras\"\n> {\n  /**\n   * An optional description of the tool to pass to the model.\n   */\n  description?: string;\n}\n\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType\n  ? InferInteropZodOutput<T>\n  : T extends JSONSchema\n    ? unknown\n    : never;\n\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType\n  ? InferInteropZodInput<T>\n  : T extends JSONSchema\n    ? unknown\n    : never;\n\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n> =\n  | (ToolInputSchemaOutputType<SchemaT> extends string ? string : never)\n  | SchemaInputT\n  | ToolCall;\n\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<\n  string | undefined,\n  z3.ZodTypeDef,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> =\n  StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n> extends RunnableInterface<\n  StructuredToolCallInput<SchemaT, SchemaInputT>,\n  ToolOutputT | ToolMessage\n> {\n  lc_namespace: string[];\n\n  /**\n   * A Zod schema representing the parameters of the tool.\n   */\n  schema: SchemaT;\n\n  /**\n   * Invokes the tool with the provided argument and configuration.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration for the tool call.\n   * @returns A Promise that resolves with the tool's output.\n   */\n  invoke<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    arg: TArg,\n    configArg?: TConfig\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument, configuration, and tags. It\n   * parses the input according to the schema, handles any errors, and\n   * manages callbacks.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration or callbacks for the tool.\n   * @param tags Optional tags for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    arg: TArg,\n    configArg?: TConfig,\n    /** @deprecated */\n    tags?: string[]\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * The name of the tool.\n   */\n  name: string;\n\n  /**\n   * A description of the tool.\n   */\n  description: string;\n\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect: boolean;\n\n  /**\n   * Optional provider-specific extra fields for the tool.\n   *\n   * This is used to pass provider-specific configuration that doesn't fit into\n   * standard tool fields.\n   */\n  extras?: Record<string, unknown>;\n}\n\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<\n  SchemaT = StringInputToolSchema,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument and callbacks. It handles\n   * string inputs specifically.\n   * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n   * @param callbacks Optional callbacks for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined,\n  >(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg,\n    callbacks?: TConfig\n  ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n  name: string;\n  description: string;\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect?: boolean;\n}\n\n/**\n * Interface for the input parameters of the DynamicTool class.\n *\n * @param ToolOutputT - The return type of the tool.\n * @param ToolEventT - The type of values yielded by the tool when using an async generator.\n */\nexport interface DynamicToolInput<\n  ToolOutputT = ToolOutputType,\n  ToolEventT = ToolEventType,\n> extends BaseDynamicToolInput {\n  func: (\n    input: string,\n    runManager?: CallbackManagerForToolRun,\n    config?: ToolRunnableConfig\n  ) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;\n}\n\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n * @param ToolOutputT - The return type of the tool.\n * @param ToolEventT - The type of values yielded by the tool when using an async generator.\n */\nexport interface DynamicStructuredToolInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n  ToolOutputT = ToolOutputType,\n  ToolEventT = ToolEventType,\n> extends BaseDynamicToolInput {\n  /**\n   * Tool handler function - the function that will be called when the tool is invoked.\n   *\n   * @param input - The input to the tool.\n   * @param runManager - The run manager for the tool.\n   * @param config - The configuration for the tool.\n   * @returns The result of the tool.\n   */\n  func: (\n    input: SchemaOutputT,\n    runManager?: CallbackManagerForToolRun,\n    config?: RunnableConfig\n  ) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;\n  schema: SchemaT;\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport function isStructuredTool(\n  tool?: StructuredToolInterface | ToolDefinition | JSONSchema\n): tool is StructuredToolInterface {\n  return (\n    tool !== undefined &&\n    Array.isArray((tool as StructuredToolInterface).lc_namespace)\n  );\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike {\n  return (\n    tool !== undefined &&\n    Runnable.isRunnable(tool) &&\n    \"lc_name\" in tool.constructor &&\n    typeof tool.constructor.lc_name === \"function\" &&\n    tool.constructor.lc_name() === \"RunnableToolLike\"\n  );\n}\n\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport function isStructuredToolParams(\n  tool?: unknown\n): tool is StructuredToolParams {\n  return (\n    !!tool &&\n    typeof tool === \"object\" &&\n    \"name\" in tool &&\n    \"schema\" in tool &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (isInteropZodSchema(tool.schema as Record<string, any>) ||\n      (tool.schema != null &&\n        typeof tool.schema === \"object\" &&\n        \"type\" in tool.schema &&\n        typeof tool.schema.type === \"string\" &&\n        [\"null\", \"boolean\", \"object\", \"array\", \"number\", \"string\"].includes(\n          tool.schema.type\n        )))\n  );\n}\n\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport function isLangChainTool(tool?: unknown): tool is StructuredToolParams {\n  return (\n    isStructuredToolParams(tool) ||\n    isRunnableToolLike(tool) ||\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    isStructuredTool(tool as any)\n  );\n}\n\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, type ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime: ToolRuntime<typeof stateSchema>) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n *\n * const agent = createAgent({\n *   model,\n *   tools: [greet],\n *   stateSchema,\n *   contextSchema,\n * });\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<\n  TState = unknown,\n  TContext = unknown,\n> = RunnableConfig & {\n  /**\n   * The current graph state.\n   */\n  state: TState extends InteropZodObject\n    ? InferInteropZodOutput<TState>\n    : TState extends Record<string, unknown>\n      ? TState\n      : unknown;\n  /**\n   * The ID of the current tool call.\n   */\n  toolCallId: string;\n  /**\n   * The current tool call.\n   */\n  toolCall?: ToolCall;\n  /**\n   * RunnableConfig for the current execution.\n   */\n  config: ToolRunnableConfig;\n  /**\n   * Runtime context (from langgraph `Runtime`).\n   */\n  context: TContext extends InteropZodObject\n    ? InferInteropZodOutput<TContext>\n    : TContext extends Record<string, unknown>\n      ? TContext\n      : unknown;\n  /**\n   * BaseStore instance for persistent storage (from langgraph `Runtime`).\n   */\n  store: BaseStore<string, unknown> | null;\n  /**\n   * Stream writer for streaming output (from langgraph `Runtime`).\n   */\n  writer: ((chunk: unknown) => void) | null;\n};\n"],"mappings":";;;;;;;;;;AAwZA,SAAgB,iBACd,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;;;;;;;;AAUjE,SAAgB,mBAAmB,MAA0C;AAC3E,QACE,SAAS,UACT,SAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;;;;;;;;AAUnC,SAAgB,uBACd,MAC8B;AAC9B,QACE,CAAC,CAAC,QACF,OAAO,SAAS,YAChB,UAAU,QACV,YAAY,SAEX,mBAAmB,KAAK,OAA8B,IACpD,KAAK,UAAU,QACd,OAAO,KAAK,WAAW,YACvB,UAAU,KAAK,UACf,OAAO,KAAK,OAAO,SAAS,YAC5B;EAAC;EAAQ;EAAW;EAAU;EAAS;EAAU;EAAS,CAAC,SACzD,KAAK,OAAO,KACb;;;;;;;;;;AAYT,SAAgB,gBAAgB,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY"}

package/dist/utils/testing/index.cjs

@@ -10,7 +10,6 @@ const require_runnables = require('./runnables.cjs');
 const require_tools = require('./tools.cjs');
 const require_tracers = require('./tracers.cjs');
 const require_vectorstores = require('./vectorstores.cjs');
-const require_fake_model_builder = require('./fake_model_builder.cjs');
 
 //#region src/utils/testing/index.ts
 var testing_exports = /* @__PURE__ */ require_runtime.__exportAll({
@@ -29,8 +28,7 @@ var testing_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	FakeTracer: () => require_message_history.FakeTracer,
 	FakeVectorStore: () => require_vectorstores.FakeVectorStore,
 	SingleRunExtractor: () => require_tracers.SingleRunExtractor,
-	SyntheticEmbeddings: () => require_embeddings.SyntheticEmbeddings,
-	fakeModel: () => require_fake_model_builder.fakeModel
+	SyntheticEmbeddings: () => require_embeddings.SyntheticEmbeddings
 });
 
 //#endregion
@@ -50,7 +48,6 @@ exports.FakeTracer = require_message_history.FakeTracer;
 exports.FakeVectorStore = require_vectorstores.FakeVectorStore;
 exports.SingleRunExtractor = require_tracers.SingleRunExtractor;
 exports.SyntheticEmbeddings = require_embeddings.SyntheticEmbeddings;
-exports.fakeModel = require_fake_model_builder.fakeModel;
 Object.defineProperty(exports, 'testing_exports', {
   enumerable: true,
   get: function () {

package/dist/utils/testing/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/utils/testing/index.ts"],"sourcesContent":["export * from \"./chat_models.js\";\nexport * from \"./embeddings.js\";\nexport * from \"./llms.js\";\nexport * from \"./message_history.js\";\nexport * from \"./output_parsers.js\";\nexport * from \"./retrievers.js\";\nexport * from \"./runnables.js\";\nexport * from \"./tools.js\";\nexport * from \"./tracers.js\";\nexport * from \"./vectorstores.js\";\nexport { fakeModel } from \"./fake_model_builder.js\";\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/utils/testing/index.ts"],"sourcesContent":["export * from \"./chat_models.js\";\nexport * from \"./embeddings.js\";\nexport * from \"./llms.js\";\nexport * from \"./message_history.js\";\nexport * from \"./output_parsers.js\";\nexport * from \"./retrievers.js\";\nexport * from \"./runnables.js\";\nexport * from \"./tools.js\";\nexport * from \"./tracers.js\";\nexport * from \"./vectorstores.js\";\n"],"mappings":""}

package/dist/utils/testing/index.d.cts

@@ -8,5 +8,4 @@ import { FakeRunnable } from "./runnables.cjs";
 import { FakeTool, FakeToolParams } from "./tools.cjs";
 import { SingleRunExtractor } from "./tracers.cjs";
 import { FakeVectorStore, FakeVectorStoreArgs } from "./vectorstores.cjs";
-import { fakeModel } from "./fake_model_builder.cjs";
-export { FakeChatInput, FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeListChatModelCallOptions, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingChatModelCallOptions, FakeStreamingChatModelFields, FakeStreamingLLM, FakeTool, FakeToolParams, FakeTracer, FakeVectorStore, FakeVectorStoreArgs, SingleRunExtractor, SyntheticEmbeddings, ToolSpec, fakeModel };
+export { FakeChatInput, FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeListChatModelCallOptions, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingChatModelCallOptions, FakeStreamingChatModelFields, FakeStreamingLLM, FakeTool, FakeToolParams, FakeTracer, FakeVectorStore, FakeVectorStoreArgs, SingleRunExtractor, SyntheticEmbeddings, ToolSpec };

package/dist/utils/testing/index.d.ts

@@ -8,5 +8,4 @@ import { FakeRunnable } from "./runnables.js";
 import { FakeTool, FakeToolParams } from "./tools.js";
 import { SingleRunExtractor } from "./tracers.js";
 import { FakeVectorStore, FakeVectorStoreArgs } from "./vectorstores.js";
-import { fakeModel } from "./fake_model_builder.js";
-export { FakeChatInput, FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeListChatModelCallOptions, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingChatModelCallOptions, FakeStreamingChatModelFields, FakeStreamingLLM, FakeTool, FakeToolParams, FakeTracer, FakeVectorStore, FakeVectorStoreArgs, SingleRunExtractor, SyntheticEmbeddings, ToolSpec, fakeModel };
+export { FakeChatInput, FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeListChatModelCallOptions, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingChatModelCallOptions, FakeStreamingChatModelFields, FakeStreamingLLM, FakeTool, FakeToolParams, FakeTracer, FakeVectorStore, FakeVectorStoreArgs, SingleRunExtractor, SyntheticEmbeddings, ToolSpec };

package/dist/utils/testing/index.js

@@ -9,7 +9,6 @@ import { FakeRunnable } from "./runnables.js";
 import { FakeTool } from "./tools.js";
 import { SingleRunExtractor } from "./tracers.js";
 import { FakeVectorStore } from "./vectorstores.js";
-import { fakeModel } from "./fake_model_builder.js";
 
 //#region src/utils/testing/index.ts
 var testing_exports = /* @__PURE__ */ __exportAll({
@@ -28,10 +27,9 @@ var testing_exports = /* @__PURE__ */ __exportAll({
 	FakeTracer: () => FakeTracer,
 	FakeVectorStore: () => FakeVectorStore,
 	SingleRunExtractor: () => SingleRunExtractor,
-	SyntheticEmbeddings: () => SyntheticEmbeddings,
-	fakeModel: () => fakeModel
+	SyntheticEmbeddings: () => SyntheticEmbeddings
 });
 
 //#endregion
-export { FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingLLM, FakeTool, FakeTracer, FakeVectorStore, SingleRunExtractor, SyntheticEmbeddings, fakeModel, testing_exports };
+export { FakeChatMessageHistory, FakeChatModel, FakeEmbeddings, FakeLLM, FakeListChatMessageHistory, FakeListChatModel, FakeRetriever, FakeRunnable, FakeSplitIntoListParser, FakeStreamingChatModel, FakeStreamingLLM, FakeTool, FakeTracer, FakeVectorStore, SingleRunExtractor, SyntheticEmbeddings, testing_exports };
 //# sourceMappingURL=index.js.map

package/dist/utils/testing/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/utils/testing/index.ts"],"sourcesContent":["export * from \"./chat_models.js\";\nexport * from \"./embeddings.js\";\nexport * from \"./llms.js\";\nexport * from \"./message_history.js\";\nexport * from \"./output_parsers.js\";\nexport * from \"./retrievers.js\";\nexport * from \"./runnables.js\";\nexport * from \"./tools.js\";\nexport * from \"./tracers.js\";\nexport * from \"./vectorstores.js\";\nexport { fakeModel } from \"./fake_model_builder.js\";\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/utils/testing/index.ts"],"sourcesContent":["export * from \"./chat_models.js\";\nexport * from \"./embeddings.js\";\nexport * from \"./llms.js\";\nexport * from \"./message_history.js\";\nexport * from \"./output_parsers.js\";\nexport * from \"./retrievers.js\";\nexport * from \"./runnables.js\";\nexport * from \"./tools.js\";\nexport * from \"./tracers.js\";\nexport * from \"./vectorstores.js\";\n"],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.1.30",
+  "version": "1.1.32",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -37,12 +37,12 @@
     "eslint": "^9.34.0",
     "ml-matrix": "^6.10.4",
     "prettier": "^3.5.0",
-    "rimraf": "^5.0.1",
+    "rimraf": "^6.1.3",
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "web-streams-polyfill": "^4.2.0",
-    "@langchain/tsconfig": "0.0.1",
-    "@langchain/eslint": "0.1.1"
+    "@langchain/eslint": "0.1.1",
+    "@langchain/tsconfig": "0.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -502,6 +502,17 @@
         "default": "./dist/structured_query/index.js"
       }
     },
+    "./testing": {
+      "input": "./src/testing/index.ts",
+      "require": {
+        "types": "./dist/testing/index.d.cts",
+        "default": "./dist/testing/index.cjs"
+      },
+      "import": {
+        "types": "./dist/testing/index.d.ts",
+        "default": "./dist/testing/index.js"
+      }
+    },
     "./tools": {
       "input": "./src/tools/index.ts",
       "require": {
@@ -862,6 +873,7 @@
     "runnables.cjs",
     "runnables.d.ts",
     "runnables.js",
+    "testing",
     "tools.d.cts",
     "tools.cjs",
     "tools.d.ts",

package/dist/utils/testing/fake_model_builder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../../src/utils/testing/fake_model_builder.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../../messages/index.js\";\nimport type { ToolCall } from \"../../messages/tool.js\";\nimport type { ChatResult } from \"../../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../../runnables/base.js\";\nimport { StructuredTool } from \"../../tools/index.js\";\nimport type { InteropZodType } from \"../types/zod.js\";\nimport type { ToolSpec } from \"./chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n *\n * Each builder method queues a model response consumed in order per `invoke()`:\n *\n * `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.\n *\n * `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given\n * tool calls. Content is derived from the input messages automatically.\n *\n * Both can be mixed freely in one chain. When all queued responses are\n * consumed, further invocations throw.\n *\n * Additional configuration:\n * - `.alwaysThrow(error)` — every call throws (overrides the queue)\n * - `.structuredResponse(value)` — value returned by `withStructuredOutput()`\n *\n * The model records all invocations in `.calls` / `.callCount`.\n */\nclass FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _callIndex = 0;\n\n  private _calls: FakeModelCall[] = [];\n\n  get calls(): FakeModelCall[] {\n    return this._calls;\n  }\n\n  get callCount(): number {\n    return this._calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._calls = this._calls;\n    next._callIndex = this._callIndex;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._callIndex;\n    this._callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a fake chat model for testing.\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":"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"}

package/dist/utils/testing/fake_model_builder.d.cts

@@ -1,87 +0,0 @@
-import { BaseMessage } from "../../messages/base.cjs";
-import { AIMessageChunk } from "../../messages/ai.cjs";
-import { MessageStructure, MessageToolSet } from "../../messages/message.cjs";
-import { ChatResult } from "../../outputs.cjs";
-import { InteropZodType } from "../types/zod.cjs";
-import { CallbackManagerForLLMRun } from "../../callbacks/manager.cjs";
-import { Runnable } from "../../runnables/base.cjs";
-import { BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "../../language_models/base.cjs";
-import { StructuredTool } from "../../tools/index.cjs";
-import { BaseChatModel, BaseChatModelCallOptions } from "../../language_models/chat_models.cjs";
-import { ToolSpec } from "./chat_models.cjs";
-
-//#region src/utils/testing/fake_model_builder.d.ts
-type ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;
-interface FakeModelCall {
-  messages: BaseMessage[];
-  options: any;
-}
-/**
- * A fake chat model for testing, created via {@link fakeModel}.
- *
- * Queue responses with `.respond()` and `.respondWithTools()`, then
- * pass the instance directly wherever a chat model is expected.
- *
- * Each builder method queues a model response consumed in order per `invoke()`:
- *
- * `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.
- *
- * `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given
- * tool calls. Content is derived from the input messages automatically.
- *
- * Both can be mixed freely in one chain. When all queued responses are
- * consumed, further invocations throw.
- *
- * Additional configuration:
- * - `.alwaysThrow(error)` — every call throws (overrides the queue)
- * - `.structuredResponse(value)` — value returned by `withStructuredOutput()`
- *
- * The model records all invocations in `.calls` / `.callCount`.
- */
-declare class FakeBuiltModel extends BaseChatModel {
-  private queue;
-  private _alwaysThrowError;
-  private _structuredResponseValue;
-  private _tools;
-  private _callIndex;
-  private _calls;
-  get calls(): FakeModelCall[];
-  get callCount(): number;
-  constructor();
-  _llmType(): string;
-  _combineLLMOutput(): never[];
-  respond(entry: BaseMessage | Error | ResponseFactory): this;
-  respondWithTools(toolCalls: Array<{
-    name: string;
-    args: Record<string, any>;
-    id?: string;
-  }>): this;
-  alwaysThrow(error: Error): this;
-  structuredResponse(value: Record<string, any>): this;
-  bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk<MessageStructure<MessageToolSet>>, BaseChatModelCallOptions>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, boolean> | InteropZodType<RunOutput> | Record<string, any>, _config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
-    raw: BaseMessage;
-    parsed: RunOutput;
-  }>;
-  _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-}
-/**
- * Creates a fake chat model for testing.
- *
- * @example
- * ```typescript
- * const model = fakeModel()
- *   .respondWithTools([{ name: "search", args: { query: "weather" } }])
- *   .respond(new AIMessage("Sunny and warm."));
- *
- * const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
- * // r1.tool_calls[0].name === "search"
- *
- * const r2 = await model.invoke([new HumanMessage("Thanks")]);
- * // r2.content === "Sunny and warm."
- * ```
- */
-declare function fakeModel(): FakeBuiltModel;
-//#endregion
-export { fakeModel };
-//# sourceMappingURL=fake_model_builder.d.cts.map

package/dist/utils/testing/fake_model_builder.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake_model_builder.d.cts","names":[],"sources":["../../../src/utils/testing/fake_model_builder.ts"],"mappings":";;;;;;;;;;;;;KAmBK,eAAA,IAAmB,QAAA,EAAU,WAAA,OAAkB,WAAA,GAAc,KAAA;AAAA,UAQxD,aAAA;EACR,QAAA,EAAU,WAAA;EACV,OAAA;AAAA;;;;;;;;;;;;;;AAVqE;;;;;;;;;cAgDjE,cAAA,SAAuB,aAAA;EAAA,QACnB,KAAA;EAAA,QAEA,iBAAA;EAAA,QAEA,wBAAA;EAAA,QAEA,MAAA;EAAA,QAEA,UAAA;EAAA,QAEA,MAAA;EAAA,IAEJ,KAAA,CAAA,GAAS,aAAA;EAAA,IAIT,SAAA,CAAA;EAIJ,WAAA,CAAA;EAIA,QAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,OAAA,CAAQ,KAAA,EAAO,WAAA,GAAc,KAAA,GAAQ,eAAA;EAWrC,gBAAA,CACE,SAAA,EAAW,KAAA;IAAQ,IAAA;IAAc,IAAA,EAAM,MAAA;IAAqB,EAAA;EAAA;EAc9D,WAAA,CAAY,KAAA,EAAO,KAAA;EAKnB,kBAAA,CAAmB,KAAA,EAAO,MAAA;EAK1B,SAAA,CAAU,KAAA,GAAQ,cAAA,GAAiB,QAAA,MAAW,QAAA,CAAA,sBAAA,EAAA,cAAA,CAAA,gBAAA,CAAA,cAAA,IAAA,wBAAA;EAa9C,oBAAA,mBACoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,OAAA,EACI,4BAAA,CAA6B,SAAA,aAC7B,cAAA,CAAe,SAAA,IACf,MAAA,eACJ,OAAA,GAAU,6BAAA,YAER,QAAA,CAAS,sBAAA,EAAwB,SAAA,IACjC,QAAA,CACE,sBAAA;IACE,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAQ5B,SAAA,CACJ,QAAA,EAAU,WAAA,IACV,OAAA,8BACA,WAAA,GAAc,wBAAA,GACb,OAAA,CAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;iBAyEG,SAAA,CAAA,GAAa,cAAA"}

package/dist/utils/testing/fake_model_builder.d.ts

@@ -1,88 +0,0 @@
-import { BaseMessage } from "../../messages/base.js";
-import { AIMessageChunk } from "../../messages/ai.js";
-import { MessageStructure, MessageToolSet } from "../../messages/message.js";
-import { ChatResult } from "../../outputs.js";
-import { InteropZodType } from "../types/zod.js";
-import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
-import { Runnable } from "../../runnables/base.js";
-import { BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "../../language_models/base.js";
-import "../../messages/index.js";
-import { StructuredTool } from "../../tools/index.js";
-import { BaseChatModel, BaseChatModelCallOptions } from "../../language_models/chat_models.js";
-import { ToolSpec } from "./chat_models.js";
-
-//#region src/utils/testing/fake_model_builder.d.ts
-type ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;
-interface FakeModelCall {
-  messages: BaseMessage[];
-  options: any;
-}
-/**
- * A fake chat model for testing, created via {@link fakeModel}.
- *
- * Queue responses with `.respond()` and `.respondWithTools()`, then
- * pass the instance directly wherever a chat model is expected.
- *
- * Each builder method queues a model response consumed in order per `invoke()`:
- *
- * `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.
- *
- * `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given
- * tool calls. Content is derived from the input messages automatically.
- *
- * Both can be mixed freely in one chain. When all queued responses are
- * consumed, further invocations throw.
- *
- * Additional configuration:
- * - `.alwaysThrow(error)` — every call throws (overrides the queue)
- * - `.structuredResponse(value)` — value returned by `withStructuredOutput()`
- *
- * The model records all invocations in `.calls` / `.callCount`.
- */
-declare class FakeBuiltModel extends BaseChatModel {
-  private queue;
-  private _alwaysThrowError;
-  private _structuredResponseValue;
-  private _tools;
-  private _callIndex;
-  private _calls;
-  get calls(): FakeModelCall[];
-  get callCount(): number;
-  constructor();
-  _llmType(): string;
-  _combineLLMOutput(): never[];
-  respond(entry: BaseMessage | Error | ResponseFactory): this;
-  respondWithTools(toolCalls: Array<{
-    name: string;
-    args: Record<string, any>;
-    id?: string;
-  }>): this;
-  alwaysThrow(error: Error): this;
-  structuredResponse(value: Record<string, any>): this;
-  bindTools(tools: (StructuredTool | ToolSpec)[]): Runnable<BaseLanguageModelInput, AIMessageChunk<MessageStructure<MessageToolSet>>, BaseChatModelCallOptions>;
-  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(_params: StructuredOutputMethodParams<RunOutput, boolean> | InteropZodType<RunOutput> | Record<string, any>, _config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
-    raw: BaseMessage;
-    parsed: RunOutput;
-  }>;
-  _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-}
-/**
- * Creates a fake chat model for testing.
- *
- * @example
- * ```typescript
- * const model = fakeModel()
- *   .respondWithTools([{ name: "search", args: { query: "weather" } }])
- *   .respond(new AIMessage("Sunny and warm."));
- *
- * const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
- * // r1.tool_calls[0].name === "search"
- *
- * const r2 = await model.invoke([new HumanMessage("Thanks")]);
- * // r2.content === "Sunny and warm."
- * ```
- */
-declare function fakeModel(): FakeBuiltModel;
-//#endregion
-export { fakeModel };
-//# sourceMappingURL=fake_model_builder.d.ts.map

package/dist/utils/testing/fake_model_builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake_model_builder.d.ts","names":[],"sources":["../../../src/utils/testing/fake_model_builder.ts"],"mappings":";;;;;;;;;;;;;;KAmBK,eAAA,IAAmB,QAAA,EAAU,WAAA,OAAkB,WAAA,GAAc,KAAA;AAAA,UAQxD,aAAA;EACR,QAAA,EAAU,WAAA;EACV,OAAA;AAAA;AAZ+C;;;;;;;;;;;;;;AAEsB;;;;;;;;AAFtB,cAkD3C,cAAA,SAAuB,aAAA;EAAA,QACnB,KAAA;EAAA,QAEA,iBAAA;EAAA,QAEA,wBAAA;EAAA,QAEA,MAAA;EAAA,QAEA,UAAA;EAAA,QAEA,MAAA;EAAA,IAEJ,KAAA,CAAA,GAAS,aAAA;EAAA,IAIT,SAAA,CAAA;EAIJ,WAAA,CAAA;EAIA,QAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,OAAA,CAAQ,KAAA,EAAO,WAAA,GAAc,KAAA,GAAQ,eAAA;EAWrC,gBAAA,CACE,SAAA,EAAW,KAAA;IAAQ,IAAA;IAAc,IAAA,EAAM,MAAA;IAAqB,EAAA;EAAA;EAc9D,WAAA,CAAY,KAAA,EAAO,KAAA;EAKnB,kBAAA,CAAmB,KAAA,EAAO,MAAA;EAK1B,SAAA,CAAU,KAAA,GAAQ,cAAA,GAAiB,QAAA,MAAW,QAAA,CAAA,sBAAA,EAAA,cAAA,CAAA,gBAAA,CAAA,cAAA,IAAA,wBAAA;EAa9C,oBAAA,mBACoB,MAAA,gBAAsB,MAAA,cAAA,CAExC,OAAA,EACI,4BAAA,CAA6B,SAAA,aAC7B,cAAA,CAAe,SAAA,IACf,MAAA,eACJ,OAAA,GAAU,6BAAA,YAER,QAAA,CAAS,sBAAA,EAAwB,SAAA,IACjC,QAAA,CACE,sBAAA;IACE,GAAA,EAAK,WAAA;IAAa,MAAA,EAAQ,SAAA;EAAA;EAQ5B,SAAA,CACJ,QAAA,EAAU,WAAA,IACV,OAAA,8BACA,WAAA,GAAc,wBAAA,GACb,OAAA,CAAQ,UAAA;AAAA;;;;;;;;;;;;;;;;;iBAyEG,SAAA,CAAA,GAAa,cAAA"}

package/dist/utils/testing/fake_model_builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake_model_builder.js","names":[],"sources":["../../../src/utils/testing/fake_model_builder.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../../messages/index.js\";\nimport type { ToolCall } from \"../../messages/tool.js\";\nimport type { ChatResult } from \"../../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../../runnables/base.js\";\nimport { StructuredTool } from \"../../tools/index.js\";\nimport type { InteropZodType } from \"../types/zod.js\";\nimport type { ToolSpec } from \"./chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n *\n * Each builder method queues a model response consumed in order per `invoke()`:\n *\n * `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.\n *\n * `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given\n * tool calls. Content is derived from the input messages automatically.\n *\n * Both can be mixed freely in one chain. When all queued responses are\n * consumed, further invocations throw.\n *\n * Additional configuration:\n * - `.alwaysThrow(error)` — every call throws (overrides the queue)\n * - `.structuredResponse(value)` — value returned by `withStructuredOutput()`\n *\n * The model records all invocations in `.calls` / `.callCount`.\n */\nclass FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _callIndex = 0;\n\n  private _calls: FakeModelCall[] = [];\n\n  get calls(): FakeModelCall[] {\n    return this._calls;\n  }\n\n  get callCount(): number {\n    return this._calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._calls = this._calls;\n    next._callIndex = this._callIndex;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._callIndex;\n    this._callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a fake chat model for testing.\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":"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"}