@langchain/core 0.3.52 → 0.3.54

package/dist/messages/tool.d.ts

@@ -27,7 +27,7 @@ export interface ToolMessageFieldsWithToolCallId extends ToolMessageFields {
  * a string and wrapped in a ToolMessage.
  */
 export interface DirectToolOutput {
-    readonly lc_direct_tool_output: boolean;
+    readonly lc_direct_tool_output: true;
 }
 export declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
 /**
@@ -37,7 +37,7 @@ export declare class ToolMessage extends BaseMessage implements DirectToolOutput
     content: string | (MessageContentComplex | DataContentBlock)[];
     static lc_name(): string;
     get lc_aliases(): Record<string, string>;
-    lc_direct_tool_output: boolean;
+    lc_direct_tool_output: true;
     /**
      * Status of the tool invocation.
      * @version 0.2.19

package/dist/tools/index.cjs

@@ -67,22 +67,16 @@ class StructuredTool extends base_js_1.BaseLangChain {
      * Invokes the tool with the provided input and configuration.
      * @param input The input for the tool.
      * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
+     * @returns A Promise that resolves with the tool's output.
      */
     async invoke(input, config) {
-        let tool_call_id;
         let toolInput;
         let enrichedConfig = (0, config_js_1.ensureConfig)(config);
         if ((0, utils_js_1._isToolCall)(input)) {
-            tool_call_id = input.id;
             toolInput = input.args;
             enrichedConfig = {
                 ...enrichedConfig,
                 toolCall: input,
-                configurable: {
-                    ...enrichedConfig.configurable,
-                    tool_call_id,
-                },
             };
         }
         else {
@@ -104,21 +98,26 @@ class StructuredTool extends base_js_1.BaseLangChain {
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
-        let parsed = arg;
+        // Determine the actual input that needs parsing/validation.
+        // If arg is a ToolCall, use its args; otherwise, use arg directly.
+        const inputForValidation = (0, utils_js_1._isToolCall)(arg) ? arg.args : arg;
+        let parsed; // This will hold the successfully parsed input of the expected output type.
         if ((0, is_zod_schema_js_1.isZodSchema)(this.schema)) {
             try {
-                parsed = await this.schema.parseAsync(arg);
+                // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check
+                parsed = await this.schema.parseAsync(inputForValidation);
             }
             catch (e) {
                 let message = `Received tool input did not match expected schema`;
                 if (this.verboseParsingErrors) {
                     message = `${message}\nDetails: ${e.message}`;
                 }
+                // Pass the original raw input arg to the exception
                 throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
             }
         }
         else {
-            const result = (0, json_schema_1.validate)(arg, this.schema);
+            const result = (0, json_schema_1.validate)(inputForValidation, this.schema);
             if (!result.valid) {
                 let message = `Received tool input did not match expected schema`;
                 if (this.verboseParsingErrors) {
@@ -126,15 +125,22 @@ class StructuredTool extends base_js_1.BaseLangChain {
                         .map((e) => `${e.keywordLocation}: ${e.error}`)
                         .join("\n")}`;
                 }
+                // Pass the original raw input arg to the exception
                 throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
             }
+            // Assign the validated input to parsed
+            // We cast here because validate() doesn't narrow the type sufficiently for TS, but we know it's valid.
+            parsed = inputForValidation;
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
         const callbackManager_ = manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), 
+        // Log the original raw input arg
+        typeof arg === "string" ? arg : JSON.stringify(arg), config.runId, undefined, undefined, undefined, config.runName);
         delete config.runId;
         let result;
         try {
+            // Pass the correctly typed parsed input to _call
             result = await this._call(parsed, runManager, config);
         }
         catch (e) {
@@ -155,9 +161,13 @@ class StructuredTool extends base_js_1.BaseLangChain {
             content = result;
         }
         let toolCallId;
-        if (config && "configurable" in config) {
-            toolCallId = config.configurable
-                .tool_call_id;
+        // Extract toolCallId ONLY if the original arg was a ToolCall
+        if ((0, utils_js_1._isToolCall)(arg)) {
+            toolCallId = arg.id;
+        }
+        // Or if it was provided in the config's toolCall property
+        if (!toolCallId && (0, utils_js_1._configHasToolCallId)(config)) {
+            toolCallId = config.toolCall.id;
         }
         const formattedOutput = _formatToolOutput({
             content,
@@ -194,8 +204,13 @@ class Tool extends StructuredTool {
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
+    // Match the base class signature including the generics and conditional return type
     call(arg, callbacks) {
-        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
+        // Prepare the input for the base class call method.
+        // If arg is string or undefined, wrap it; otherwise, pass ToolCall or { input: ... } directly.
+        const structuredArg = typeof arg === "string" || arg == null ? { input: arg } : arg;
+        // Ensure TConfig is passed to super.call
+        return super.call(structuredArg, callbacks);
     }
 }
 exports.Tool = Tool;
@@ -239,10 +254,13 @@ class DynamicTool extends Tool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the Tool class's call method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config);
     }
     /** @ignore */
-    async _call(input, runManager, parentConfig) {
+    async _call(input, // DynamicTool's _call specifically expects a string after schema transformation
+    runManager, parentConfig) {
         return this.func(input, runManager, parentConfig);
     }
 }
@@ -295,6 +313,7 @@ class DynamicStructuredTool extends StructuredTool {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
+    // Match the base class signature
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
@@ -302,6 +321,8 @@ class DynamicStructuredTool extends StructuredTool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the base class method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config, tags);
     }
     _call(arg, runManager, parentConfig) {

package/dist/tools/index.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
+import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import { BaseLangChain } from "../language_models/base.js";
 import { type RunnableConfig } from "../runnables/config.js";
 import type { RunnableFunc } from "../runnables/base.js";
-import { ToolCall } from "../messages/tool.js";
+import { ToolCall, ToolMessage } from "../messages/tool.js";
 import { ToolInputParsingException } from "./utils.js";
-import type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, ZodObjectAny } from "./types.js";
+import type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, ZodObjectAny, StringInputToolSchema, ToolInterface, ToolOutputType } from "./types.js";
 import { type JSONSchema } from "../utils/json_schema.js";
 export type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from "./types.js";
 export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, } from "./types.js";
@@ -13,7 +13,7 @@ export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
-export declare abstract class StructuredTool<SchemaT extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolReturnType> {
+export declare abstract class StructuredTool<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
     abstract name: string;
     abstract description: string;
     abstract schema: SchemaT;
@@ -37,14 +37,14 @@ export declare abstract class StructuredTool<SchemaT extends ToolInputSchemaBase
      */
     responseFormat?: ResponseFormat;
     constructor(fields?: ToolParams);
-    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
+    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
     /**
      * Invokes the tool with the provided input and configuration.
      * @param input The input for the tool.
      * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
+     * @returns A Promise that resolves with the tool's output.
      */
-    invoke(input: StructuredToolCallInput<SchemaT, SchemaInputT>, config?: RunnableConfig): Promise<ToolReturnType>;
+    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>>;
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -56,16 +56,14 @@ export declare abstract class StructuredTool<SchemaT extends ToolInputSchemaBase
      * @param tags Optional tags for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: StructuredToolCallInput<SchemaT, SchemaInputT>, configArg?: Callbacks | ToolRunnableConfig, 
+    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType>;
+    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
 }
 /**
  * Base class for Tools that accept input as a string.
  */
-export declare abstract class Tool extends StructuredTool<z.ZodEffects<z.ZodObject<{
-    input: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, any, any>, any, any>> {
+export declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {
     schema: z.ZodEffects<z.ZodObject<{
         input: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -85,23 +83,24 @@ export declare abstract class Tool extends StructuredTool<z.ZodEffects<z.ZodObje
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: string | undefined | z.input<this["schema"]> | ToolCall, callbacks?: Callbacks | RunnableConfig): Promise<ToolReturnType>;
+    call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and description.
  */
-export declare class DynamicTool extends Tool {
+export declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {
     static lc_name(): string;
     name: string;
     description: string;
-    func: DynamicToolInput["func"];
-    constructor(fields: DynamicToolInput);
+    func: DynamicToolInput<ToolOutputT>["func"];
+    constructor(fields: DynamicToolInput<ToolOutputT>);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call(arg: string | undefined | z.input<this["schema"]> | ToolCall, configArg?: ToolRunnableConfig | Callbacks): Promise<ToolReturnType>;
+    call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
     /** @ignore */
-    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
+    _call(input: string, // DynamicTool's _call specifically expects a string after schema transformation
+    runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and
@@ -112,20 +111,20 @@ export declare class DynamicTool extends Tool {
  * Schema can be passed as Zod or JSON schema. The tool will not validate
  * input if JSON schema is passed.
  */
-export declare class DynamicStructuredTool<SchemaT extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT> {
+export declare class DynamicStructuredTool<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {
     static lc_name(): string;
     name: string;
     description: string;
-    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"];
+    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>["func"];
     schema: SchemaT;
-    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT>);
+    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call(arg: StructuredToolCallInput<SchemaT, SchemaInputT>, configArg?: RunnableConfig | Callbacks, 
+    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType>;
-    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;
 }
 /**
  * Abstract base class for toolkits in LangChain. Toolkits are collections
@@ -140,9 +139,9 @@ export declare abstract class BaseToolkit {
  * Parameters for the tool function.
  * Schema can be provided as Zod or JSON schema.
  * Both schema types will be validated.
- * @template {ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, a Zod string, or JSON schema.
+ * @template {ToolInputSchemaBase} RunInput The input schema for the tool.
  */
-interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny> extends ToolParams {
+interface ToolWrapperParams<RunInput extends ToolInputSchemaBase | undefined = ToolInputSchemaBase | undefined> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -183,9 +182,10 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | JSONSc
  * Schema can be provided as Zod or JSON schema, and both will be validated.
  *
  * @function
- * @template {ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny} SchemaT The input schema for the tool. Either any Zod object, a Zod string, or JSON schema instance.
+ * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.
+ * @template {ToolReturnType} ToolOutputT The output type of the tool.
  *
- * @param {RunnableFunc<z.output<SchemaT>, ToolReturnType>} func - The function to invoke when the tool is called.
+ * @param {RunnableFunc<z.output<SchemaT>, ToolOutputT>} func - The function to invoke when the tool is called.
  * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:
  * @param {string} fields.name The name of the tool.
  * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.
@@ -193,6 +193,6 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | JSONSc
  *
  * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.
  */
-export declare function tool<SchemaT extends z.ZodString>(func: RunnableFunc<SchemaT extends z.ZodString ? z.output<SchemaT> : string, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool;
-export declare function tool<SchemaT extends ZodObjectAny, SchemaOutputT = z.output<SchemaT>, SchemaInputT = z.input<SchemaT>>(func: RunnableFunc<SchemaOutputT, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT>;
-export declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT>;
+export declare function tool<SchemaT extends z.ZodString, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaT extends z.ZodString ? z.output<SchemaT> : string, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
+export declare function tool<SchemaT extends ZodObjectAny, SchemaOutputT = z.output<SchemaT>, SchemaInputT = z.input<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
+export declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;

package/dist/tools/index.js

@@ -5,7 +5,7 @@ import { BaseLangChain } from "../language_models/base.js";
 import { ensureConfig, patchConfig, pickRunnableConfigKeys, } from "../runnables/config.js";
 import { isDirectToolOutput, ToolMessage } from "../messages/tool.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
-import { _isToolCall, ToolInputParsingException } from "./utils.js";
+import { _configHasToolCallId, _isToolCall, ToolInputParsingException, } from "./utils.js";
 import { isZodSchema } from "../utils/types/is_zod_schema.js";
 import { validatesOnlyStrings } from "../utils/json_schema.js";
 export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, } from "./types.js";
@@ -60,22 +60,16 @@ export class StructuredTool extends BaseLangChain {
      * Invokes the tool with the provided input and configuration.
      * @param input The input for the tool.
      * @param config Optional configuration for the tool.
-     * @returns A Promise that resolves with a string.
+     * @returns A Promise that resolves with the tool's output.
      */
     async invoke(input, config) {
-        let tool_call_id;
         let toolInput;
         let enrichedConfig = ensureConfig(config);
         if (_isToolCall(input)) {
-            tool_call_id = input.id;
             toolInput = input.args;
             enrichedConfig = {
                 ...enrichedConfig,
                 toolCall: input,
-                configurable: {
-                    ...enrichedConfig.configurable,
-                    tool_call_id,
-                },
             };
         }
         else {
@@ -97,21 +91,26 @@ export class StructuredTool extends BaseLangChain {
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
-        let parsed = arg;
+        // Determine the actual input that needs parsing/validation.
+        // If arg is a ToolCall, use its args; otherwise, use arg directly.
+        const inputForValidation = _isToolCall(arg) ? arg.args : arg;
+        let parsed; // This will hold the successfully parsed input of the expected output type.
         if (isZodSchema(this.schema)) {
             try {
-                parsed = await this.schema.parseAsync(arg);
+                // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check
+                parsed = await this.schema.parseAsync(inputForValidation);
             }
             catch (e) {
                 let message = `Received tool input did not match expected schema`;
                 if (this.verboseParsingErrors) {
                     message = `${message}\nDetails: ${e.message}`;
                 }
+                // Pass the original raw input arg to the exception
                 throw new ToolInputParsingException(message, JSON.stringify(arg));
             }
         }
         else {
-            const result = validate(arg, this.schema);
+            const result = validate(inputForValidation, this.schema);
             if (!result.valid) {
                 let message = `Received tool input did not match expected schema`;
                 if (this.verboseParsingErrors) {
@@ -119,15 +118,22 @@ export class StructuredTool extends BaseLangChain {
                         .map((e) => `${e.keywordLocation}: ${e.error}`)
                         .join("\n")}`;
                 }
+                // Pass the original raw input arg to the exception
                 throw new ToolInputParsingException(message, JSON.stringify(arg));
             }
+            // Assign the validated input to parsed
+            // We cast here because validate() doesn't narrow the type sufficiently for TS, but we know it's valid.
+            parsed = inputForValidation;
         }
         const config = parseCallbackConfigArg(configArg);
         const callbackManager_ = CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), 
+        // Log the original raw input arg
+        typeof arg === "string" ? arg : JSON.stringify(arg), config.runId, undefined, undefined, undefined, config.runName);
         delete config.runId;
         let result;
         try {
+            // Pass the correctly typed parsed input to _call
             result = await this._call(parsed, runManager, config);
         }
         catch (e) {
@@ -148,9 +154,13 @@ export class StructuredTool extends BaseLangChain {
             content = result;
         }
         let toolCallId;
-        if (config && "configurable" in config) {
-            toolCallId = config.configurable
-                .tool_call_id;
+        // Extract toolCallId ONLY if the original arg was a ToolCall
+        if (_isToolCall(arg)) {
+            toolCallId = arg.id;
+        }
+        // Or if it was provided in the config's toolCall property
+        if (!toolCallId && _configHasToolCallId(config)) {
+            toolCallId = config.toolCall.id;
         }
         const formattedOutput = _formatToolOutput({
             content,
@@ -186,8 +196,13 @@ export class Tool extends StructuredTool {
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
+    // Match the base class signature including the generics and conditional return type
     call(arg, callbacks) {
-        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
+        // Prepare the input for the base class call method.
+        // If arg is string or undefined, wrap it; otherwise, pass ToolCall or { input: ... } directly.
+        const structuredArg = typeof arg === "string" || arg == null ? { input: arg } : arg;
+        // Ensure TConfig is passed to super.call
+        return super.call(structuredArg, callbacks);
     }
 }
 /**
@@ -230,10 +245,13 @@ export class DynamicTool extends Tool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the Tool class's call method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config);
     }
     /** @ignore */
-    async _call(input, runManager, parentConfig) {
+    async _call(input, // DynamicTool's _call specifically expects a string after schema transformation
+    runManager, parentConfig) {
         return this.func(input, runManager, parentConfig);
     }
 }
@@ -285,6 +303,7 @@ export class DynamicStructuredTool extends StructuredTool {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
+    // Match the base class signature
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
@@ -292,6 +311,8 @@ export class DynamicStructuredTool extends StructuredTool {
         if (config.runName === undefined) {
             config.runName = this.name;
         }
+        // Call the base class method, passing generics through
+        // Cast config to TConfig to satisfy the super.call signature
         return super.call(arg, config, tags);
     }
     _call(arg, runManager, parentConfig) {

package/dist/tools/types.d.ts

@@ -1,20 +1,39 @@
 import { z } from "zod";
-import { CallbackManagerForToolRun, type Callbacks } from "../callbacks/manager.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 { ToolCall } from "../messages/tool.js";
+import { type DirectToolOutput, type ToolCall, type ToolMessage } from "../messages/tool.js";
 import type { MessageContent } from "../messages/base.js";
 import { JSONSchema } from "../utils/json_schema.js";
 export type ResponseFormat = "content" | "content_and_artifact" | string;
-export type ToolReturnType = any;
+export type ToolOutputType = any;
 export type ContentAndArtifact = [MessageContent, any];
 export type ZodObjectAny = z.ZodObject<any, any, any, 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;
+    };
+} ? ToolMessage : TConfig extends {
+    toolCall: {
+        id: undefined;
+    };
+} ? TOutput : TConfig extends {
+    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 = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema;
+export type ToolInputSchemaBase = z.ZodAny | JSONSchema;
 /**
  * Parameters for the Tool classes.
  */
@@ -80,7 +99,32 @@ export type ToolInputSchemaInputType<T extends ToolInputSchemaBase> = T extends
  * @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 extends ToolInputSchemaBase = ZodObjectAny, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
+export type StructuredToolCallInput<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
+/**
+ * An input schema type for tools that accept a single string input.
+ *
+ * This schema defines a tool that takes an optional string parameter named "input".
+ * It uses Zod's effects to transform the input and strip any extra properties.
+ *
+ * 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 = z.ZodEffects<z.ZodObject<{
+    input: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, any, any>, any, any>;
+/**
+ * Defines the type for input to a tool's call method.
+ *
+ * This type is a convenience alias for StructuredToolCallInput with the input type
+ * derived from the schema. It represents the possible inputs that can be passed to a tool,
+ * which can be either:
+ * - A string (if the tool accepts string input)
+ * - A structured input matching the tool's schema
+ * - A ToolCall object (typically from an LLM)
+ *
+ * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema
+ */
+export type ToolCallInput<SchemaT extends ToolInputSchemaBase = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -90,12 +134,19 @@ export type StructuredToolCallInput<SchemaT extends ToolInputSchemaBase = ZodObj
  * @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 extends ToolInputSchemaBase = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolReturnType> {
+export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = 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.
      *
@@ -107,9 +158,9 @@ export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = Z
      * @param tags Optional tags for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: StructuredToolCallInput<SchemaT, SchemaInputT>, configArg?: Callbacks | RunnableConfig, 
+    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType>;
+    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
     /**
      * The name of the tool.
      */
@@ -132,7 +183,7 @@ export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = Z
  * @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 extends ToolInputSchemaBase = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends StructuredToolInterface<SchemaT, SchemaInputT> {
+export interface ToolInterface<SchemaT extends StringInputToolSchema = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -142,7 +193,7 @@ export interface ToolInterface<SchemaT extends ToolInputSchemaBase = ZodObjectAn
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: string | undefined | SchemaInputT | ToolCall, callbacks?: Callbacks | RunnableConfig): Promise<ToolReturnType>;
+    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
  * Base interface for the input parameters of the {@link DynamicTool} and
@@ -162,8 +213,8 @@ export interface BaseDynamicToolInput extends ToolParams {
 /**
  * Interface for the input parameters of the DynamicTool class.
  */
-export interface DynamicToolInput extends BaseDynamicToolInput {
-    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolReturnType>;
+export interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
+    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;
 }
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
@@ -171,7 +222,7 @@ export interface DynamicToolInput extends BaseDynamicToolInput {
  * @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 extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>> extends BaseDynamicToolInput {
+export interface DynamicStructuredToolInput<SchemaT extends ToolInputSchemaBase = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {
     /**
      * Tool handler function - the function that will be called when the tool is invoked.
      *
@@ -180,8 +231,8 @@ export interface DynamicStructuredToolInput<SchemaT extends ToolInputSchemaBase
      * @param config - The configuration for the tool.
      * @returns The result of the tool.
      */
-    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
-    schema: SchemaT extends ZodObjectAny ? SchemaT : SchemaT;
+    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;
+    schema: SchemaT;
 }
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.

package/dist/tools/utils.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolInputParsingException = exports._isToolCall = void 0;
+exports.ToolInputParsingException = exports._configHasToolCallId = exports._isToolCall = void 0;
 function _isToolCall(toolCall) {
     return !!(toolCall &&
         typeof toolCall === "object" &&
@@ -8,6 +8,16 @@ function _isToolCall(toolCall) {
         toolCall.type === "tool_call");
 }
 exports._isToolCall = _isToolCall;
+function _configHasToolCallId(config) {
+    return !!(config &&
+        typeof config === "object" &&
+        "toolCall" in config &&
+        config.toolCall != null &&
+        typeof config.toolCall === "object" &&
+        "id" in config.toolCall &&
+        typeof config.toolCall.id === "string");
+}
+exports._configHasToolCallId = _configHasToolCallId;
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`

package/dist/tools/utils.d.ts

@@ -1,5 +1,10 @@
 import { ToolCall } from "../messages/tool.js";
 export declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;
+export declare function _configHasToolCallId(config?: unknown): config is {
+    toolCall: {
+        id?: string;
+    };
+};
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`

package/dist/tools/utils.js

@@ -4,6 +4,15 @@ export function _isToolCall(toolCall) {
         "type" in toolCall &&
         toolCall.type === "tool_call");
 }
+export function _configHasToolCallId(config) {
+    return !!(config &&
+        typeof config === "object" &&
+        "toolCall" in config &&
+        config.toolCall != null &&
+        typeof config.toolCall === "object" &&
+        "id" in config.toolCall &&
+        typeof config.toolCall.id === "string");
+}
 /**
  * Custom error class used to handle exceptions related to tool input parsing.
  * It extends the built-in `Error` class and adds an optional `output`

package/package.json

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