@langchain/core 0.3.71 → 1.0.0-alpha.1

package/dist/tools/types.d.ts

@@ -1,81 +1,83 @@
-import type { z as z3 } from "zod/v3";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodType } from "../utils/types/zod.js";
+import { MessageContent } from "../messages/base.js";
+import { DirectToolOutput, ToolCall, ToolMessage } from "../messages/tool.js";
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
-import type { BaseLangChainParams, ToolDefinition } from "../language_models/base.js";
-import type { RunnableConfig } from "../runnables/config.js";
-import { RunnableToolLike, type RunnableInterface } from "../runnables/base.js";
-import { type DirectToolOutput, type ToolCall, type ToolMessage } from "../messages/tool.js";
-import type { MessageContent } from "../messages/base.js";
-import { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType } from "../utils/types/zod.js";
+import { RunnableConfig, RunnableInterface } from "../runnables/types.js";
+import { RunnableToolLike } from "../runnables/base.js";
 import { JSONSchema } from "../utils/json_schema.js";
-export type ResponseFormat = "content" | "content_and_artifact" | string;
-export type ToolOutputType = any;
-export type ContentAndArtifact = [MessageContent, any];
+import { BaseLangChainParams, ToolDefinition } from "../language_models/base.js";
+import { z } from "zod/v3";
+
+//#region src/tools/types.d.ts
+type ResponseFormat = "content" | "content_and_artifact" | string;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ToolOutputType = any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ContentAndArtifact = [MessageContent, any];
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
  * - If the input is a ToolCall, it returns a ToolMessage
  * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage
  * - Otherwise, it returns the original output type
  */
-export type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {
-    toolCall: {
-        id: string;
-    };
+type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {
+  toolCall: {
+    id: string;
+  };
 } ? ToolMessage : TConfig extends {
-    toolCall: {
-        id: undefined;
-    };
+  toolCall: {
+    id: undefined;
+  };
 } ? TOutput : TConfig extends {
-    toolCall: {
-        id?: string;
-    };
+  toolCall: {
+    id?: string;
+  };
 } ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;
 /**
  * Base type that establishes the types of input schemas that can be used for LangChain tool
  * definitions.
  */
-export type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;
+type ToolInputSchemaBase = z.ZodTypeAny | JSONSchema;
 /**
  * Parameters for the Tool classes.
  */
-export interface ToolParams extends BaseLangChainParams {
-    /**
-     * The tool response format.
-     *
-     * If "content" then the output of the tool is interpreted as the contents of a
-     * ToolMessage. If "content_and_artifact" then the output is expected to be a
-     * two-tuple corresponding to the (content, artifact) of a ToolMessage.
-     *
-     * @default "content"
-     */
-    responseFormat?: ResponseFormat;
-    /**
-     * Default config object for the tool runnable.
-     */
-    defaultConfig?: ToolRunnableConfig;
-    /**
-     * Whether to show full details in the thrown parsing errors.
-     *
-     * @default false
-     */
-    verboseParsingErrors?: boolean;
-    /**
-     * Metadata for the tool.
-     */
-    metadata?: Record<string, unknown>;
+interface ToolParams extends BaseLangChainParams {
+  /**
+   * The tool response format.
+   *
+   * If "content" then the output of the tool is interpreted as the contents of a
+   * ToolMessage. If "content_and_artifact" then the output is expected to be a
+   * two-tuple corresponding to the (content, artifact) of a ToolMessage.
+   *
+   * @default "content"
+   */
+  responseFormat?: ResponseFormat;
+  /**
+   * Default config object for the tool runnable.
+   */
+  defaultConfig?: ToolRunnableConfig;
+  /**
+   * Whether to show full details in the thrown parsing errors.
+   *
+   * @default false
+   */
+  verboseParsingErrors?: boolean;
 }
-export type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> = RunnableConfig<ConfigurableFieldType> & {
-    toolCall?: ToolCall;
+type ToolRunnableConfig<
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ConfigurableFieldType extends Record<string, any> = Record<string, any>> = RunnableConfig<ConfigurableFieldType> & {
+  toolCall?: ToolCall;
 };
 /**
  * Schema for defining tools.
  *
  * @version 0.2.19
  */
-export interface StructuredToolParams extends Pick<StructuredToolInterface, "name" | "schema"> {
-    /**
-     * An optional description of the tool to pass to the model.
-     */
-    description?: string;
+interface StructuredToolParams extends Pick<StructuredToolInterface, "name" | "schema"> {
+  /**
+   * An optional description of the tool to pass to the model.
+   */
+  description?: string;
 }
 /**
  * Utility type that resolves the output type of a tool input schema.
@@ -88,7 +90,7 @@ export interface StructuredToolParams extends Pick<StructuredToolInterface, "nam
  * applying any transforms defined in your schema. If there are no transforms, the input and output
  * types will be the same.
  */
-export type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;
+type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;
 /**
  * Utility type that resolves the input type of a tool input schema.
  *
@@ -100,14 +102,14 @@ export type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInter
  * applying any transforms defined in your schema. If there are no transforms, the input and output
  * types will be the same.
  */
-export type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;
+type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;
 /**
  * Defines the type that will be passed into a tool handler function as a result of a tool call.
  *
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @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.
  */
-export type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
+type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
 /**
  * An input schema type for tools that accept a single string input.
  *
@@ -117,7 +119,9 @@ export type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-export type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, any>;
+type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+any>;
 /**
  * Defines the type for input to a tool's call method.
  *
@@ -130,7 +134,7 @@ export type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef
  *
  * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema
  */
-export type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;
+
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -140,48 +144,47 @@ export type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallI
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @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.
  */
-export interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {
-    lc_namespace: string[];
-    /**
-     * A Zod schema representing the parameters of the tool.
-     */
-    schema: SchemaT;
-    /**
-     * Invokes the tool with the provided argument and configuration.
-     * @param arg The input argument for the tool.
-     * @param configArg Optional configuration for the tool call.
-     * @returns A Promise that resolves with the tool's output.
-     */
-    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
-    /**
-     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-     *
-     * Calls the tool with the provided argument, configuration, and tags. It
-     * parses the input according to the schema, handles any errors, and
-     * manages callbacks.
-     * @param arg The input argument for the tool.
-     * @param configArg Optional configuration or callbacks for the tool.
-     * @param tags Optional tags for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
-    /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
-    /**
-     * The name of the tool.
-     */
-    name: string;
-    /**
-     * A description of the tool.
-     */
-    description: string;
-    /**
-     * Whether to return the tool's output directly.
-     *
-     * Setting this to true means that after the tool is called,
-     * an agent should stop looping.
-     */
-    returnDirect: boolean;
+interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {
+  lc_namespace: string[];
+  /**
+   * A Zod schema representing the parameters of the tool.
+   */
+  schema: SchemaT;
+  /**
+   * Invokes the tool with the provided argument and configuration.
+   * @param arg The input argument for the tool.
+   * @param configArg Optional configuration for the tool call.
+   * @returns A Promise that resolves with the tool's output.
+   */
+  invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
+  /**
+   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
+   *
+   * Calls the tool with the provided argument, configuration, and tags. It
+   * parses the input according to the schema, handles any errors, and
+   * manages callbacks.
+   * @param arg The input argument for the tool.
+   * @param configArg Optional configuration or callbacks for the tool.
+   * @param tags Optional tags for the tool.
+   * @returns A Promise that resolves with a string.
+   */
+  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, /** @deprecated */
+  tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
+  /**
+   * The name of the tool.
+   */
+  name: string;
+  /**
+   * A description of the tool.
+   */
+  description: string;
+  /**
+   * Whether to return the tool's output directly.
+   *
+   * Setting this to true means that after the tool is called,
+   * an agent should stop looping.
+   */
+  returnDirect: boolean;
 }
 /**
  * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.
@@ -189,38 +192,40 @@ export interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaIn
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @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.
  */
-export interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
-    /**
-     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-     *
-     * Calls the tool with the provided argument and callbacks. It handles
-     * string inputs specifically.
-     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
-     * @param callbacks Optional callbacks for the tool.
-     * @returns A Promise that resolves with a string.
-     */
-    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
+  /**
+   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
+   *
+   * Calls the tool with the provided argument and callbacks. It handles
+   * string inputs specifically.
+   * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.
+   * @param callbacks Optional callbacks for the tool.
+   * @returns A Promise that resolves with a string.
+   */
+  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(
+  // TODO: shouldn't this be narrowed based on SchemaT?
+  arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
  * Base interface for the input parameters of the {@link DynamicTool} and
  * {@link DynamicStructuredTool} classes.
  */
-export interface BaseDynamicToolInput extends ToolParams {
-    name: string;
-    description: string;
-    /**
-     * Whether to return the tool's output directly.
-     *
-     * Setting this to true means that after the tool is called,
-     * an agent should stop looping.
-     */
-    returnDirect?: boolean;
+interface BaseDynamicToolInput extends ToolParams {
+  name: string;
+  description: string;
+  /**
+   * Whether to return the tool's output directly.
+   *
+   * Setting this to true means that after the tool is called,
+   * an agent should stop looping.
+   */
+  returnDirect?: boolean;
 }
 /**
  * Interface for the input parameters of the DynamicTool class.
  */
-export interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
-    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;
+interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+  func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;
 }
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
@@ -228,17 +233,17 @@ export interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDyna
  * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
  * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.
  */
-export interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
-    /**
-     * Tool handler function - the function that will be called when the tool is invoked.
-     *
-     * @param input - The input to the tool.
-     * @param runManager - The run manager for the tool.
-     * @param config - The configuration for the tool.
-     * @returns The result of the tool.
-     */
-    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;
-    schema: SchemaT;
+interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+  /**
+   * Tool handler function - the function that will be called when the tool is invoked.
+   *
+   * @param input - The input to the tool.
+   * @param runManager - The run manager for the tool.
+   * @param config - The configuration for the tool.
+   * @returns The result of the tool.
+   */
+  func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;
+  schema: SchemaT;
 }
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
@@ -246,21 +251,21 @@ export interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, Schem
  * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
  * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
  */
-export declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;
+declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;
 /**
  * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
  *
  * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
  * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
  */
-export declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;
+declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;
 /**
  * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
  *
  * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
  * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
  */
-export declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;
+declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;
 /**
  * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.
  * It returns `is StructuredToolParams` since that is the most minimal interface of the three,
@@ -269,4 +274,7 @@ export declare function isStructuredToolParams(tool?: unknown): tool is Structur
  * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.
  * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
  */
-export declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
+declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;
+//#endregion
+export { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","JSONSchema","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Default config object for the tool runnable.\n     */\n    defaultConfig?: ToolRunnableConfig;\n    /**\n     * Whether to show full details in the thrown parsing errors.\n     *\n     * @default false\n     */\n    verboseParsingErrors?: boolean;\n}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\n}\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\n    /**\n     * Invokes the tool with the provided argument and configuration.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration for the tool call.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument, configuration, and tags. It\n     * parses the input according to the schema, handles any errors, and\n     * manages callbacks.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration or callbacks for the tool.\n     * @param tags Optional tags for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n    /**\n     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect: boolean;\n}\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument and callbacks. It handles\n     * string inputs specifically.\n     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n     * @param callbacks Optional callbacks for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n    name: string;\n    description: string;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect?: boolean;\n}\n/**\n * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\n}\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    /**\n     * Tool handler function - the function that will be called when the tool is invoked.\n     *\n     * @param input - The input to the tool.\n     * @param runManager - The run manager for the tool.\n     * @param config - The configuration for the tool.\n     * @returns The result of the tool.\n     */\n    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\n}\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n"],"mappings":"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"}

package/dist/tools/types.js

@@ -1,58 +1,53 @@
-import { Runnable, } from "../runnables/base.js";
-import { isInteropZodSchema, } from "../utils/types/zod.js";
+import { isInteropZodSchema } from "../utils/types/zod.js";
+import { Runnable } from "../runnables/base.js";
+
+//#region src/tools/types.ts
 /**
- * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
- *
- * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
- * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
- */
-export function isStructuredTool(tool) {
-    return (tool !== undefined &&
-        Array.isArray(tool.lc_namespace));
+* Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
+*
+* @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
+* @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
+*/
+function isStructuredTool(tool) {
+	return tool !== void 0 && Array.isArray(tool.lc_namespace);
 }
 /**
- * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
- *
- * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
- * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
- */
-export function isRunnableToolLike(tool) {
-    return (tool !== undefined &&
-        Runnable.isRunnable(tool) &&
-        "lc_name" in tool.constructor &&
-        typeof tool.constructor.lc_name === "function" &&
-        tool.constructor.lc_name() === "RunnableToolLike");
+* Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+*
+* @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+* @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+*/
+function isRunnableToolLike(tool) {
+	return tool !== void 0 && Runnable.isRunnable(tool) && "lc_name" in tool.constructor && typeof tool.constructor.lc_name === "function" && tool.constructor.lc_name() === "RunnableToolLike";
 }
 /**
- * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
- *
- * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
- * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
- */
-export function isStructuredToolParams(tool) {
-    return (!!tool &&
-        typeof tool === "object" &&
-        "name" in tool &&
-        "schema" in tool &&
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (isInteropZodSchema(tool.schema) ||
-            (tool.schema != null &&
-                typeof tool.schema === "object" &&
-                "type" in tool.schema &&
-                typeof tool.schema.type === "string" &&
-                ["null", "boolean", "object", "array", "number", "string"].includes(tool.schema.type))));
+* Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
+*
+* @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
+* @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
+*/
+function isStructuredToolParams(tool) {
+	return !!tool && typeof tool === "object" && "name" in tool && "schema" in tool && (isInteropZodSchema(tool.schema) || tool.schema != null && typeof tool.schema === "object" && "type" in tool.schema && typeof tool.schema.type === "string" && [
+		"null",
+		"boolean",
+		"object",
+		"array",
+		"number",
+		"string"
+	].includes(tool.schema.type));
 }
 /**
- * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.
- * It returns `is StructuredToolParams` since that is the most minimal interface of the three,
- * while still containing the necessary properties to be passed to a LLM for tool calling.
- *
- * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.
- * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
- */
-export function isLangChainTool(tool) {
-    return (isStructuredToolParams(tool) ||
-        isRunnableToolLike(tool) ||
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        isStructuredTool(tool));
+* Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.
+* It returns `is StructuredToolParams` since that is the most minimal interface of the three,
+* while still containing the necessary properties to be passed to a LLM for tool calling.
+*
+* @param {unknown | undefined} tool The tool to check if it is a LangChain tool.
+* @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
+*/
+function isLangChainTool(tool) {
+	return isStructuredToolParams(tool) || isRunnableToolLike(tool) || isStructuredTool(tool);
 }
+
+//#endregion
+export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+//# sourceMappingURL=types.js.map

package/dist/tools/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":["tool?: StructuredToolInterface | ToolDefinition | JSONSchema","tool?: unknown"],"sources":["../../src/tools/types.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type {\n  BaseLangChainParams,\n  ToolDefinition,\n} from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport {\n  Runnable,\n  RunnableToolLike,\n  type RunnableInterface,\n} from \"../runnables/base.js\";\nimport {\n  type DirectToolOutput,\n  type ToolCall,\n  type ToolMessage,\n} from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport {\n  type InferInteropZodInput,\n  type InferInteropZodOutput,\n  type InteropZodType,\n  isInteropZodSchema,\n} from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\n\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> =\n  TOutput extends DirectToolOutput\n    ? TOutput\n    : TConfig extends { toolCall: { id: string } }\n    ? ToolMessage\n    : TConfig extends { toolCall: { id: undefined } }\n    ? TOutput\n    : TConfig extends { toolCall: { id?: string } }\n    ? TOutput | ToolMessage\n    : TInput extends ToolCall\n    ? ToolMessage\n    : TOutput;\n\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\n  /**\n   * The tool response format.\n   *\n   * If \"content\" then the output of the tool is interpreted as the contents of a\n   * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n   * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n   *\n   * @default \"content\"\n   */\n  responseFormat?: ResponseFormat;\n  /**\n   * Default config object for the tool runnable.\n   */\n  defaultConfig?: ToolRunnableConfig;\n  /**\n   * Whether to show full details in the thrown parsing errors.\n   *\n   * @default false\n   */\n  verboseParsingErrors?: boolean;\n}\n\nexport type ToolRunnableConfig<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ConfigurableFieldType extends Record<string, any> = Record<string, any>\n> = RunnableConfig<ConfigurableFieldType> & { toolCall?: ToolCall };\n\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams\n  extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n  /**\n   * An optional description of the tool to pass to the model.\n   */\n  description?: string;\n}\n\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType\n  ? InferInteropZodOutput<T>\n  : T extends JSONSchema\n  ? unknown\n  : never;\n\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType\n  ? InferInteropZodInput<T>\n  : T extends JSONSchema\n  ? unknown\n  : never;\n\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>\n> =\n  | (ToolInputSchemaOutputType<SchemaT> extends string ? string : never)\n  | SchemaInputT\n  | ToolCall;\n\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<\n  string | undefined,\n  z3.ZodTypeDef,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>;\n\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> =\n  StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<\n  SchemaT = ToolInputSchemaBase,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType\n> extends RunnableInterface<\n    StructuredToolCallInput<SchemaT, SchemaInputT>,\n    ToolOutputT | ToolMessage\n  > {\n  lc_namespace: string[];\n\n  /**\n   * A Zod schema representing the parameters of the tool.\n   */\n  schema: SchemaT;\n\n  /**\n   * Invokes the tool with the provided argument and configuration.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration for the tool call.\n   * @returns A Promise that resolves with the tool's output.\n   */\n  invoke<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined\n  >(\n    arg: TArg,\n    configArg?: TConfig\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument, configuration, and tags. It\n   * parses the input according to the schema, handles any errors, and\n   * manages callbacks.\n   * @param arg The input argument for the tool.\n   * @param configArg Optional configuration or callbacks for the tool.\n   * @param tags Optional tags for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined\n  >(\n    arg: TArg,\n    configArg?: TConfig,\n    /** @deprecated */\n    tags?: string[]\n  ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n\n  /**\n   * The name of the tool.\n   */\n  name: string;\n\n  /**\n   * A description of the tool.\n   */\n  description: string;\n\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect: boolean;\n}\n\n/**\n * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<\n  SchemaT = StringInputToolSchema,\n  SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n  ToolOutputT = ToolOutputType\n> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Calls the tool with the provided argument and callbacks. It handles\n   * string inputs specifically.\n   * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n   * @param callbacks Optional callbacks for the tool.\n   * @returns A Promise that resolves with a string.\n   */\n  call<\n    TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n    TConfig extends ToolRunnableConfig | undefined\n  >(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg,\n    callbacks?: TConfig\n  ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n  name: string;\n  description: string;\n  /**\n   * Whether to return the tool's output directly.\n   *\n   * Setting this to true means that after the tool is called,\n   * an agent should stop looping.\n   */\n  returnDirect?: boolean;\n}\n\n/**\n * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType>\n  extends BaseDynamicToolInput {\n  func: (\n    input: string,\n    runManager?: CallbackManagerForToolRun,\n    config?: ToolRunnableConfig\n  ) => Promise<ToolOutputT>;\n}\n\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<\n  SchemaT = ToolInputSchemaBase,\n  SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n  ToolOutputT = ToolOutputType\n> extends BaseDynamicToolInput {\n  /**\n   * Tool handler function - the function that will be called when the tool is invoked.\n   *\n   * @param input - The input to the tool.\n   * @param runManager - The run manager for the tool.\n   * @param config - The configuration for the tool.\n   * @returns The result of the tool.\n   */\n  func: (\n    input: SchemaOutputT,\n    runManager?: CallbackManagerForToolRun,\n    config?: RunnableConfig\n  ) => Promise<ToolOutputT>;\n  schema: SchemaT;\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport function isStructuredTool(\n  tool?: StructuredToolInterface | ToolDefinition | JSONSchema\n): tool is StructuredToolInterface {\n  return (\n    tool !== undefined &&\n    Array.isArray((tool as StructuredToolInterface).lc_namespace)\n  );\n}\n\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike {\n  return (\n    tool !== undefined &&\n    Runnable.isRunnable(tool) &&\n    \"lc_name\" in tool.constructor &&\n    typeof tool.constructor.lc_name === \"function\" &&\n    tool.constructor.lc_name() === \"RunnableToolLike\"\n  );\n}\n\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport function isStructuredToolParams(\n  tool?: unknown\n): tool is StructuredToolParams {\n  return (\n    !!tool &&\n    typeof tool === \"object\" &&\n    \"name\" in tool &&\n    \"schema\" in tool &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (isInteropZodSchema(tool.schema as Record<string, any>) ||\n      (tool.schema != null &&\n        typeof tool.schema === \"object\" &&\n        \"type\" in tool.schema &&\n        typeof tool.schema.type === \"string\" &&\n        [\"null\", \"boolean\", \"object\", \"array\", \"number\", \"string\"].includes(\n          tool.schema.type\n        )))\n  );\n}\n\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport function isLangChainTool(tool?: unknown): tool is StructuredToolParams {\n  return (\n    isStructuredToolParams(tool) ||\n    isRunnableToolLike(tool) ||\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    isStructuredTool(tool as any)\n  );\n}\n"],"mappings":";;;;;;;;;;AA+VA,SAAgB,iBACdA,MACiC;AACjC,QACE,SAAS,UACT,MAAM,QAAS,KAAiC,aAAa;AAEhE;;;;;;;AAQD,SAAgB,mBAAmBC,MAA0C;AAC3E,QACE,SAAS,UACT,SAAS,WAAW,KAAK,IACzB,aAAa,KAAK,eAClB,OAAO,KAAK,YAAY,YAAY,cACpC,KAAK,YAAY,SAAS,KAAK;AAElC;;;;;;;AAQD,SAAgB,uBACdA,MAC8B;AAC9B,QACE,CAAC,CAAC,QACF,OAAO,SAAS,YAChB,UAAU,QACV,YAAY,SAEX,mBAAmB,KAAK,OAA8B,IACpD,KAAK,UAAU,QACd,OAAO,KAAK,WAAW,YACvB,UAAU,KAAK,UACf,OAAO,KAAK,OAAO,SAAS,YAC5B;EAAC;EAAQ;EAAW;EAAU;EAAS;EAAU;CAAS,EAAC,SACzD,KAAK,OAAO,KACb;AAER;;;;;;;;;AAUD,SAAgB,gBAAgBA,MAA8C;AAC5E,QACE,uBAAuB,KAAK,IAC5B,mBAAmB,KAAK,IAExB,iBAAiB,KAAY;AAEhC"}