@nocobase/plugin-ai 1.9.33 → 1.9.35

package/dist/node_modules/@langchain/core/dist/tools/index.d.ts

@@ -1,94 +1,23 @@
-import { z } from "zod";
-import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
-import { BaseLangChain, type BaseLangChainParams } from "../language_models/base.js";
+import { z } from "zod/v3";
+import { CallbackManagerForToolRun } from "../callbacks/manager.js";
+import { BaseLangChain } from "../language_models/base.js";
 import { type RunnableConfig } from "../runnables/config.js";
-import type { RunnableFunc, RunnableInterface } from "../runnables/base.js";
-import { ToolCall } from "../messages/tool.js";
-import { MessageContent } from "../messages/base.js";
+import type { RunnableFunc } from "../runnables/base.js";
+import { ToolCall, ToolMessage } from "../messages/tool.js";
 import { ToolInputParsingException } from "./utils.js";
+import { type InferInteropZodInput, type InferInteropZodOutput, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from "../utils/types/zod.js";
+import type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, 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";
 export { ToolInputParsingException };
-export type ResponseFormat = "content" | "content_and_artifact" | string;
-type ToolReturnType = any;
-export type ContentAndArtifact = [MessageContent, any];
-type ZodObjectAny = z.ZodObject<any, any, any, any>;
-/**
- * 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;
-    /**
-     * 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;
-};
-/**
- * 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;
-}
-export interface StructuredToolInterface<T extends ZodObjectAny = ZodObjectAny> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
-    lc_namespace: string[];
-    /**
-     * A Zod schema representing the parameters of the tool.
-     */
-    schema: T | z.ZodEffects<T>;
-    /**
-     * @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(arg: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, configArg?: Callbacks | RunnableConfig, 
-    /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType>;
-    /**
-     * 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;
-}
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
-export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
+export declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
     abstract name: string;
     abstract description: string;
-    abstract schema: T | z.ZodEffects<T>;
+    abstract schema: SchemaT;
     /**
      * Whether to return the tool's output directly.
      *
@@ -108,15 +37,19 @@ export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectA
      * @default "content"
      */
     responseFormat?: ResponseFormat;
+    /**
+     * Default config object for the tool runnable.
+     */
+    defaultConfig?: ToolRunnableConfig;
     constructor(fields?: ToolParams);
-    protected abstract _call(arg: z.output<T>, 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: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, 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.
      *
@@ -128,26 +61,14 @@ export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectA
      * @param tags Optional tags for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: (z.output<T> extends string ? string : never) | z.input<T>, configArg?: Callbacks | ToolRunnableConfig, 
+    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType>;
-}
-export interface ToolInterface<T extends ZodObjectAny = ZodObjectAny> extends StructuredToolInterface<T> {
-    /**
-     * @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(arg: string | undefined | z.input<this["schema"]> | ToolCall, callbacks?: Callbacks | RunnableConfig): 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<ZodObjectAny> {
+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, {
@@ -167,47 +88,24 @@ export declare abstract class Tool extends StructuredTool<ZodObjectAny> {
      * @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>;
-}
-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 for the input parameters of the DynamicTool class.
- */
-export interface DynamicToolInput extends BaseDynamicToolInput {
-    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolReturnType>;
-}
-/**
- * Interface for the input parameters of the DynamicStructuredTool class.
- */
-export interface DynamicStructuredToolInput<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends BaseDynamicToolInput {
-    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : T extends ZodObjectAny ? z.infer<T> : T, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
-    schema: T extends ZodObjectAny ? T : T;
+    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
@@ -218,20 +116,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<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends StructuredTool<T extends ZodObjectAny ? T : ZodObjectAny> {
+export declare class DynamicStructuredTool<SchemaT = 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<T>["func"];
-    schema: T extends ZodObjectAny ? T : ZodObjectAny;
-    constructor(fields: DynamicStructuredToolInput<T>);
+    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>["func"];
+    schema: SchemaT;
+    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, 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: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, 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
@@ -245,10 +143,10 @@ export declare abstract class BaseToolkit {
 /**
  * Parameters for the tool function.
  * Schema can be provided as Zod or JSON schema.
- * If you pass JSON schema, tool inputs will not be validated.
- * @template {ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, a Zod string, or JSON schema.
+ * Both schema types will be validated.
+ * @template {ToolInputSchemaBase} RunInput The input schema for the tool.
  */
-interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny> extends ToolParams {
+interface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -286,20 +184,22 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
  *
- * Schema can be provided as Zod or JSON schema.
- * If you pass JSON schema, tool inputs will not be validated.
+ * Schema can be provided as Zod or JSON schema, and both will be validated.
  *
  * @function
- * @template {ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny} T 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<T>, ToolReturnType>} func - The function to invoke when the tool is called.
- * @param {ToolWrapperParams<T>} fields - An object containing the following properties:
+ * @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`.
- * @param {ZodObjectAny | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.
+ * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.
  *
- * @returns {DynamicStructuredTool<T>} A new StructuredTool instance.
+ * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.
  */
-export declare function tool<T extends z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicTool;
-export declare function tool<T extends ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
-export declare function tool<T extends Record<string, any>>(func: RunnableFunc<T, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
+export declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
+export declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
+export declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
+export declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<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/node_modules/@langchain/core/dist/tools/index.js

@@ -1,11 +1,14 @@
-import { z } from "zod";
+import { z } from "zod/v3";
+import { validate, } from "@cfworker/json-schema";
 import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
-import { BaseLangChain, } from "../language_models/base.js";
-import { ensureConfig, patchConfig, pickRunnableConfigKeys, } from "../runnables/config.js";
+import { BaseLangChain } from "../language_models/base.js";
+import { mergeConfigs, 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 { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { _configHasToolCallId, _isToolCall, ToolInputParsingException, } from "./utils.js";
+import { interopParseAsync, isSimpleStringZodSchema, isInteropZodSchema, getSchemaDescription, } from "../utils/types/zod.js";
+import { validatesOnlyStrings } from "../utils/json_schema.js";
+export { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, } from "./types.js";
 export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
@@ -49,30 +52,35 @@ export class StructuredTool extends BaseLangChain {
             writable: true,
             value: "content"
         });
+        /**
+         * Default config object for the tool runnable.
+         */
+        Object.defineProperty(this, "defaultConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.verboseParsingErrors =
             fields?.verboseParsingErrors ?? this.verboseParsingErrors;
         this.responseFormat = fields?.responseFormat ?? this.responseFormat;
+        this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;
+        this.metadata = fields?.metadata ?? this.metadata;
     }
     /**
      * 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);
+        let enrichedConfig = ensureConfig(mergeConfigs(this.defaultConfig, config));
         if (_isToolCall(input)) {
-            tool_call_id = input.id;
             toolInput = input.args;
             enrichedConfig = {
                 ...enrichedConfig,
                 toolCall: input,
-                configurable: {
-                    ...enrichedConfig.configurable,
-                    tool_call_id,
-                },
             };
         }
         else {
@@ -94,26 +102,50 @@ export class StructuredTool extends BaseLangChain {
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
-        let parsed;
-        try {
-            parsed = await this.schema.parseAsync(arg);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // 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 (isInteropZodSchema(this.schema)) {
+            try {
+                // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check
+                parsed = await interopParseAsync(this.schema, 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));
+            }
         }
-        catch (e) {
-            let message = `Received tool input did not match expected schema`;
-            if (this.verboseParsingErrors) {
-                message = `${message}\nDetails: ${e.message}`;
+        else {
+            const result = validate(inputForValidation, this.schema);
+            if (!result.valid) {
+                let message = `Received tool input did not match expected schema`;
+                if (this.verboseParsingErrors) {
+                    message = `${message}\nDetails: ${result.errors
+                        .map((e) => `${e.keywordLocation}: ${e.error}`)
+                        .join("\n")}`;
+                }
+                // Pass the original raw input arg to the exception
+                throw new ToolInputParsingException(message, JSON.stringify(arg));
             }
-            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);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -133,15 +165,20 @@ 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,
             artifact,
             toolCallId,
             name: this.name,
+            metadata: this.metadata,
         });
         await runManager?.handleToolEnd(formattedOutput);
         return formattedOutput;
@@ -171,8 +208,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);
     }
 }
 /**
@@ -215,10 +257,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);
     }
 }
@@ -265,11 +310,12 @@ export class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = (isZodSchema(fields.schema) ? fields.schema : z.object({}).passthrough());
+        this.schema = fields.schema;
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
+    // Match the base class signature
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
@@ -277,10 +323,11 @@ 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) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.func(arg, runManager, parentConfig);
     }
 }
@@ -295,14 +342,14 @@ export class BaseToolkit {
     }
 }
 export function tool(func, fields) {
-    // If the schema is not provided, or it's a string schema, create a DynamicTool
-    if (!fields.schema ||
-        (isZodSchema(fields.schema) &&
-            (!("shape" in fields.schema) || !fields.schema.shape))) {
+    const isSimpleStringSchema = isSimpleStringZodSchema(fields.schema);
+    const isStringJSONSchema = validatesOnlyStrings(fields.schema);
+    // If the schema is not provided, or it's a simple string schema, create a DynamicTool
+    if (!fields.schema || isSimpleStringSchema || isStringJSONSchema) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
-                fields.schema?.description ??
+                (fields.schema && getSchemaDescription(fields.schema)) ??
                 `${fields.name} tool`,
             func: async (input, runManager, config) => {
                 return new Promise((resolve, reject) => {
@@ -323,13 +370,14 @@ export function tool(func, fields) {
             },
         });
     }
-    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
+    const schema = fields.schema;
+    const description = fields.description ??
+        fields.schema.description ??
+        `${fields.name} tool`;
     return new DynamicStructuredTool({
         ...fields,
         description,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        schema: fields.schema,
-        // TODO: Consider moving into DynamicStructuredTool constructor
+        schema,
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
                 const childConfig = patchConfig(config, {
@@ -337,8 +385,6 @@ export function tool(func, fields) {
                 });
                 void AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
                     try {
-                        // TS doesn't restrict the type here based on the guard above
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         resolve(func(input, childConfig));
                     }
                     catch (e) {
@@ -350,24 +396,28 @@ export function tool(func, fields) {
     });
 }
 function _formatToolOutput(params) {
-    const { content, artifact, toolCallId } = params;
+    const { content, artifact, toolCallId, metadata } = params;
     if (toolCallId && !isDirectToolOutput(content)) {
         if (typeof content === "string" ||
             (Array.isArray(content) &&
                 content.every((item) => typeof item === "object"))) {
             return new ToolMessage({
+                status: "success",
                 content,
                 artifact,
                 tool_call_id: toolCallId,
                 name: params.name,
+                metadata,
             });
         }
         else {
             return new ToolMessage({
+                status: "success",
                 content: _stringify(content),
                 artifact,
                 tool_call_id: toolCallId,
                 name: params.name,
+                metadata,
             });
         }
     }
@@ -377,7 +427,7 @@ function _formatToolOutput(params) {
 }
 function _stringify(content) {
     try {
-        return JSON.stringify(content, null, 2);
+        return JSON.stringify(content, null, 2) ?? "";
     }
     catch (_noOp) {
         return `${content}`;

package/dist/node_modules/@langchain/core/dist/tools/types.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStructuredTool = isStructuredTool;
+exports.isRunnableToolLike = isRunnableToolLike;
+exports.isStructuredToolParams = isStructuredToolParams;
+exports.isLangChainTool = isLangChainTool;
+const base_js_1 = require("../runnables/base.cjs");
+const zod_js_1 = require("../utils/types/zod.cjs");
+/**
+ * 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 !== undefined &&
+        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`.
+ */
+function isRunnableToolLike(tool) {
+    return (tool !== undefined &&
+        base_js_1.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`.
+ */
+function isStructuredToolParams(tool) {
+    return (!!tool &&
+        typeof tool === "object" &&
+        "name" in tool &&
+        "schema" in tool &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ((0, zod_js_1.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.
+ */
+function isLangChainTool(tool) {
+    return (isStructuredToolParams(tool) ||
+        isRunnableToolLike(tool) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isStructuredTool(tool));
+}