@langchain/core 1.1.12 → 1.1.13

package/dist/output_parsers/json.d.ts

@@ -1,10 +1,11 @@
+import { BaseMessage } from "../messages/base.js";
 import { ChatGeneration, Generation } from "../outputs.js";
 import { Operation } from "../utils/fast-json-patch/src/core.js";
+import "../messages/index.js";
 import { BaseCumulativeTransformOutputParser } from "./transform.js";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.js";
 
 //#region src/output_parsers/json.d.ts
-
 /**
  * Class for parsing the output of an LLM into a JSON object.
  */
@@ -18,6 +19,14 @@ declare class JsonOutputParser<T extends Record<string, any> = Record<string, an
   parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;
   parse(text: string): Promise<T>;
   getFormatInstructions(): string;
+  /**
+   * Extracts text content from a message for JSON parsing.
+   * Uses the message's `.text` accessor which properly handles both
+   * string content and ContentBlock[] arrays (extracting text from text blocks).
+   * @param message The message to extract text from
+   * @returns The text content of the message
+   */
+  protected _baseMessageToString(message: BaseMessage): string;
 }
 //#endregion
 export { JsonOutputParser };

package/dist/output_parsers/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAAgDQ,cAA3BF,gBAA2BE,CAAAA,UAAAA,MAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAAsBA,MAAtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SAAmDR,mCAAnDQ,CAAuFD,CAAvFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiED,YAAAA,EAAAA,MAAAA,EAAAA;EAKrGA,eAAAA,EAAAA,OAAAA;EAAWA;EAAIA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAfA,CAAeA,EAAAA,MAAAA,EAAJA,CAAIA,CAAAA,EAAAA,CAAAA;EACcN,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,SAAAA,EAAAA,GAAAA,SAAAA;EAC3BC,kBAAAA,CAAAA,WAAAA,EAAAA,cAAAA,EAAAA,GAAmBC,UAAnBD,EAAAA,CAAAA,EAAkCO,OAAlCP,CAA0CK,CAA1CL,GAAAA,SAAAA,CAAAA;EAAmBC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAC9BM,OAD8BN,CACtBI,CADsBJ,CAAAA;EAAuBI,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA"}
+{"version":3,"file":"json.d.ts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","BaseMessage","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\nimport type { BaseMessage } from \"../messages/index.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n    /**\n     * Extracts text content from a message for JSON parsing.\n     * Uses the message's `.text` accessor which properly handles both\n     * string content and ContentBlock[] arrays (extracting text from text blocks).\n     * @param message The message to extract text from\n     * @returns The text content of the message\n     */\n    protected _baseMessageToString(message: BaseMessage): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;;;AAQqBO,cAAAA,gBAAgB,CAAA,UAAWE,MAAX,CAAA,MAAA,EAAA,GAAA,CAAA,GAAiCA,MAAjC,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAA8DT,mCAA9D,CAAkGQ,CAAlG,CAAA,CAAA;EAAWC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsBA,YAAAA,EAAAA,MAAAA,EAAAA;EAAiED,eAAAA,EAAAA,OAAAA;EAKrGA;EAAWA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAXA,CAAWA,EAAAA,MAAAA,EAAAA,CAAAA,CAAAA,EAAIA,CAAJA;EAAIA,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EACcP,SADdO,EAAAA,GAAAA,SAAAA;EACcP,kBAAAA,CAAAA,WAAAA,EAC3BC,cAD2BD,EAAAA,GACRE,UADQF,EAAAA,CAAAA,EACOS,OADPT,CACeO,CADfP,GAAAA,SAAAA,CAAAA;EAC3BC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EACXQ,OADWR,CACHM,CADGN,CAAAA;EAAmBC,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBK;;;;;;AAPwD;0CAiB1FF"}

package/dist/output_parsers/json.js

@@ -36,6 +36,16 @@ var JsonOutputParser = class extends BaseCumulativeTransformOutputParser {
 	getFormatInstructions() {
 		return "";
 	}
+	/**
+	* Extracts text content from a message for JSON parsing.
+	* Uses the message's `.text` accessor which properly handles both
+	* string content and ContentBlock[] arrays (extracting text from text blocks).
+	* @param message The message to extract text from
+	* @returns The text content of the message
+	*/
+	_baseMessageToString(message) {
+		return message.text;
+	}
 };
 
 //#endregion

package/dist/output_parsers/json.js.map

@@ -1 +1 @@
-{"version":3,"file":"json.js","names":["first: T","second: T","prev: unknown | undefined","next: unknown","generations: ChatGeneration[] | Generation[]","text: string"],"sources":["../../src/output_parsers/json.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation, compare } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport class JsonOutputParser<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends Record<string, any> = Record<string, any>,\n> extends BaseCumulativeTransformOutputParser<T> {\n  static lc_name() {\n    return \"JsonOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /** @internal */\n  override _concatOutputChunks<T>(first: T, second: T): T {\n    if (this.diff) {\n      return super._concatOutputChunks(first, second);\n    }\n    return second;\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): Operation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    if (!prev) {\n      return [{ op: \"replace\", path: \"\", value: next }];\n    }\n    return compare(prev, next);\n  }\n\n  // This should actually return Partial<T>, but there's no way\n  // to specify emitted chunks as instances separate from the main output type.\n  async parsePartialResult(\n    generations: ChatGeneration[] | Generation[]\n  ): Promise<T | undefined> {\n    return parseJsonMarkdown(generations[0].text) as T | undefined;\n  }\n\n  async parse(text: string): Promise<T> {\n    return parseJsonMarkdown(text, JSON.parse) as T;\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport { parsePartialJson, parseJsonMarkdown };\n"],"mappings":";;;;;;;;;AAQA,IAAa,mBAAb,cAGU,oCAAuC;CAC/C,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,gBAAiB;CAEnD,kBAAkB;;CAGlB,AAAS,oBAAuBA,OAAUC,QAAc;AACtD,MAAI,KAAK,KACP,QAAO,MAAM,oBAAoB,OAAO,OAAO;AAEjD,SAAO;CACR;CAED,AAAU,MACRC,MACAC,MACyB;AACzB,MAAI,CAAC,KACH,QAAO;AAET,MAAI,CAAC,KACH,QAAO,CAAC;GAAE,IAAI;GAAW,MAAM;GAAI,OAAO;EAAM,CAAC;AAEnD,SAAO,QAAQ,MAAM,KAAK;CAC3B;CAID,MAAM,mBACJC,aACwB;AACxB,SAAO,kBAAkB,YAAY,GAAG,KAAK;CAC9C;CAED,MAAM,MAAMC,MAA0B;AACpC,SAAO,kBAAkB,MAAM,KAAK,MAAM;CAC3C;CAED,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"json.js","names":["first: T","second: T","prev: unknown | undefined","next: unknown","generations: ChatGeneration[] | Generation[]","text: string","message: BaseMessage"],"sources":["../../src/output_parsers/json.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation, compare } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\nimport type { BaseMessage } from \"../messages/index.js\";\n\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport class JsonOutputParser<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends Record<string, any> = Record<string, any>,\n> extends BaseCumulativeTransformOutputParser<T> {\n  static lc_name() {\n    return \"JsonOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /** @internal */\n  override _concatOutputChunks<T>(first: T, second: T): T {\n    if (this.diff) {\n      return super._concatOutputChunks(first, second);\n    }\n    return second;\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): Operation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    if (!prev) {\n      return [{ op: \"replace\", path: \"\", value: next }];\n    }\n    return compare(prev, next);\n  }\n\n  // This should actually return Partial<T>, but there's no way\n  // to specify emitted chunks as instances separate from the main output type.\n  async parsePartialResult(\n    generations: ChatGeneration[] | Generation[]\n  ): Promise<T | undefined> {\n    return parseJsonMarkdown(generations[0].text) as T | undefined;\n  }\n\n  async parse(text: string): Promise<T> {\n    return parseJsonMarkdown(text, JSON.parse) as T;\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n\n  /**\n   * Extracts text content from a message for JSON parsing.\n   * Uses the message's `.text` accessor which properly handles both\n   * string content and ContentBlock[] arrays (extracting text from text blocks).\n   * @param message The message to extract text from\n   * @returns The text content of the message\n   */\n  protected _baseMessageToString(message: BaseMessage): string {\n    return message.text;\n  }\n}\n\nexport { parsePartialJson, parseJsonMarkdown };\n"],"mappings":";;;;;;;;;AASA,IAAa,mBAAb,cAGU,oCAAuC;CAC/C,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,gBAAiB;CAEnD,kBAAkB;;CAGlB,AAAS,oBAAuBA,OAAUC,QAAc;AACtD,MAAI,KAAK,KACP,QAAO,MAAM,oBAAoB,OAAO,OAAO;AAEjD,SAAO;CACR;CAED,AAAU,MACRC,MACAC,MACyB;AACzB,MAAI,CAAC,KACH,QAAO;AAET,MAAI,CAAC,KACH,QAAO,CAAC;GAAE,IAAI;GAAW,MAAM;GAAI,OAAO;EAAM,CAAC;AAEnD,SAAO,QAAQ,MAAM,KAAK;CAC3B;CAID,MAAM,mBACJC,aACwB;AACxB,SAAO,kBAAkB,YAAY,GAAG,KAAK;CAC9C;CAED,MAAM,MAAMC,MAA0B;AACpC,SAAO,kBAAkB,MAAM,KAAK,MAAM;CAC3C;CAED,wBAAgC;AAC9B,SAAO;CACR;;;;;;;;CASD,AAAU,qBAAqBC,SAA8B;AAC3D,SAAO,QAAQ;CAChB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","RunnableToolLike","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","InteropZodObject","InteropZodType","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","ToolRuntime","JSONSchema","BaseDynamicToolInput","ContentAndArtifact","StructuredToolParams","ToolSchemaBase","isLangChainTool","isRunnableToolLike","isStructuredTool","isStructuredToolParams","StructuredTool","TInput","TConfig","TArg","SchemaT","SchemaOutputT","SchemaInputT","ToolOutputT","Record","Promise","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","NameT","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","ClientTool"],"sources":["../../src/tools/index.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport { type RunnableConfig } from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport type { RunnableToolLike } from \"../runnables/base.js\";\nimport { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodObject, type InteropZodType, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from \"../utils/types/zod.js\";\nimport type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, StringInputToolSchema, ToolInterface, ToolOutputType, ToolRuntime } from \"./types.js\";\nimport { type JSONSchema } from \"../utils/json_schema.js\";\nexport type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from \"./types.js\";\nexport { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, type ToolRuntime, } from \"./types.js\";\nexport { ToolInputParsingException };\n/**\n * Base class for Tools that accept input of any shape defined by a Zod schema.\n */\nexport declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    abstract name: string;\n    abstract description: string;\n    abstract schema: SchemaT;\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     * 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    verboseParsingErrors: boolean;\n    get lc_namespace(): string[];\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    constructor(fields?: ToolParams);\n    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n    /**\n     * Invokes the tool with the provided input and configuration.\n     * @param input The input for the tool.\n     * @param config Optional configuration for the tool.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, 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/**\n * Base class for Tools that accept input as a string.\n */\nexport declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {\n    schema: z.ZodEffects<z.ZodObject<{\n        input: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        input?: string | undefined;\n    }, {\n        input?: string | undefined;\n    }>, string | undefined, {\n        input?: string | undefined;\n    }>;\n    constructor(fields?: ToolParams);\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 string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and description.\n */\nexport declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicToolInput<ToolOutputT>[\"func\"];\n    constructor(fields: DynamicToolInput<ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    /** @ignore */\n    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and\n * description, designed to work with structured data. It extends the\n * StructuredTool class and overrides the _call method to execute the\n * provided function when the tool is called.\n *\n * Schema can be passed as Zod or JSON schema. The tool will not validate\n * input if JSON schema is passed.\n *\n * @template SchemaT The input schema type for the tool (Zod schema or JSON schema). Defaults to `ToolInputSchemaBase`.\n * @template SchemaOutputT The output type derived from the schema after parsing/validation. Defaults to `ToolInputSchemaOutputType<SchemaT>`.\n * @template SchemaInputT The input type derived from the schema before parsing. Defaults to `ToolInputSchemaInputType<SchemaT>`.\n * @template ToolOutputT The return type of the tool's function. Defaults to `ToolOutputType`.\n * @template NameT The literal type of the tool name (for discriminated union support). Defaults to `string`.\n */\nexport declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, NameT extends string = string> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n    static lc_name(): string;\n    name: NameT;\n    description: string;\n    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n    schema: SchemaT;\n    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT> & {\n        name: NameT;\n    });\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * Abstract base class for toolkits in LangChain. Toolkits are collections\n * of tools that agents can use. Subclasses must implement the `tools`\n * property to provide the specific tools for the toolkit.\n */\nexport declare abstract class BaseToolkit {\n    abstract tools: StructuredToolInterface[];\n    getTools(): StructuredToolInterface[];\n}\n/**\n * Parameters for the tool function.\n * Schema can be provided as Zod or JSON schema.\n * Both schema types will be validated.\n * @template {ToolInputSchemaBase} RunInput The input schema for the tool.\n * @template {string} NameT The literal name type for discriminated union support.\n */\ninterface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined, NameT extends string = string> extends ToolParams {\n    /**\n     * The name of the tool. If using with an LLM, this\n     * will be passed as the tool name.\n     */\n    name: NameT;\n    /**\n     * The description of the tool.\n     * @default `${fields.name} tool`\n     */\n    description?: string;\n    /**\n     * The input schema for the tool. If using an LLM, this\n     * will be passed as the tool schema to generate arguments\n     * for.\n     */\n    schema?: RunInput;\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     * 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 * Creates a new StructuredTool instance with the provided function, name, description, and schema.\n *\n * Schema can be provided as Zod or JSON schema, and both will be validated.\n *\n * @function\n * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.\n * @template {ToolReturnType} ToolOutputT The output type of the tool.\n *\n * @param {RunnableFunc<z.output<SchemaT>, ToolOutputT>} func - The function to invoke when the tool is called.\n * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:\n * @param {string} fields.name The name of the tool.\n * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.\n * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.\n *\n * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.\n */\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends ZodObjectV4, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends JSONSchema, NameT extends string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JSONSchema = InteropZodObject, NameT extends string = string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT> | DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends ZodObjectV4, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends JSONSchema, NameT extends string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","RunnableToolLike","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","InteropZodObject","InteropZodType","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","ToolRuntime","JSONSchema","BaseDynamicToolInput","ContentAndArtifact","StructuredToolParams","ToolSchemaBase","isLangChainTool","isRunnableToolLike","isStructuredTool","isStructuredToolParams","StructuredTool","TInput","TConfig","TArg","SchemaT","SchemaOutputT","SchemaInputT","ToolOutputT","Record","Promise","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","NameT","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","ClientTool"],"sources":["../../src/tools/index.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport { type RunnableConfig } from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport type { RunnableToolLike } from \"../runnables/base.js\";\nimport { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodObject, type InteropZodType, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from \"../utils/types/zod.js\";\nimport type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, StringInputToolSchema, ToolInterface, ToolOutputType, ToolRuntime } from \"./types.js\";\nimport { type JSONSchema } from \"../utils/json_schema.js\";\nexport type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from \"./types.js\";\nexport { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, type ToolRuntime, } from \"./types.js\";\nexport { ToolInputParsingException };\n/**\n * Base class for Tools that accept input of any shape defined by a Zod schema.\n */\nexport declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    abstract name: string;\n    abstract description: string;\n    abstract schema: SchemaT;\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     * 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    verboseParsingErrors: boolean;\n    get lc_namespace(): string[];\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    constructor(fields?: ToolParams);\n    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n    /**\n     * Invokes the tool with the provided input and configuration.\n     * @param input The input for the tool.\n     * @param config Optional configuration for the tool.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, 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/**\n * Base class for Tools that accept input as a string.\n */\nexport declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {\n    schema: z.ZodEffects<z.ZodObject<{\n        input: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        input?: string | undefined;\n    }, {\n        input?: string | undefined;\n    }>, string | undefined, {\n        input?: string | undefined;\n    }>;\n    constructor(fields?: ToolParams);\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 string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and description.\n */\nexport declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicToolInput<ToolOutputT>[\"func\"];\n    constructor(fields: DynamicToolInput<ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    /** @ignore */\n    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and\n * description, designed to work with structured data. It extends the\n * StructuredTool class and overrides the _call method to execute the\n * provided function when the tool is called.\n *\n * Schema can be passed as Zod or JSON schema. The tool will not validate\n * input if JSON schema is passed.\n *\n * @template SchemaT The input schema type for the tool (Zod schema or JSON schema). Defaults to `ToolInputSchemaBase`.\n * @template SchemaOutputT The output type derived from the schema after parsing/validation. Defaults to `ToolInputSchemaOutputType<SchemaT>`.\n * @template SchemaInputT The input type derived from the schema before parsing. Defaults to `ToolInputSchemaInputType<SchemaT>`.\n * @template ToolOutputT The return type of the tool's function. Defaults to `ToolOutputType`.\n * @template NameT The literal type of the tool name (for discriminated union support). Defaults to `string`.\n */\nexport declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, NameT extends string = string> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n    static lc_name(): string;\n    name: NameT;\n    description: string;\n    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n    schema: SchemaT;\n    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT> & {\n        name: NameT;\n    });\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * Abstract base class for toolkits in LangChain. Toolkits are collections\n * of tools that agents can use. Subclasses must implement the `tools`\n * property to provide the specific tools for the toolkit.\n */\nexport declare abstract class BaseToolkit {\n    abstract tools: StructuredToolInterface[];\n    getTools(): StructuredToolInterface[];\n}\n/**\n * Parameters for the tool function.\n * Schema can be provided as Zod or JSON schema.\n * Both schema types will be validated.\n * @template {ToolInputSchemaBase} RunInput The input schema for the tool.\n * @template {string} NameT The literal name type for discriminated union support.\n */\ninterface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined, NameT extends string = string> extends ToolParams {\n    /**\n     * The name of the tool. If using with an LLM, this\n     * will be passed as the tool name.\n     */\n    name: NameT;\n    /**\n     * The description of the tool.\n     * @default `${fields.name} tool`\n     */\n    description?: string;\n    /**\n     * The input schema for the tool. If using an LLM, this\n     * will be passed as the tool schema to generate arguments\n     * for.\n     */\n    schema?: RunInput;\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     * 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 * Creates a new StructuredTool instance with the provided function, name, description, and schema.\n *\n * Schema can be provided as Zod or JSON schema, and both will be validated.\n *\n * @function\n * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.\n * @template {ToolReturnType} ToolOutputT The output type of the tool.\n *\n * @param {RunnableFunc<z.output<SchemaT>, ToolOutputT>} func - The function to invoke when the tool is called.\n * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:\n * @param {string} fields.name The name of the tool.\n * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.\n * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.\n *\n * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.\n */\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends ZodObjectV4, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends JSONSchema, NameT extends string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JSONSchema = InteropZodObject, NameT extends string = string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT> | DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends ZodObjectV4, NameT extends string, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport declare function tool<SchemaT extends JSONSchema, NameT extends string, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT, NameT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT, NameT>;\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}

package/dist/tools/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","names":["tool?: StructuredToolInterface | ToolDefinition | JSONSchema","tool?: unknown","Runnable","isInteropZodSchema"],"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,UACTC,sBAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;AAElC;;;;;;;AAQD,SAAgB,uBACdD,MAC8B;AAC9B,QACE,CAAC,CAAC,QACF,OAAO,SAAS,YAChB,UAAU,QACV,YAAY,SAEXE,+BAAmB,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,gBAAgBF,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY;AAEhC"}
+{"version":3,"file":"types.cjs","names":["tool?: StructuredToolInterface | ToolDefinition | JSONSchema","tool?: unknown","Runnable","isInteropZodSchema"],"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, 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":";;;;;;;;;;AA0XA,SAAgB,iBACdA,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;AAEhE;;;;;;;AAQD,SAAgB,mBAAmBC,MAA0C;AAC3E,QACE,SAAS,UACTC,sBAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;AAElC;;;;;;;AAQD,SAAgB,uBACdD,MAC8B;AAC9B,QACE,CAAC,CAAC,QACF,OAAO,SAAS,YAChB,UAAU,QACV,YAAY,SAEXE,+BAAmB,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,gBAAgBF,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY;AAEhC"}

package/dist/tools/types.d.cts

@@ -293,7 +293,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 +302,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 +330,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)

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":["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, 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<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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"}

package/dist/tools/types.d.ts

@@ -295,7 +295,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 +304,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 +332,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)