@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/tools/types.d.cts

@@ -1,17 +1,19 @@
 import { MessageContent } from "../messages/base.cjs";
 import { DirectToolOutput, ToolCall, ToolMessage } from "../messages/tool.cjs";
-import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType } from "../utils/types/zod.cjs";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType, ZodV3Like } 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
 type ResponseFormat = "content" | "content_and_artifact" | string;
 type ToolOutputType = any;
+type ToolEventType = unknown;
+type InferToolEventFromFunc<F> = F extends ((...args: any[]) => AsyncGenerator<infer Y, any, any>) ? Y : ToolEventType;
+type InferToolOutputFromFunc<F> = F extends ((...args: any[]) => AsyncGenerator<any, infer R, any>) ? R : F extends ((...args: any[]) => Promise<infer R>) ? R : F extends ((...args: any[]) => infer R) ? R : ToolOutputType;
 type ContentAndArtifact = [MessageContent, any];
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
@@ -36,7 +38,7 @@ type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput
  * Base type that establishes the types of input schemas that can be used for LangChain tool
  * definitions.
  */
-type ToolInputSchemaBase = z.ZodTypeAny | JsonSchema7Type;
+type ToolInputSchemaBase = InteropZodType | JsonSchema7Type;
 /**
  * Parameters for the Tool classes.
  */
@@ -128,7 +130,7 @@ type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolI
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef, any>;
+type StringInputToolSchema = ZodV3Like<string | undefined, any>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -163,6 +165,7 @@ interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT =
    * @returns A Promise that resolves with a string.
    */
   call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, /** @deprecated */
+
   tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
   /**
    * The name of the tool.
@@ -222,17 +225,22 @@ interface BaseDynamicToolInput extends ToolParams {
 }
 /**
  * Interface for the input parameters of the DynamicTool class.
+ *
+ * @param ToolOutputT - The return type of the tool.
+ * @param ToolEventT - The type of values yielded by the tool when using an async generator.
  */
-interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
-  func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;
+interface DynamicToolInput<ToolOutputT = ToolOutputType, ToolEventT = ToolEventType> extends BaseDynamicToolInput {
+  func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;
 }
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
  *
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @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.
+ * @param ToolOutputT - The return type of the tool.
+ * @param ToolEventT - The type of values yielded by the tool when using an async generator.
  */
-interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType, ToolEventT = ToolEventType> extends BaseDynamicToolInput {
   /**
    * Tool handler function - the function that will be called when the tool is invoked.
    *
@@ -241,7 +249,7 @@ interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutput
    * @param config - The configuration for the tool.
    * @returns The result of the tool.
    */
-  func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;
+  func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;
   schema: SchemaT;
 }
 /**
@@ -293,7 +301,7 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  *
  * @example
  * ```typescript
- * import { tool, ToolRuntime } from "@langchain/core/tools";
+ * import { tool, type ToolRuntime } from "@langchain/core/tools";
  * import { z } from "zod";
  *
  * const stateSchema = z.object({
@@ -302,7 +310,7 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  * });
  *
  * const greet = tool(
- *   async ({ name }, runtime) => {
+ *   async ({ name }, runtime: ToolRuntime<typeof stateSchema>) => {
  *     // Access state
  *     const messages = runtime.state.messages;
  *
@@ -330,6 +338,13 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  *     stateSchema,
  *   }
  * );
+ *
+ * const agent = createAgent({
+ *   model,
+ *   tools: [greet],
+ *   stateSchema,
+ *   contextSchema,
+ * });
  * ```
  *
  * @template StateT - The type of the state schema (inferred from stateSchema)
@@ -366,5 +381,5 @@ type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {
   writer: ((chunk: unknown) => void) | null;
 };
 //#endregion
-export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, ToolRuntime, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, InferToolEventFromFunc, InferToolOutputFromFunc, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolEventType, 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","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TInput","TConfig","TOutput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","TArg","ToolOutputT","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;\nexport type ToolOutputType = 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    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = 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\" | \"extras\"> {\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, any>;\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     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\n/**\n * 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>(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//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/tools/types.ts"],"mappings":"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"}

package/dist/tools/types.d.ts

@@ -1,19 +1,19 @@
 import { MessageContent } from "../messages/base.js";
 import { DirectToolOutput, ToolCall, ToolMessage } from "../messages/tool.js";
-import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType } from "../utils/types/zod.js";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject, InteropZodType, ZodV3Like } from "../utils/types/zod.js";
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import { RunnableConfig, RunnableInterface } from "../runnables/types.js";
-import "../runnables/config.js";
 import { RunnableToolLike } from "../runnables/base.js";
 import { JsonSchema7Type } from "../utils/zod-to-json-schema/parseTypes.js";
-import "../utils/json_schema.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
 type ResponseFormat = "content" | "content_and_artifact" | string;
 type ToolOutputType = any;
+type ToolEventType = unknown;
+type InferToolEventFromFunc<F> = F extends ((...args: any[]) => AsyncGenerator<infer Y, any, any>) ? Y : ToolEventType;
+type InferToolOutputFromFunc<F> = F extends ((...args: any[]) => AsyncGenerator<any, infer R, any>) ? R : F extends ((...args: any[]) => Promise<infer R>) ? R : F extends ((...args: any[]) => infer R) ? R : ToolOutputType;
 type ContentAndArtifact = [MessageContent, any];
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
@@ -38,7 +38,7 @@ type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput
  * Base type that establishes the types of input schemas that can be used for LangChain tool
  * definitions.
  */
-type ToolInputSchemaBase = z.ZodTypeAny | JsonSchema7Type;
+type ToolInputSchemaBase = InteropZodType | JsonSchema7Type;
 /**
  * Parameters for the Tool classes.
  */
@@ -130,7 +130,7 @@ type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolI
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef, any>;
+type StringInputToolSchema = ZodV3Like<string | undefined, any>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -165,6 +165,7 @@ interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT =
    * @returns A Promise that resolves with a string.
    */
   call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, /** @deprecated */
+
   tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
   /**
    * The name of the tool.
@@ -224,17 +225,22 @@ interface BaseDynamicToolInput extends ToolParams {
 }
 /**
  * Interface for the input parameters of the DynamicTool class.
+ *
+ * @param ToolOutputT - The return type of the tool.
+ * @param ToolEventT - The type of values yielded by the tool when using an async generator.
  */
-interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
-  func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;
+interface DynamicToolInput<ToolOutputT = ToolOutputType, ToolEventT = ToolEventType> extends BaseDynamicToolInput {
+  func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;
 }
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
  *
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @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.
+ * @param ToolOutputT - The return type of the tool.
+ * @param ToolEventT - The type of values yielded by the tool when using an async generator.
  */
-interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType, ToolEventT = ToolEventType> extends BaseDynamicToolInput {
   /**
    * Tool handler function - the function that will be called when the tool is invoked.
    *
@@ -243,7 +249,7 @@ interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutput
    * @param config - The configuration for the tool.
    * @returns The result of the tool.
    */
-  func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;
+  func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT> | AsyncGenerator<ToolEventT, ToolOutputT>;
   schema: SchemaT;
 }
 /**
@@ -295,7 +301,7 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  *
  * @example
  * ```typescript
- * import { tool, ToolRuntime } from "@langchain/core/tools";
+ * import { tool, type ToolRuntime } from "@langchain/core/tools";
  * import { z } from "zod";
  *
  * const stateSchema = z.object({
@@ -304,7 +310,7 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  * });
  *
  * const greet = tool(
- *   async ({ name }, runtime) => {
+ *   async ({ name }, runtime: ToolRuntime<typeof stateSchema>) => {
  *     // Access state
  *     const messages = runtime.state.messages;
  *
@@ -332,6 +338,13 @@ declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
  *     stateSchema,
  *   }
  * );
+ *
+ * const agent = createAgent({
+ *   model,
+ *   tools: [greet],
+ *   stateSchema,
+ *   contextSchema,
+ * });
  * ```
  *
  * @template StateT - The type of the state schema (inferred from stateSchema)
@@ -368,5 +381,5 @@ type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {
   writer: ((chunk: unknown) => void) | null;
 };
 //#endregion
-export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, ToolRuntime, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, InferToolEventFromFunc, InferToolOutputFromFunc, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolEventType, 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","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TInput","TConfig","TOutput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","TArg","ToolOutputT","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;\nexport type ToolOutputType = 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    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = 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\" | \"extras\"> {\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, any>;\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     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n}\n/**\n * 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>(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//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;;;KAUYkB,cAAAA;KACAC,cAAAA;KACAC,kBAAAA,IAAsBT;;AAFlC;AACA;AACA;AAOA;;AAAuEH,KAA3Da,cAA2Db,CAAAA,MAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAAhBgB,OAAgBhB,SAAAA,gBAAAA,GAAmBgB,OAAnBhB,GAA6Be,OAA7Bf,SAAAA;EAAmBgB,QAAAA,EAAAA;IAAUD,EAAAA,EAAAA,MAAAA;EAIhGb,CAAAA;CAAca,GAAdb,WAAca,GAAAA,OAAAA,SAAAA;EAIdC,QAAAA,EAAAA;IAAUD,EAAAA,EAAAA,SAAAA;EAIVC,CAAAA;CAAUd,GAJVc,OAIUd,GAJAa,OAIAb,SAAAA;EAAcY,QAAAA,EAAAA;IAAeb,EAAAA,CAAAA,EAAAA,MAAAA;EAAWC,CAAAA;CAAcc,GAAhEA,OAAgEA,GAAtDd,WAAsDc,GAAxCF,MAAwCE,SAAzBf,QAAyBe,GAAdd,WAAcc,GAAAA,OAAAA;AAAO;AAK3E;AAIA;;AAcoBI,KAlBRH,mBAAAA,GAAsBxB,CAAAA,CAAGyB,UAkBjBE,GAlB8BZ,eAkB9BY;;;;AAdmC,UAAtCD,UAAAA,SAAmBxB,mBAAmB,CAAA;EAiC3CyB;;;;;;;AAEe;AAO3B;EAiBYO,cAAAA,CAAAA,EAjDSjB,cAiDgB;EAAMkB;;;EAA2BvB,aAAAA,CAAAA,EA7ClDe,kBA6CkDf;EAA2BuB;;AAAoB;AAYrH;;EAAoDtB,oBAAAA,CAAAA,EAAAA,OAAAA;EAAsCsB;;;EAAepB,QAAAA,CAAAA,EA/C1Fa,MA+C0Fb,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAU;AAOnH;;;;;EAAwHmB,MAAAA,CAAAA,EA/C3GN,MA+C2GM,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;AAAqF1B,KA7CjMmB,kBA6CiMnB,CAAAA,8BA7ChJoB,MA6CgJpB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GA7C1HoB,MA6C0HpB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,gBAAAA,GAAAA,CAAAA,GA7C9EJ,cA6C8EI,CA7C/DqB,qBA6C+DrB,CAAAA,GAAAA;EAAQ,QAAA,CAAA,EA5CtMA,QA4CsM;EAUzMgC,OAAAA,CAAAA,EArDEV,aAqDFU;AAuBZ,CAAA;;;;;;AAAmND,UArElMR,oBAAAA,SAA6BE,IAqEqKM,CArEhKP,uBAqEgKO,EAAAA,MAAAA,GAAAA,QAAAA,GAAAA,QAAAA,CAAAA,CAAAA;EAAjCF;;;EAKtKC,WAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;;;;;;AAmB2CC,KA5E3CL,yBA4E2CK,CAAAA,CAAAA,CAAAA,GA5EZJ,CA4EYI,SA5EF1B,cA4EE0B,GA5Ee3B,qBA4Ef2B,CA5EqCJ,CA4ErCI,CAAAA,GA5E0CJ,CA4E1CI,SA5EoDxB,eA4EpDwB,GAAAA,OAAAA,GAAAA,KAAAA;;;;;;;;;;;;AAxB0H,KAxCrKH,wBAwCqK,CAAA,CAAA,CAAA,GAxCvID,CAwCuI,SAxC7HtB,cAwC6H,GAxC5GF,oBAwC4G,CAxCvFwB,CAwCuF,CAAA,GAxClFA,CAwCkF,SAxCxEpB,eAwCwE,GAAA,OAAA,GAAA,KAAA;AAwDjL;;;;;;AAAyLwB,KAzF7KF,uBAyF6KE,CAAAA,UAzF3If,mBAyF2Ie,EAAAA,eAzFvGH,wBAyFuGG,CAzF9ED,OAyF8EC,CAAAA,CAAAA,GAAAA,CAzFjEL,yBAyFiEK,CAzFvCD,OAyFuCC,CAAAA,SAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA,CAAAA,GAzFKA,YAyFLA,GAzFoB/B,QAyFpB+B;;;;;;;;;;AAUQjB,KAzFrLkB,qBAAAA,GAAwBxC,CAAAA,CAAG0C,OAyF0JpB,CAAAA,MAAAA,GAAAA,SAAAA,EAzF9HtB,CAAAA,CAAGyC,UAyF2HnB,EAAAA,GAAAA,CAAAA;AAoBrG;AAS5F;;;;;;;;AAS6GuB,UAxG5Fb,uBAwG4Fa,CAAAA,UAxG1DrB,mBAwG0DqB,EAAAA,eAxGtBT,wBAwGsBS,CAxGGP,OAwGHO,CAAAA,EAAAA,cAxG2B3B,cAwG3B2B,CAAAA,SAxGmDvC,iBAwGnDuC,CAxGqER,uBAwGrEQ,CAxG6FP,OAwG7FO,EAxGsGN,YAwGtGM,CAAAA,EAxGqHA,WAwGrHA,GAxGmIpC,WAwGnIoC,CAAAA,CAAAA;EAARC,YAAAA,EAAAA,MAAAA,EAAAA;EACzFR;;AAV6K;EAkBjKe,MAAAA,EA5GZf,OA4GYe;EAAwBrB;;;;AAAuF;AAOvI;EAOwBuB,MAAAA,CAAAA,aAnHAlB,uBAmHgDN,CAnHxBO,OAmHwBP,EAnHfQ,YAmHmC,CAAA,EAAA,gBAnHJZ,kBAmHI,GAAA,SAAA,CAAA,CAAA,GAAA,EAnHiCiB,IAmHjC,EAAA,SAAA,CAAA,EAnHmDtB,OAmHnD,CAAA,EAnH6DwB,OAmH7D,CAnHqE1B,cAmHrE,CAnHoFwB,IAmHpF,EAnH0FtB,OAmH1F,EAnHmGuB,WAmHnG,CAAA,CAAA;EASpEW;AA8DxB;;;;;;;;;;EAgBY7B,IAAAA,CAAAA,aA9LUU,uBA8LVV,CA9LkCW,OA8LlCX,EA9L2CY,YA8L3CZ,CAAAA,EAAAA,gBA9L0EA,kBA8L1EA,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EA9L+GiB,IA8L/GjB,EAAAA,SAAAA,CAAAA,EA9LiIL,OA8LjIK,EAICgC;EAAiB7C,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAhMRgC,OAgMQhC,CAhMAM,cAgMAN,CAhMe8B,IAgMf9B,EAhMqBQ,OAgMrBR,EAhM8B+B,WAgM9B/B,CAAAA,CAAAA;EAAyC6C;;;EAA6B/B,IAAAA,EAAAA,MAAAA;EAA0B+B;;AAI1G;;;;;;;;;;;;;;;WA9KP/B;;;;;;;;UAQImB,wBAAwBP,sCAAsCJ,yBAAyBE,wBAAwBpB,wBAAwBc,wBAAwBM,SAASC,cAAcM;;;;;;;;;;oBAUjLR,wBAAwBC,SAASC,+BAA+BZ,qCAAqCiB,kBAAkBtB,UAAUwB,QAAQ1B,eAAe4B,YAAYJ,OAAOtB,SAASuB;;;;;;UAMzLI,oBAAAA,SAA6BvB;;;;;;;;;;;;;;UAc7BwB,+BAA+BhC,wBAAwB+B;qCACjChD,oCAAoC0B,uBAAuBmB,QAAQD;;;;;;;;UAQzFM,qCAAqC3B,qCAAqCU,0BAA0BI,wBAAwBpB,wBAAwB+B;;;;;;;;;gBASnJG,4BAA4BnD,oCAAoCG,mBAAmB0C,QAAQD;UACjGP;;;;;;;;iBAQYe,gBAAAA,QAAwBrB,0BAA0B7B,iBAAiBY,0BAAqBiB;;;;;;;iBAOxFsB,kBAAAA,0BAA4CjD;;;;;;;iBAO5CkD,sBAAAA,0BAAgDxB;;;;;;;;;iBAShDyB,eAAAA,0BAAyCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8DrD0B,oDAAoDrD;;;;SAIrDsD,eAAe5C,mBAAmBF,sBAAsB8C,UAAUA,eAAe9B,0BAA0B8B;;;;;;;;aAQvGlD;;;;UAIHmB;;;;WAICgC,iBAAiB7C,mBAAmBF,sBAAsB+C,YAAYA,iBAAiB/B,0BAA0B+B;;;;SAInH3C"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/tools/types.ts"],"mappings":"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"}

package/dist/tools/types.js

@@ -1,6 +1,5 @@
 import { isInteropZodSchema } from "../utils/types/zod.js";
 import { Runnable } from "../runnables/base.js";
-
 //#region src/tools/types.ts
 /**
 * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
@@ -47,7 +46,7 @@ function isStructuredToolParams(tool) {
 function isLangChainTool(tool) {
 	return isStructuredToolParams(tool) || isRunnableToolLike(tool) || isStructuredTool(tool);
 }
-
 //#endregion
 export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+
 //# sourceMappingURL=types.js.map

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

package/dist/tools/utils.cjs

@@ -1,4 +1,3 @@
-
 //#region src/tools/utils.ts
 function _isToolCall(toolCall) {
 	return !!(toolCall && typeof toolCall === "object" && "type" in toolCall && toolCall.type === "tool_call");
@@ -18,9 +17,9 @@ var ToolInputParsingException = class extends Error {
 		this.output = output;
 	}
 };
-
 //#endregion
 exports.ToolInputParsingException = ToolInputParsingException;
 exports._configHasToolCallId = _configHasToolCallId;
 exports._isToolCall = _isToolCall;
+
 //# sourceMappingURL=utils.cjs.map

package/dist/tools/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["toolCall?: unknown","config?: unknown","message: string","output?: string"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\n\nexport function _isToolCall(toolCall?: unknown): toolCall is ToolCall {\n  return !!(\n    toolCall &&\n    typeof toolCall === \"object\" &&\n    \"type\" in toolCall &&\n    toolCall.type === \"tool_call\"\n  );\n}\n\nexport function _configHasToolCallId(\n  config?: unknown\n): config is { toolCall: { id?: string } } {\n  return !!(\n    config &&\n    typeof config === \"object\" &&\n    \"toolCall\" in config &&\n    config.toolCall != null &&\n    typeof config.toolCall === \"object\" &&\n    \"id\" in config.toolCall &&\n    typeof config.toolCall.id === \"string\"\n  );\n}\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport class ToolInputParsingException extends Error {\n  output?: string;\n\n  constructor(message: string, output?: string) {\n    super(message);\n    this.output = output;\n  }\n}\n"],"mappings":";;AAEA,SAAgB,YAAYA,UAA0C;AACpE,QAAO,CAAC,EACN,YACA,OAAO,aAAa,YACpB,UAAU,YACV,SAAS,SAAS;AAErB;AAED,SAAgB,qBACdC,QACyC;AACzC,QAAO,CAAC,EACN,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,YAAY,QACnB,OAAO,OAAO,aAAa,YAC3B,QAAQ,OAAO,YACf,OAAO,OAAO,SAAS,OAAO;AAEjC;;;;;;AAMD,IAAa,4BAAb,cAA+C,MAAM;CACnD;CAEA,YAAYC,SAAiBC,QAAiB;EAC5C,MAAM,QAAQ;EACd,KAAK,SAAS;CACf;AACF"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/tools/utils.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\n\nexport function _isToolCall(toolCall?: unknown): toolCall is ToolCall {\n  return !!(\n    toolCall &&\n    typeof toolCall === \"object\" &&\n    \"type\" in toolCall &&\n    toolCall.type === \"tool_call\"\n  );\n}\n\nexport function _configHasToolCallId(\n  config?: unknown\n): config is { toolCall: { id?: string } } {\n  return !!(\n    config &&\n    typeof config === \"object\" &&\n    \"toolCall\" in config &&\n    config.toolCall != null &&\n    typeof config.toolCall === \"object\" &&\n    \"id\" in config.toolCall &&\n    typeof config.toolCall.id === \"string\"\n  );\n}\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport class ToolInputParsingException extends Error {\n  output?: string;\n\n  constructor(message: string, output?: string) {\n    super(message);\n    this.output = output;\n  }\n}\n"],"mappings":";AAEA,SAAgB,YAAY,UAA0C;AACpE,QAAO,CAAC,EACN,YACA,OAAO,aAAa,YACpB,UAAU,YACV,SAAS,SAAS;;AAItB,SAAgB,qBACd,QACyC;AACzC,QAAO,CAAC,EACN,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,YAAY,QACnB,OAAO,OAAO,aAAa,YAC3B,QAAQ,OAAO,YACf,OAAO,OAAO,SAAS,OAAO;;;;;;;AAQlC,IAAa,4BAAb,cAA+C,MAAM;CACnD;CAEA,YAAY,SAAiB,QAAiB;AAC5C,QAAM,QAAQ;AACd,OAAK,SAAS"}

package/dist/tools/utils.d.cts

@@ -1,5 +1,4 @@
 //#region src/tools/utils.d.ts
-
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/tools/utils.ts"],"mappings":";;;;;;cA6Ba,yBAAA,SAAkC,KAAA;EAC7C,MAAA;EAEA,WAAA,CAAY,OAAA,UAAiB,MAAA;AAAA"}

package/dist/tools/utils.d.ts

@@ -1,5 +1,4 @@
 //#region src/tools/utils.d.ts
-
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/tools/utils.ts"],"mappings":";;;;;;cA6Ba,yBAAA,SAAkC,KAAA;EAC7C,MAAA;EAEA,WAAA,CAAY,OAAA,UAAiB,MAAA;AAAA"}

package/dist/tools/utils.js

@@ -17,7 +17,7 @@ var ToolInputParsingException = class extends Error {
 		this.output = output;
 	}
 };
-
 //#endregion
 export { ToolInputParsingException, _configHasToolCallId, _isToolCall };
+
 //# sourceMappingURL=utils.js.map

package/dist/tools/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["toolCall?: unknown","config?: unknown","message: string","output?: string"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\n\nexport function _isToolCall(toolCall?: unknown): toolCall is ToolCall {\n  return !!(\n    toolCall &&\n    typeof toolCall === \"object\" &&\n    \"type\" in toolCall &&\n    toolCall.type === \"tool_call\"\n  );\n}\n\nexport function _configHasToolCallId(\n  config?: unknown\n): config is { toolCall: { id?: string } } {\n  return !!(\n    config &&\n    typeof config === \"object\" &&\n    \"toolCall\" in config &&\n    config.toolCall != null &&\n    typeof config.toolCall === \"object\" &&\n    \"id\" in config.toolCall &&\n    typeof config.toolCall.id === \"string\"\n  );\n}\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport class ToolInputParsingException extends Error {\n  output?: string;\n\n  constructor(message: string, output?: string) {\n    super(message);\n    this.output = output;\n  }\n}\n"],"mappings":";AAEA,SAAgB,YAAYA,UAA0C;AACpE,QAAO,CAAC,EACN,YACA,OAAO,aAAa,YACpB,UAAU,YACV,SAAS,SAAS;AAErB;AAED,SAAgB,qBACdC,QACyC;AACzC,QAAO,CAAC,EACN,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,YAAY,QACnB,OAAO,OAAO,aAAa,YAC3B,QAAQ,OAAO,YACf,OAAO,OAAO,SAAS,OAAO;AAEjC;;;;;;AAMD,IAAa,4BAAb,cAA+C,MAAM;CACnD;CAEA,YAAYC,SAAiBC,QAAiB;EAC5C,MAAM,QAAQ;EACd,KAAK,SAAS;CACf;AACF"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/tools/utils.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\n\nexport function _isToolCall(toolCall?: unknown): toolCall is ToolCall {\n  return !!(\n    toolCall &&\n    typeof toolCall === \"object\" &&\n    \"type\" in toolCall &&\n    toolCall.type === \"tool_call\"\n  );\n}\n\nexport function _configHasToolCallId(\n  config?: unknown\n): config is { toolCall: { id?: string } } {\n  return !!(\n    config &&\n    typeof config === \"object\" &&\n    \"toolCall\" in config &&\n    config.toolCall != null &&\n    typeof config.toolCall === \"object\" &&\n    \"id\" in config.toolCall &&\n    typeof config.toolCall.id === \"string\"\n  );\n}\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport class ToolInputParsingException extends Error {\n  output?: string;\n\n  constructor(message: string, output?: string) {\n    super(message);\n    this.output = output;\n  }\n}\n"],"mappings":";AAEA,SAAgB,YAAY,UAA0C;AACpE,QAAO,CAAC,EACN,YACA,OAAO,aAAa,YACpB,UAAU,YACV,SAAS,SAAS;;AAItB,SAAgB,qBACd,QACyC;AACzC,QAAO,CAAC,EACN,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,YAAY,QACnB,OAAO,OAAO,aAAa,YAC3B,QAAQ,OAAO,YACf,OAAO,OAAO,SAAS,OAAO;;;;;;;AAQlC,IAAa,4BAAb,cAA+C,MAAM;CACnD;CAEA,YAAY,SAAiB,QAAiB;AAC5C,QAAM,QAAQ;AACd,OAAK,SAAS"}