@nocobase/plugin-ai 1.9.36 → 1.9.38

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

@@ -1,23 +1,94 @@
-import { z } from "zod/v3";
-import { CallbackManagerForToolRun } from "../callbacks/manager.js";
-import { BaseLangChain } from "../language_models/base.js";
+import { z } from "zod";
+import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
+import { BaseLangChain, type BaseLangChainParams } from "../language_models/base.js";
 import { type RunnableConfig } from "../runnables/config.js";
-import type { RunnableFunc } from "../runnables/base.js";
-import { ToolCall, ToolMessage } from "../messages/tool.js";
+import type { RunnableFunc, RunnableInterface } from "../runnables/base.js";
+import { ToolCall } from "../messages/tool.js";
+import { MessageContent } from "../messages/base.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<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {
+export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectAny> extends BaseLangChain<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
     abstract name: string;
     abstract description: string;
-    abstract schema: SchemaT;
+    abstract schema: T | z.ZodEffects<T>;
     /**
      * Whether to return the tool's output directly.
      *
@@ -37,19 +108,15 @@ export declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, Sche
      * @default "content"
      */
     responseFormat?: ResponseFormat;
-    /**
-     * Default config object for the tool runnable.
-     */
-    defaultConfig?: ToolRunnableConfig;
     constructor(fields?: ToolParams);
-    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+    protected abstract _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
     /**
      * 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 the tool's output.
+     * @returns A Promise that resolves with a string.
      */
-    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>>;
+    invoke(input: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, config?: RunnableConfig): Promise<ToolReturnType>;
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -61,14 +128,26 @@ export declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, Sche
      * @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, 
+    call(arg: (z.output<T> extends string ? string : never) | z.input<T>, configArg?: Callbacks | ToolRunnableConfig, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;
+    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>;
 }
 /**
  * Base class for Tools that accept input as a string.
  */
-export declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {
+export declare abstract class Tool extends StructuredTool<ZodObjectAny> {
     schema: z.ZodEffects<z.ZodObject<{
         input: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -88,24 +167,47 @@ export declare abstract class Tool<ToolOutputT = ToolOutputType> extends Structu
      * @param callbacks Optional callbacks for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+    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;
 }
 /**
  * A tool that can be created dynamically from a function, name, and description.
  */
-export declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {
+export declare class DynamicTool extends Tool {
     static lc_name(): string;
     name: string;
     description: string;
-    func: DynamicToolInput<ToolOutputT>["func"];
-    constructor(fields: DynamicToolInput<ToolOutputT>);
+    func: DynamicToolInput["func"];
+    constructor(fields: DynamicToolInput);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+    call(arg: string | undefined | z.input<this["schema"]> | ToolCall, configArg?: ToolRunnableConfig | Callbacks): Promise<ToolReturnType>;
     /** @ignore */
-    _call(input: string, // DynamicTool's _call specifically expects a string after schema transformation
-    runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and
@@ -116,20 +218,20 @@ export declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<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 = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {
+export declare class DynamicStructuredTool<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends StructuredTool<T extends ZodObjectAny ? T : ZodObjectAny> {
     static lc_name(): string;
     name: string;
     description: string;
-    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>["func"];
-    schema: SchemaT;
-    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>);
+    func: DynamicStructuredToolInput<T>["func"];
+    schema: T extends ZodObjectAny ? T : ZodObjectAny;
+    constructor(fields: DynamicStructuredToolInput<T>);
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, 
+    call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, configArg?: RunnableConfig | Callbacks, 
     /** @deprecated */
-    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
-    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;
+    tags?: string[]): Promise<ToolReturnType>;
+    protected _call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
 }
 /**
  * Abstract base class for toolkits in LangChain. Toolkits are collections
@@ -143,10 +245,10 @@ 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 {ToolInputSchemaBase} RunInput The input schema for the tool.
+ * 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.
  */
-interface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends ToolParams {
+interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -184,22 +286,20 @@ interface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends
 /**
  * Creates a new StructuredTool instance with the provided function, name, description, and schema.
  *
- * Schema can be provided as Zod or JSON schema, and both will be validated.
+ * Schema can be provided as Zod or JSON schema.
+ * If you pass JSON schema, tool inputs will not be validated.
  *
  * @function
- * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.
- * @template {ToolReturnType} ToolOutputT The output type of the tool.
+ * @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.
  *
- * @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 {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 {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 {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.
+ * @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.
  *
- * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.
+ * @returns {DynamicStructuredTool<T>} A new StructuredTool instance.
  */
-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>;
+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>;

package/dist/node_modules/@langchain/core/dist/tools/index.js

@@ -1,14 +1,11 @@
-import { z } from "zod/v3";
-import { validate, } from "@cfworker/json-schema";
+import { z } from "zod";
 import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
-import { BaseLangChain } from "../language_models/base.js";
-import { mergeConfigs, ensureConfig, patchConfig, pickRunnableConfigKeys, } from "../runnables/config.js";
+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 { _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";
+import { _isToolCall, ToolInputParsingException } from "./utils.js";
+import { isZodSchema } from "../utils/types/is_zod_schema.js";
 export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
@@ -52,35 +49,30 @@ 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 the tool's output.
+     * @returns A Promise that resolves with a string.
      */
     async invoke(input, config) {
+        let tool_call_id;
         let toolInput;
-        let enrichedConfig = ensureConfig(mergeConfigs(this.defaultConfig, config));
+        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 {
@@ -102,50 +94,26 @@ export class StructuredTool extends BaseLangChain {
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
-        // 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));
-            }
+        let parsed;
+        try {
+            parsed = await this.schema.parseAsync(arg);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
-        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));
+        catch (e) {
+            let message = `Received tool input did not match expected schema`;
+            if (this.verboseParsingErrors) {
+                message = `${message}\nDetails: ${e.message}`;
             }
-            // 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;
+            throw new ToolInputParsingException(message, JSON.stringify(arg));
         }
         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(), 
-        // Log the original raw input arg
-        typeof arg === "string" ? arg : JSON.stringify(arg), config.runId, undefined, undefined, undefined, config.runName);
+        const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), 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);
@@ -165,20 +133,15 @@ export class StructuredTool extends BaseLangChain {
             content = result;
         }
         let toolCallId;
-        // 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;
+        if (config && "configurable" in config) {
+            toolCallId = config.configurable
+                .tool_call_id;
         }
         const formattedOutput = _formatToolOutput({
             content,
             artifact,
             toolCallId,
             name: this.name,
-            metadata: this.metadata,
         });
         await runManager?.handleToolEnd(formattedOutput);
         return formattedOutput;
@@ -208,13 +171,8 @@ 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) {
-        // 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);
+        return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
     }
 }
 /**
@@ -257,13 +215,10 @@ 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, // DynamicTool's _call specifically expects a string after schema transformation
-    runManager, parentConfig) {
+    async _call(input, runManager, parentConfig) {
         return this.func(input, runManager, parentConfig);
     }
 }
@@ -310,12 +265,11 @@ export class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = fields.schema;
+        this.schema = (isZodSchema(fields.schema) ? fields.schema : z.object({}).passthrough());
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    // Match the base class signature
     async call(arg, configArg, 
     /** @deprecated */
     tags) {
@@ -323,11 +277,10 @@ 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);
     }
 }
@@ -342,14 +295,14 @@ export class BaseToolkit {
     }
 }
 export function tool(func, fields) {
-    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) {
+    // 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))) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
-                (fields.schema && getSchemaDescription(fields.schema)) ??
+                fields.schema?.description ??
                 `${fields.name} tool`,
             func: async (input, runManager, config) => {
                 return new Promise((resolve, reject) => {
@@ -370,14 +323,13 @@ export function tool(func, fields) {
             },
         });
     }
-    const schema = fields.schema;
-    const description = fields.description ??
-        fields.schema.description ??
-        `${fields.name} tool`;
+    const description = fields.description ?? fields.schema.description ?? `${fields.name} tool`;
     return new DynamicStructuredTool({
         ...fields,
         description,
-        schema,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        schema: fields.schema,
+        // TODO: Consider moving into DynamicStructuredTool constructor
         func: async (input, runManager, config) => {
             return new Promise((resolve, reject) => {
                 const childConfig = patchConfig(config, {
@@ -385,6 +337,8 @@ 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) {
@@ -396,28 +350,24 @@ export function tool(func, fields) {
     });
 }
 function _formatToolOutput(params) {
-    const { content, artifact, toolCallId, metadata } = params;
+    const { content, artifact, toolCallId } = 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,
             });
         }
     }
@@ -427,7 +377,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/utils.cjs

@@ -1,23 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolInputParsingException = void 0;
-exports._isToolCall = _isToolCall;
-exports._configHasToolCallId = _configHasToolCallId;
+exports.ToolInputParsingException = exports._isToolCall = void 0;
 function _isToolCall(toolCall) {
     return !!(toolCall &&
         typeof toolCall === "object" &&
         "type" in toolCall &&
         toolCall.type === "tool_call");
 }
-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._isToolCall = _isToolCall;
 /**
  * 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/node_modules/@langchain/core/dist/tools/utils.d.ts

@@ -1,10 +1,5 @@
 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/node_modules/@langchain/core/dist/tools/utils.js

@@ -4,15 +4,6 @@ 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`