@langchain/core 0.3.43 → 0.3.44

package/dist/language_models/base.d.ts

@@ -8,6 +8,7 @@ import { CallbackManager, Callbacks } from "../callbacks/manager.js";
 import { AsyncCaller, AsyncCallerParams } from "../utils/async_caller.js";
 import { Runnable, type RunnableInterface } from "../runnables/base.js";
 import { RunnableConfig } from "../runnables/config.js";
+import { JSONSchema } from "../utils/json_schema.js";
 export declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;
 export declare const getEmbeddingContextSize: (modelName?: string) => number;
 export declare const getModelContextSize: (modelName: string) => number;
@@ -83,7 +84,7 @@ export interface FunctionDefinition {
      * To describe a function that accepts no parameters, provide the value
      * `{"type": "object", "properties": {}}`.
      */
-    parameters: Record<string, unknown>;
+    parameters: Record<string, unknown> | JSONSchema;
     /**
      * A description of what the function does, used by the model to choose when and
      * how to call the function.

package/dist/tools/index.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tool = exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
+const json_schema_1 = require("@cfworker/json-schema");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_1 = require("../language_models/base.cjs");
 const config_js_1 = require("../runnables/config.cjs");
@@ -10,6 +11,7 @@ const index_js_1 = require("../singletons/index.cjs");
 const utils_js_1 = require("./utils.cjs");
 Object.defineProperty(exports, "ToolInputParsingException", { enumerable: true, get: function () { return utils_js_1.ToolInputParsingException; } });
 const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const json_schema_js_1 = require("../utils/json_schema.cjs");
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
  */
@@ -97,17 +99,30 @@ class StructuredTool extends base_js_1.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
+        let parsed = arg;
+        if ((0, is_zod_schema_js_1.isZodSchema)(this.schema)) {
+            try {
+                parsed = await this.schema.parseAsync(arg);
+            }
+            catch (e) {
+                let message = `Received tool input did not match expected schema`;
+                if (this.verboseParsingErrors) {
+                    message = `${message}\nDetails: ${e.message}`;
+                }
+                throw new utils_js_1.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 = (0, json_schema_1.validate)(arg, 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")}`;
+                }
+                throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
             }
-            throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
         }
         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 });
@@ -116,7 +131,6 @@ class StructuredTool extends base_js_1.BaseLangChain {
         let result;
         try {
             result = await this._call(parsed, runManager, config);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -271,7 +285,7 @@ class DynamicStructuredTool extends StructuredTool {
         this.description = fields.description;
         this.func = fields.func;
         this.returnDirect = fields.returnDirect ?? this.returnDirect;
-        this.schema = ((0, is_zod_schema_js_1.isZodSchema)(fields.schema) ? fields.schema : zod_1.z.object({}).passthrough());
+        this.schema = fields.schema;
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -286,7 +300,6 @@ class DynamicStructuredTool extends StructuredTool {
         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);
     }
 }
@@ -303,10 +316,12 @@ class BaseToolkit {
 }
 exports.BaseToolkit = BaseToolkit;
 function tool(func, fields) {
-    // If the schema is not provided, or it's a string schema, create a DynamicTool
-    if (!fields.schema ||
-        ((0, is_zod_schema_js_1.isZodSchema)(fields.schema) &&
-            (!("shape" in fields.schema) || !fields.schema.shape))) {
+    const isShapelessZodSchema = fields.schema &&
+        (0, is_zod_schema_js_1.isZodSchema)(fields.schema) &&
+        (!("shape" in fields.schema) || !fields.schema.shape);
+    const isStringJSONSchema = (0, json_schema_js_1.validatesOnlyStrings)(fields.schema);
+    // If the schema is not provided, or it's a shapeless schema (e.g. a ZodString), create a DynamicTool
+    if (!fields.schema || isShapelessZodSchema || isStringJSONSchema) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
@@ -331,13 +346,14 @@ 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 = (0, config_js_1.patchConfig)(config, {
@@ -345,8 +361,6 @@ function tool(func, fields) {
                 });
                 void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.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) {

package/dist/tools/index.d.ts

@@ -1,94 +1,21 @@
 import { z } from "zod";
 import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
-import { BaseLangChain, type BaseLangChainParams } from "../language_models/base.js";
+import { BaseLangChain } from "../language_models/base.js";
 import { type RunnableConfig } from "../runnables/config.js";
-import type { RunnableFunc, RunnableInterface } from "../runnables/base.js";
+import type { RunnableFunc } from "../runnables/base.js";
 import { ToolCall } from "../messages/tool.js";
-import { MessageContent } from "../messages/base.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 JSONSchema } from "../utils/json_schema.js";
+export type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } 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 extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolReturnType> {
     abstract name: string;
     abstract description: string;
-    abstract schema: T | z.ZodEffects<T>;
+    abstract schema: SchemaT;
     /**
      * Whether to return the tool's output directly.
      *
@@ -109,14 +36,14 @@ export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectA
      */
     responseFormat?: ResponseFormat;
     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<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 a string.
      */
-    invoke(input: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, config?: RunnableConfig): Promise<ToolReturnType>;
+    invoke(input: StructuredToolCallInput<SchemaT, SchemaInputT>, config?: RunnableConfig): Promise<ToolReturnType>;
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      *
@@ -128,26 +55,16 @@ 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(arg: StructuredToolCallInput<SchemaT, SchemaInputT>, configArg?: Callbacks | ToolRunnableConfig, 
     /** @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>;
-}
 /**
  * Base class for Tools that accept input as a string.
  */
-export declare abstract class Tool extends StructuredTool<ZodObjectAny> {
+export declare abstract class Tool extends StructuredTool<z.ZodEffects<z.ZodObject<{
+    input: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, any, any>, any, any>> {
     schema: z.ZodEffects<z.ZodObject<{
         input: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -169,30 +86,6 @@ export declare abstract class Tool extends StructuredTool<ZodObjectAny> {
      */
     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.
  */
@@ -218,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<T extends ZodObjectAny | Record<string, any> = ZodObjectAny> extends StructuredTool<T extends ZodObjectAny ? T : ZodObjectAny> {
+export declare class DynamicStructuredTool<SchemaT extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT> {
     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>["func"];
+    schema: SchemaT;
+    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT>);
     /**
      * @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(arg: StructuredToolCallInput<SchemaT, SchemaInputT>, configArg?: RunnableConfig | Callbacks, 
     /** @deprecated */
     tags?: string[]): Promise<ToolReturnType>;
-    protected _call(arg: (T extends ZodObjectAny ? z.output<T> : T) | ToolCall, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
 }
 /**
  * Abstract base class for toolkits in LangChain. Toolkits are collections
@@ -245,10 +138,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 {ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny} RunInput The input schema for the tool. Either any Zod object, a Zod string, or JSON schema.
  */
-interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record<string, any> = ZodObjectAny> extends ToolParams {
+interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny> extends ToolParams {
     /**
      * The name of the tool. If using with an LLM, this
      * will be passed as the tool name.
@@ -286,20 +179,19 @@ 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 {ZodObjectAny | z.ZodString | JSONSchema = ZodObjectAny} SchemaT The input schema for the tool. Either any Zod object, a Zod string, or JSON schema instance.
  *
- * @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>, ToolReturnType>} 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.
  *
- * @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 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>;

package/dist/tools/index.js

@@ -1,11 +1,13 @@
 import { z } from "zod";
+import { validate, } from "@cfworker/json-schema";
 import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
-import { BaseLangChain, } from "../language_models/base.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 { _isToolCall, ToolInputParsingException } from "./utils.js";
 import { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { validatesOnlyStrings } from "../utils/json_schema.js";
 export { ToolInputParsingException };
 /**
  * Base class for Tools that accept input of any shape defined by a Zod schema.
@@ -94,17 +96,30 @@ 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
+        let parsed = arg;
+        if (isZodSchema(this.schema)) {
+            try {
+                parsed = await this.schema.parseAsync(arg);
+            }
+            catch (e) {
+                let message = `Received tool input did not match expected schema`;
+                if (this.verboseParsingErrors) {
+                    message = `${message}\nDetails: ${e.message}`;
+                }
+                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(arg, 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")}`;
+                }
+                throw new ToolInputParsingException(message, JSON.stringify(arg));
             }
-            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 });
@@ -113,7 +128,6 @@ export class StructuredTool extends BaseLangChain {
         let result;
         try {
             result = await this._call(parsed, runManager, config);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             await runManager?.handleToolError(e);
@@ -265,7 +279,7 @@ 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.
@@ -280,7 +294,6 @@ export class DynamicStructuredTool extends StructuredTool {
         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,10 +308,12 @@ 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 isShapelessZodSchema = fields.schema &&
+        isZodSchema(fields.schema) &&
+        (!("shape" in fields.schema) || !fields.schema.shape);
+    const isStringJSONSchema = validatesOnlyStrings(fields.schema);
+    // If the schema is not provided, or it's a shapeless schema (e.g. a ZodString), create a DynamicTool
+    if (!fields.schema || isShapelessZodSchema || isStringJSONSchema) {
         return new DynamicTool({
             ...fields,
             description: fields.description ??
@@ -323,13 +338,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 +353,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) {

package/dist/tools/types.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLangChainTool = exports.isStructuredToolParams = exports.isRunnableToolLike = exports.isStructuredTool = void 0;
+const base_js_1 = require("../runnables/base.cjs");
+const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.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));
+}
+exports.isStructuredTool = isStructuredTool;
+/**
+ * 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");
+}
+exports.isRunnableToolLike = isRunnableToolLike;
+/**
+ * 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, is_zod_schema_js_1.isZodSchema)(tool.schema));
+}
+exports.isStructuredToolParams = isStructuredToolParams;
+/**
+ * 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));
+}
+exports.isLangChainTool = isLangChainTool;