@langchain/core 0.3.43 → 0.3.45

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/output_parsers/structured.cjs

@@ -55,7 +55,7 @@ class StructuredOutputParser extends base_js_1.BaseOutputParser {
 
 "JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.
 
-For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}
+For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}
 would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.
 Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
 

package/dist/output_parsers/structured.js

@@ -52,7 +52,7 @@ export class StructuredOutputParser extends BaseOutputParser {
 
 "JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.
 
-For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}
+For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}
 would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.
 Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
 

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;