@langchain/core 0.3.43 → 0.3.45

package/dist/tools/types.d.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+import { CallbackManagerForToolRun, type Callbacks } from "../callbacks/manager.js";
+import type { BaseLangChainParams, ToolDefinition } from "../language_models/base.js";
+import type { RunnableConfig } from "../runnables/config.js";
+import { RunnableToolLike, type RunnableInterface } from "../runnables/base.js";
+import type { ToolCall } from "../messages/tool.js";
+import type { MessageContent } from "../messages/base.js";
+import { JSONSchema } from "../utils/json_schema.js";
+export type ResponseFormat = "content" | "content_and_artifact" | string;
+export type ToolReturnType = any;
+export type ContentAndArtifact = [MessageContent, any];
+export type ZodObjectAny = z.ZodObject<any, any, any, any>;
+/**
+ * Base type that establishes the types of input schemas that can be used for LangChain tool
+ * definitions.
+ */
+export type ToolInputSchemaBase = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema;
+/**
+ * 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;
+}
+/**
+ * Utility type that resolves the output type of a tool input schema.
+ *
+ * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur
+ * during parsing. When using JSONSchema, input and output types are the same.
+ *
+ * The input type for a given schema should match the structure of the arguments that the LLM
+ * generates as part of its {@link ToolCall}. The output type will be the type that results from
+ * applying any transforms defined in your schema. If there are no transforms, the input and output
+ * types will be the same.
+ */
+export type ToolInputSchemaOutputType<T extends ToolInputSchemaBase> = T extends z.ZodSchema ? z.output<T> : T extends JSONSchema ? unknown : never;
+/**
+ * Utility type that resolves the input type of a tool input schema.
+ *
+ * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur
+ * during parsing. When using JSONSchema, input and output types are the same.
+ *
+ * The input type for a given schema should match the structure of the arguments that the LLM
+ * generates as part of its {@link ToolCall}. The output type will be the type that results from
+ * applying any transforms defined in your schema. If there are no transforms, the input and output
+ * types will be the same.
+ */
+export type ToolInputSchemaInputType<T extends ToolInputSchemaBase> = T extends z.ZodSchema ? z.input<T> : T extends JSONSchema ? unknown : never;
+/**
+ * Defines the type that will be passed into a tool handler function as a result of a tool call.
+ *
+ * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
+ * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
+ */
+export type StructuredToolCallInput<SchemaT extends ToolInputSchemaBase = ZodObjectAny, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;
+/**
+ * Interface that defines the shape of a LangChain structured tool.
+ *
+ * A structured tool is a tool that uses a schema to define the structure of the arguments that the
+ * LLM generates as part of its {@link ToolCall}.
+ *
+ * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
+ * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
+ */
+export interface StructuredToolInterface<SchemaT extends ToolInputSchemaBase = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolReturnType> {
+    lc_namespace: string[];
+    /**
+     * A Zod schema representing the parameters of the tool.
+     */
+    schema: SchemaT;
+    /**
+     * @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: StructuredToolCallInput<SchemaT, SchemaInputT>, 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;
+}
+/**
+ * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.
+ *
+ * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
+ * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.
+ */
+export interface ToolInterface<SchemaT extends ToolInputSchemaBase = ZodObjectAny | z.ZodEffects<ZodObjectAny> | JSONSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>> extends StructuredToolInterface<SchemaT, SchemaInputT> {
+    /**
+     * @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 | SchemaInputT | ToolCall, callbacks?: Callbacks | RunnableConfig): Promise<ToolReturnType>;
+}
+/**
+ * Base interface for the input parameters of the {@link DynamicTool} and
+ * {@link DynamicStructuredTool} classes.
+ */
+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.
+ *
+ * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.
+ * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.
+ */
+export interface DynamicStructuredToolInput<SchemaT extends ToolInputSchemaBase = ZodObjectAny, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>> extends BaseDynamicToolInput {
+    /**
+     * Tool handler function - the function that will be called when the tool is invoked.
+     *
+     * @param input - The input to the tool.
+     * @param runManager - The run manager for the tool.
+     * @param config - The configuration for the tool.
+     * @returns The result of the tool.
+     */
+    func: (input: BaseDynamicToolInput["responseFormat"] extends "content_and_artifact" ? ToolCall : SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
+    schema: SchemaT extends ZodObjectAny ? SchemaT : SchemaT;
+}
+/**
+ * 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`.
+ */
+export declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;
+/**
+ * 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`.
+ */
+export declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;
+/**
+ * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
+ *
+ * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
+ * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
+ */
+export declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;
+/**
+ * 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.
+ */
+export declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;

package/dist/tools/types.js

@@ -0,0 +1,53 @@
+import { Runnable, } from "../runnables/base.js";
+import { isZodSchema } from "../utils/types/is_zod_schema.js";
+/**
+ * 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`.
+ */
+export function isStructuredTool(tool) {
+    return (tool !== undefined &&
+        Array.isArray(tool.lc_namespace));
+}
+/**
+ * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+ * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+ */
+export function isRunnableToolLike(tool) {
+    return (tool !== undefined &&
+        Runnable.isRunnable(tool) &&
+        "lc_name" in tool.constructor &&
+        typeof tool.constructor.lc_name === "function" &&
+        tool.constructor.lc_name() === "RunnableToolLike");
+}
+/**
+ * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
+ *
+ * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
+ * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
+ */
+export function isStructuredToolParams(tool) {
+    return (!!tool &&
+        typeof tool === "object" &&
+        "name" in tool &&
+        "schema" in tool &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isZodSchema(tool.schema));
+}
+/**
+ * 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.
+ */
+export function isLangChainTool(tool) {
+    return (isStructuredToolParams(tool) ||
+        isRunnableToolLike(tool) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isStructuredTool(tool));
+}

package/dist/tracers/tracer_langchain.cjs

@@ -73,6 +73,7 @@ class LangChainTracer extends base_js_1.BaseTracer {
             dotted_order: run.dotted_order,
             parent_run_id: run.parent_run_id,
             extra: run.extra,
+            session_name: this.projectName,
         };
         await this.client.updateRun(run.id, runUpdate);
     }

package/dist/tracers/tracer_langchain.js

@@ -70,6 +70,7 @@ export class LangChainTracer extends BaseTracer {
             dotted_order: run.dotted_order,
             parent_run_id: run.parent_run_id,
             extra: run.extra,
+            session_name: this.projectName,
         };
         await this.client.updateRun(run.id, runUpdate);
     }

package/dist/utils/function_calling.cjs

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLangChainTool = exports.isStructuredToolParams = exports.isRunnableToolLike = exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const base_js_1 = require("../runnables/base.cjs");
-const is_zod_schema_js_1 = require("./types/is_zod_schema.cjs");
+exports.convertToOpenAITool = exports.convertToOpenAIFunction = exports.isLangChainTool = exports.isRunnableToolLike = exports.isStructuredToolParams = exports.isStructuredTool = void 0;
+const types_js_1 = require("../tools/types.cjs");
+const json_schema_js_1 = require("./json_schema.cjs");
+// These utility functions were moved to a more appropriate location,
+// but we still export them here for backwards compatibility.
+var types_js_2 = require("../tools/types.cjs");
+Object.defineProperty(exports, "isStructuredTool", { enumerable: true, get: function () { return types_js_2.isStructuredTool; } });
+Object.defineProperty(exports, "isStructuredToolParams", { enumerable: true, get: function () { return types_js_2.isStructuredToolParams; } });
+Object.defineProperty(exports, "isRunnableToolLike", { enumerable: true, get: function () { return types_js_2.isRunnableToolLike; } });
+Object.defineProperty(exports, "isLangChainTool", { enumerable: true, get: function () { return types_js_2.isLangChainTool; } });
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
- * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * that is compatible with OpenAI function calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
  * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
  * into a JSON schema, which is then used as the parameters for the OpenAI function.
  *
@@ -19,7 +26,7 @@ function convertToOpenAIFunction(tool, fields) {
     return {
         name: tool.name,
         description: tool.description,
-        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+        parameters: (0, json_schema_js_1.toJsonSchema)(tool.schema),
         // Do not include the `strict` field if it is `undefined`.
         ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
@@ -27,10 +34,10 @@ function convertToOpenAIFunction(tool, fields) {
 exports.convertToOpenAIFunction = convertToOpenAIFunction;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
- * format that is compatible with OpenAI tool calling. It uses the
- * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
- * or `RunnableToolLike` into a JSON schema, which is then used as the
- * parameters for the OpenAI tool.
+ * format that is compatible with OpenAI tool calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
@@ -41,7 +48,7 @@ tool, fields) {
     // @TODO 0.3.0 Remove the `number` typing
     const fieldsCopy = typeof fields === "number" ? undefined : fields;
     let toolDef;
-    if (isLangChainTool(tool)) {
+    if ((0, types_js_1.isLangChainTool)(tool)) {
         toolDef = {
             type: "function",
             function: convertToOpenAIFunction(tool),
@@ -57,60 +64,3 @@ tool, fields) {
     return toolDef;
 }
 exports.convertToOpenAITool = convertToOpenAITool;
-/**
- * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
- *
- * @param {StructuredToolInterface | Record<string, any> | 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(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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;

package/dist/utils/function_calling.d.ts

@@ -1,9 +1,11 @@
-import { StructuredToolInterface, StructuredToolParams } from "../tools/index.js";
+import { StructuredToolInterface, StructuredToolParams } from "../tools/types.js";
 import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
 import { RunnableToolLike } from "../runnables/base.js";
+export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from "../tools/types.js";
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
- * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * that is compatible with OpenAI function calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
  * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
  * into a JSON schema, which is then used as the parameters for the OpenAI function.
  *
@@ -19,10 +21,10 @@ export declare function convertToOpenAIFunction(tool: StructuredToolInterface |
 } | number): FunctionDefinition;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
- * format that is compatible with OpenAI tool calling. It uses the
- * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
- * or `RunnableToolLike` into a JSON schema, which is then used as the
- * parameters for the OpenAI tool.
+ * format that is compatible with OpenAI tool calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
@@ -34,33 +36,3 @@ export declare function convertToOpenAITool(tool: StructuredToolInterface | Reco
      */
     strict?: boolean;
 } | number): ToolDefinition;
-/**
- * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
- *
- * @param {StructuredToolInterface | Record<string, any> | 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`.
- */
-export declare function isStructuredTool(tool?: StructuredToolInterface | Record<string, any>): tool is StructuredToolInterface;
-/**
- * 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`.
- */
-export declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;
-/**
- * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
- *
- * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
- * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
- */
-export declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;
-/**
- * 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.
- */
-export declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;

package/dist/utils/function_calling.js

@@ -1,9 +1,12 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { Runnable } from "../runnables/base.js";
-import { isZodSchema } from "./types/is_zod_schema.js";
+import { isLangChainTool, } from "../tools/types.js";
+import { toJsonSchema } from "./json_schema.js";
+// These utility functions were moved to a more appropriate location,
+// but we still export them here for backwards compatibility.
+export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from "../tools/types.js";
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
- * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * that is compatible with OpenAI function calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
  * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
  * into a JSON schema, which is then used as the parameters for the OpenAI function.
  *
@@ -16,17 +19,17 @@ export function convertToOpenAIFunction(tool, fields) {
     return {
         name: tool.name,
         description: tool.description,
-        parameters: zodToJsonSchema(tool.schema),
+        parameters: toJsonSchema(tool.schema),
         // Do not include the `strict` field if it is `undefined`.
         ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
- * format that is compatible with OpenAI tool calling. It uses the
- * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
- * or `RunnableToolLike` into a JSON schema, which is then used as the
- * parameters for the OpenAI tool.
+ * format that is compatible with OpenAI tool calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, it uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
@@ -52,56 +55,3 @@ tool, fields) {
     }
     return toolDef;
 }
-/**
- * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
- *
- * @param {StructuredToolInterface | Record<string, any> | 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`.
- */
-export function isStructuredTool(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool) {
-    return (tool !== undefined &&
-        Array.isArray(tool.lc_namespace));
-}
-/**
- * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
- *
- * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
- * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
- */
-export function isRunnableToolLike(tool) {
-    return (tool !== undefined &&
-        Runnable.isRunnable(tool) &&
-        "lc_name" in tool.constructor &&
-        typeof tool.constructor.lc_name === "function" &&
-        tool.constructor.lc_name() === "RunnableToolLike");
-}
-/**
- * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
- *
- * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
- * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
- */
-export function isStructuredToolParams(tool) {
-    return (!!tool &&
-        typeof tool === "object" &&
-        "name" in tool &&
-        "schema" in tool &&
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        isZodSchema(tool.schema));
-}
-/**
- * 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.
- */
-export function isLangChainTool(tool) {
-    return (isStructuredToolParams(tool) ||
-        isRunnableToolLike(tool) ||
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        isStructuredTool(tool));
-}

package/dist/utils/json_schema.cjs

@@ -1,6 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = exports.deepCompareStrict = void 0;
-var json_schema_1 = require("@cfworker/json-schema");
-Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_1.deepCompareStrict; } });
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_1.Validator; } });
+exports.validatesOnlyStrings = exports.toJsonSchema = exports.Validator = exports.deepCompareStrict = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const json_schema_1 = require("@cfworker/json-schema");
+const is_zod_schema_js_1 = require("./types/is_zod_schema.cjs");
+var json_schema_2 = require("@cfworker/json-schema");
+Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_2.deepCompareStrict; } });
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_2.Validator; } });
+/**
+ * Converts a Zod schema or JSON schema to a JSON schema.
+ * @param schema - The schema to convert.
+ * @returns The converted schema.
+ */
+function toJsonSchema(schema) {
+    if ((0, is_zod_schema_js_1.isZodSchema)(schema)) {
+        return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+    }
+    return schema;
+}
+exports.toJsonSchema = toJsonSchema;
+/**
+ * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
+ * (like recursive or unresolvable refs).
+ *
+ * @param schema - The schema to validate.
+ * @returns `true` if the schema validates only strings, `false` otherwise.
+ */
+function validatesOnlyStrings(schema) {
+    // Null, undefined, or empty schema
+    if (!schema ||
+        typeof schema !== "object" ||
+        Object.keys(schema).length === 0 ||
+        Array.isArray(schema)) {
+        return false; // Validates anything, not just strings
+    }
+    // Explicit type constraint
+    if ("type" in schema) {
+        if (typeof schema.type === "string") {
+            return schema.type === "string";
+        }
+        if (Array.isArray(schema.type)) {
+            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
+            // "string", "string", ...]` but we're not here to judge
+            return schema.type.every((t) => t === "string");
+        }
+        return false; // Invalid or non-string type
+    }
+    // Enum with only string values
+    if ("enum" in schema) {
+        return (Array.isArray(schema.enum) &&
+            schema.enum.length > 0 &&
+            schema.enum.every((val) => typeof val === "string"));
+    }
+    // String constant
+    if ("const" in schema) {
+        return typeof schema.const === "string";
+    }
+    // Schema combinations
+    if ("allOf" in schema && Array.isArray(schema.allOf)) {
+        // If any subschema validates only strings, then the overall schema validates only strings
+        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
+    }
+    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
+        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
+        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
+        // All subschemas must validate only strings
+        return (subschemas.length > 0 &&
+            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
+    }
+    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
+    if ("not" in schema) {
+        return false; // The not case can validate non-strings
+    }
+    if ("$ref" in schema && typeof schema.$ref === "string") {
+        const ref = schema.$ref;
+        const resolved = (0, json_schema_1.dereference)(schema);
+        if (resolved[ref]) {
+            return validatesOnlyStrings(resolved[ref]);
+        }
+        return false;
+    }
+    // ignore recursive refs and other cases where type is omitted for now
+    // ignore other cases for now where type is omitted
+    return false;
+}
+exports.validatesOnlyStrings = validatesOnlyStrings;