@langchain/core 1.0.1 → 1.0.3

package/dist/tools/types.d.cts

@@ -1,11 +1,12 @@
 import { MessageContent } from "../messages/base.cjs";
 import { DirectToolOutput, ToolCall, ToolMessage } from "../messages/tool.cjs";
-import { InferInteropZodInput, InferInteropZodOutput, InteropZodType } from "../utils/types/zod.cjs";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType } from "../utils/types/zod.cjs";
 import { CallbackManagerForToolRun } from "../callbacks/manager.cjs";
 import { RunnableConfig, RunnableInterface } from "../runnables/types.cjs";
 import { RunnableToolLike } from "../runnables/base.cjs";
 import { JsonSchema7Type } from "../utils/zod-to-json-schema/parseTypes.cjs";
 import { BaseLangChainParams, ToolDefinition } from "../language_models/base.cjs";
+import { BaseStore } from "../stores.cjs";
 import { z } from "zod/v3";
 
 //#region src/tools/types.d.ts
@@ -282,6 +283,97 @@ declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolP
  * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
  */
 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
+/**
+ * Runtime context automatically injected into tools.
+ *
+ * When a tool function has a parameter named `tool_runtime` with type hint
+ * `ToolRuntime`, the tool execution system will automatically inject an instance
+ * containing:
+ *
+ * - `state`: The current graph state
+ * - `toolCallId`: The ID of the current tool call
+ * - `config`: `RunnableConfig` for the current execution
+ * - `context`: Runtime context
+ * - `store`: `BaseStore` instance for persistent storage
+ * - `writer`: Stream writer for streaming output
+ *
+ * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`
+ * as a parameter.
+ *
+ * @example
+ * ```typescript
+ * import { tool, ToolRuntime } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const stateSchema = z.object({
+ *   messages: z.array(z.any()),
+ *   userId: z.string().optional(),
+ * });
+ *
+ * const greet = tool(
+ *   async ({ name }, runtime) => {
+ *     // Access state
+ *     const messages = runtime.state.messages;
+ *
+ *     // Access tool_call_id
+ *     console.log(`Tool call ID: ${runtime.toolCallId}`);
+ *
+ *     // Access config
+ *     console.log(`Run ID: ${runtime.config.runId}`);
+ *
+ *     // Access runtime context
+ *     const userId = runtime.context?.userId;
+ *
+ *     // Access store
+ *     await runtime.store?.mset([["key", "value"]]);
+ *
+ *     // Stream output
+ *     runtime.writer?.("Processing...");
+ *
+ *     return `Hello! User ID: ${runtime.state.userId || "unknown"} ${name}`;
+ *   },
+ *   {
+ *     name: "greet",
+ *     description: "Use this to greet the user once you found their info.",
+ *     schema: z.object({ name: z.string() }),
+ *     stateSchema,
+ *   }
+ * );
+ * ```
+ *
+ * @template StateT - The type of the state schema (inferred from stateSchema)
+ * @template ContextT - The type of the context schema (inferred from contextSchema)
+ */
+type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {
+  /**
+   * The current graph state.
+   */
+  state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;
+  /**
+   * The ID of the current tool call.
+   */
+  toolCallId: string;
+  /**
+   * The current tool call.
+   */
+  toolCall?: ToolCall;
+  /**
+   * RunnableConfig for the current execution.
+   */
+  config: ToolRunnableConfig;
+  /**
+   * Runtime context (from langgraph `Runtime`).
+   */
+  context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;
+  /**
+   * BaseStore instance for persistent storage (from langgraph `Runtime`).
+   */
+  store: BaseStore<string, unknown> | null;
+  /**
+   * Stream writer for streaming output (from langgraph `Runtime`).
+   */
+  writer: ((chunk: unknown) => void) | null;
+};
 //#endregion
-export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, ToolRuntime, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
 //# sourceMappingURL=types.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","JSONSchema","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\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> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\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 * 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}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\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 ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\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 ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\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<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\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> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\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 * 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<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> 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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\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<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> 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: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\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 declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\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 declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\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 declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\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 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\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> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\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 * 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}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\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 ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\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 ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\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<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\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> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\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 * 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<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> 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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\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<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> 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: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\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 declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\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 declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\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 declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\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 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\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, 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) => {\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 *\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<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : 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 ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : 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":"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"}

package/dist/tools/types.d.ts

@@ -1,11 +1,12 @@
 import { MessageContent } from "../messages/base.js";
 import { DirectToolOutput, ToolCall, ToolMessage } from "../messages/tool.js";
-import { InferInteropZodInput, InferInteropZodOutput, InteropZodType } from "../utils/types/zod.js";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType } from "../utils/types/zod.js";
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import { RunnableConfig, RunnableInterface } from "../runnables/types.js";
 import { RunnableToolLike } from "../runnables/base.js";
 import { JsonSchema7Type } from "../utils/zod-to-json-schema/parseTypes.js";
 import { BaseLangChainParams, ToolDefinition } from "../language_models/base.js";
+import { BaseStore } from "../stores.js";
 import { z } from "zod/v3";
 
 //#region src/tools/types.d.ts
@@ -282,6 +283,97 @@ declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolP
  * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
  */
 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
+/**
+ * Runtime context automatically injected into tools.
+ *
+ * When a tool function has a parameter named `tool_runtime` with type hint
+ * `ToolRuntime`, the tool execution system will automatically inject an instance
+ * containing:
+ *
+ * - `state`: The current graph state
+ * - `toolCallId`: The ID of the current tool call
+ * - `config`: `RunnableConfig` for the current execution
+ * - `context`: Runtime context
+ * - `store`: `BaseStore` instance for persistent storage
+ * - `writer`: Stream writer for streaming output
+ *
+ * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`
+ * as a parameter.
+ *
+ * @example
+ * ```typescript
+ * import { tool, ToolRuntime } from "@langchain/core/tools";
+ * import { z } from "zod";
+ *
+ * const stateSchema = z.object({
+ *   messages: z.array(z.any()),
+ *   userId: z.string().optional(),
+ * });
+ *
+ * const greet = tool(
+ *   async ({ name }, runtime) => {
+ *     // Access state
+ *     const messages = runtime.state.messages;
+ *
+ *     // Access tool_call_id
+ *     console.log(`Tool call ID: ${runtime.toolCallId}`);
+ *
+ *     // Access config
+ *     console.log(`Run ID: ${runtime.config.runId}`);
+ *
+ *     // Access runtime context
+ *     const userId = runtime.context?.userId;
+ *
+ *     // Access store
+ *     await runtime.store?.mset([["key", "value"]]);
+ *
+ *     // Stream output
+ *     runtime.writer?.("Processing...");
+ *
+ *     return `Hello! User ID: ${runtime.state.userId || "unknown"} ${name}`;
+ *   },
+ *   {
+ *     name: "greet",
+ *     description: "Use this to greet the user once you found their info.",
+ *     schema: z.object({ name: z.string() }),
+ *     stateSchema,
+ *   }
+ * );
+ * ```
+ *
+ * @template StateT - The type of the state schema (inferred from stateSchema)
+ * @template ContextT - The type of the context schema (inferred from contextSchema)
+ */
+type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {
+  /**
+   * The current graph state.
+   */
+  state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;
+  /**
+   * The ID of the current tool call.
+   */
+  toolCallId: string;
+  /**
+   * The current tool call.
+   */
+  toolCall?: ToolCall;
+  /**
+   * RunnableConfig for the current execution.
+   */
+  config: ToolRunnableConfig;
+  /**
+   * Runtime context (from langgraph `Runtime`).
+   */
+  context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;
+  /**
+   * BaseStore instance for persistent storage (from langgraph `Runtime`).
+   */
+  store: BaseStore<string, unknown> | null;
+  /**
+   * Stream writer for streaming output (from langgraph `Runtime`).
+   */
+  writer: ((chunk: unknown) => void) | null;
+};
 //#endregion
-export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, ToolRuntime, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","JSONSchema","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\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> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\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 * 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}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\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 ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\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 ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\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<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\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> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\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 * 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<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> 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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\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<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> 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: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\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 declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\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 declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\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 declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\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 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\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> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\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 * 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}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\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 ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\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 ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\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<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\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> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\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<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\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 * 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<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> 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<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\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<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> 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: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\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 declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\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 declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\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 declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\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 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\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, 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) => {\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 *\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<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : 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 ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : 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":"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"}

package/dist/tools/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["tool?: StructuredToolInterface | ToolDefinition | JSONSchema","tool?: unknown"],"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} from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.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\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\n  extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\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/**\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<ToolOutputT = ToolOutputType>\n  extends BaseDynamicToolInput {\n  func: (\n    input: string,\n    runManager?: CallbackManagerForToolRun,\n    config?: ToolRunnableConfig\n  ) => Promise<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>;\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"],"mappings":";;;;;;;;;;AAwWA,SAAgB,iBACdA,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;AAEhE;;;;;;;AAQD,SAAgB,mBAAmBC,MAA0C;AAC3E,QACE,SAAS,UACT,SAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;AAElC;;;;;;;AAQD,SAAgB,uBACdA,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;CAAS,EAAC,SACzD,KAAK,OAAO,KACb;AAER;;;;;;;;;AAUD,SAAgB,gBAAgBA,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY;AAEhC"}
+{"version":3,"file":"types.js","names":["tool?: StructuredToolInterface | ToolDefinition | JSONSchema","tool?: unknown"],"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\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\n  extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\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/**\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<ToolOutputT = ToolOutputType>\n  extends BaseDynamicToolInput {\n  func: (\n    input: string,\n    runManager?: CallbackManagerForToolRun,\n    config?: ToolRunnableConfig\n  ) => Promise<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>;\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, 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) => {\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 *\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":";;;;;;;;;;AA2WA,SAAgB,iBACdA,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;AAEhE;;;;;;;AAQD,SAAgB,mBAAmBC,MAA0C;AAC3E,QACE,SAAS,UACT,SAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;AAElC;;;;;;;AAQD,SAAgB,uBACdA,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;CAAS,EAAC,SACzD,KAAK,OAAO,KACb;AAER;;;;;;;;;AAUD,SAAgB,gBAAgBA,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY;AAEhC"}

package/dist/utils/async_caller.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"async_caller.d.cts","names":["FailedAttemptHandler","AsyncCallerParams","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","Promise","T","Parameters","ReturnType","Awaited","fetch"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FailedAttemptHandler = (error: any) => any;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    /**\n     * Custom handler to handle failed attempts. Takes the originally thrown\n     * error object as input, and should itself throw an error if the input\n     * error is not retryable.\n     */\n    onFailedAttempt?: FailedAttemptHandler;\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 6. This\n * means that by default, each call will be retried up to 6 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    protected onFailedAttempt: AsyncCallerParams[\"onFailedAttempt\"];\n    private queue;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\n"],"mappings":";;AACYA,KAAAA,oBAAAA,GAAoB,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,GAAA;AACfC,UAAAA,iBAAAA,CAgBKD;EAELE;AAgBjB;;;EAC+C,cACrBD,CAAAA,EAAAA,MAAAA;EAAiB;;;;EAKgB,UAAiBM,CAAAA,EAAAA,MAAAA;EAAC;;;;;EAA0C,eAAfD,CAAAA,EAzBlFN,oBAyBkFM;;AAEzCA,UAzB9CJ,sBAAAA,CAyB8CI;EAAO,MAAgBJ,CAAAA,EAxBzEC,WAwByED;;;;;;;;;;;;AAC9B;;;cAVnCE,WAAAA;4BACSH;wBACJA;6BACKA;;sBAEPA;;4CAEsBI,MAAMC,wBAAwBC,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;;uDAE1EF,MAAMC,uBAAuBJ,kCAAkCK,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;iBAC5JC,kBAAkBG,SAASF,kBAAkBE"}
+{"version":3,"file":"async_caller.d.cts","names":["FailedAttemptHandler","AsyncCallerParams","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","Promise","T","Parameters","ReturnType","Awaited","fetch"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FailedAttemptHandler = (error: any) => any;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    /**\n     * Custom handler to handle failed attempts. Takes the originally thrown\n     * error object as input, and should itself throw an error if the input\n     * error is not retryable.\n     */\n    onFailedAttempt?: FailedAttemptHandler;\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 6. This\n * means that by default, each call will be retried up to 6 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    protected onFailedAttempt: AsyncCallerParams[\"onFailedAttempt\"];\n    private queue;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\n"],"mappings":";;AACYA,KAAAA,oBAAAA,GAAoB,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,GAAA;AACfC,UAAAA,iBAAAA,CAAiB;EAkBjBC;AAgBjB;;;EAC+C,cACrBD,CAAAA,EAAAA,MAAAA;EAAiB;;;;EAKgB,UAAiBM,CAAAA,EAAAA,MAAAA;EAAC;;;;;EAA0C,eAAfD,CAAAA,EAzBlFN,oBAyBkFM;;AAEzCA,UAzB9CJ,sBAAAA,CAyB8CI;EAAO,MAAgBJ,CAAAA,EAxBzEC,WAwByED;;;;;;;;;;;;AAC9B;;;cAVnCE,WAAAA;4BACSH;wBACJA;6BACKA;;sBAEPA;;4CAEsBI,MAAMC,wBAAwBC,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;;uDAE1EF,MAAMC,uBAAuBJ,kCAAkCK,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;iBAC5JC,kBAAkBG,SAASF,kBAAkBE"}

package/dist/utils/async_caller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async_caller.d.ts","names":["FailedAttemptHandler","AsyncCallerParams","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","Promise","T","Parameters","ReturnType","Awaited","fetch"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FailedAttemptHandler = (error: any) => any;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    /**\n     * Custom handler to handle failed attempts. Takes the originally thrown\n     * error object as input, and should itself throw an error if the input\n     * error is not retryable.\n     */\n    onFailedAttempt?: FailedAttemptHandler;\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 6. This\n * means that by default, each call will be retried up to 6 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    protected onFailedAttempt: AsyncCallerParams[\"onFailedAttempt\"];\n    private queue;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\n"],"mappings":";;AACYA,KAAAA,oBAAAA,GAAoB,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,GAAA;AACfC,UAAAA,iBAAAA,CAgBKD;EAELE;AAgBjB;;;EAC+C,cACrBD,CAAAA,EAAAA,MAAAA;EAAiB;;;;EAKgB,UAAiBM,CAAAA,EAAAA,MAAAA;EAAC;;;;;EAA0C,eAAfD,CAAAA,EAzBlFN,oBAyBkFM;;AAEzCA,UAzB9CJ,sBAAAA,CAyB8CI;EAAO,MAAgBJ,CAAAA,EAxBzEC,WAwByED;;;;;;;;;;;;AAC9B;;;cAVnCE,WAAAA;4BACSH;wBACJA;6BACKA;;sBAEPA;;4CAEsBI,MAAMC,wBAAwBC,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;;uDAE1EF,MAAMC,uBAAuBJ,kCAAkCK,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;iBAC5JC,kBAAkBG,SAASF,kBAAkBE"}
+{"version":3,"file":"async_caller.d.ts","names":["FailedAttemptHandler","AsyncCallerParams","AsyncCallerCallOptions","AbortSignal","AsyncCaller","A","Promise","T","Parameters","ReturnType","Awaited","fetch"],"sources":["../../src/utils/async_caller.d.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FailedAttemptHandler = (error: any) => any;\nexport interface AsyncCallerParams {\n    /**\n     * The maximum number of concurrent calls that can be made.\n     * Defaults to `Infinity`, which means no limit.\n     */\n    maxConcurrency?: number;\n    /**\n     * The maximum number of retries that can be made for a single call,\n     * with an exponential backoff between each attempt. Defaults to 6.\n     */\n    maxRetries?: number;\n    /**\n     * Custom handler to handle failed attempts. Takes the originally thrown\n     * error object as input, and should itself throw an error if the input\n     * error is not retryable.\n     */\n    onFailedAttempt?: FailedAttemptHandler;\n}\nexport interface AsyncCallerCallOptions {\n    signal?: AbortSignal;\n}\n/**\n * A class that can be used to make async calls with concurrency and retry logic.\n *\n * This is useful for making calls to any kind of \"expensive\" external resource,\n * be it because it's rate-limited, subject to network issues, etc.\n *\n * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults\n * to `Infinity`. This means that by default, all calls will be made in parallel.\n *\n * Retries are limited by the `maxRetries` parameter, which defaults to 6. This\n * means that by default, each call will be retried up to 6 times, with an\n * exponential backoff between each attempt.\n */\nexport declare class AsyncCaller {\n    protected maxConcurrency: AsyncCallerParams[\"maxConcurrency\"];\n    protected maxRetries: AsyncCallerParams[\"maxRetries\"];\n    protected onFailedAttempt: AsyncCallerParams[\"onFailedAttempt\"];\n    private queue;\n    constructor(params: AsyncCallerParams);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;\n    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;\n}\n"],"mappings":";;AACYA,KAAAA,oBAAAA,GAAoB,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,GAAA;AACfC,UAAAA,iBAAAA,CAAiB;EAkBjBC;AAgBjB;;;EAC+C,cACrBD,CAAAA,EAAAA,MAAAA;EAAiB;;;;EAKgB,UAAiBM,CAAAA,EAAAA,MAAAA;EAAC;;;;;EAA0C,eAAfD,CAAAA,EAzBlFN,oBAyBkFM;;AAEzCA,UAzB9CJ,sBAAAA,CAyB8CI;EAAO,MAAgBJ,CAAAA,EAxBzEC,WAwByED;;;;;;;;;;;;AAC9B;;;cAVnCE,WAAAA;4BACSH;wBACJA;6BACKA;;sBAEPA;;4CAEsBI,MAAMC,wBAAwBC,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;;uDAE1EF,MAAMC,uBAAuBJ,kCAAkCK,YAAYC,WAAWD,KAAKD,QAAQI,QAAQD,WAAWF;iBAC5JC,kBAAkBG,SAASF,kBAAkBE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {