@langchain/core 0.2.20 → 0.2.22-rc.0

package/dist/language_models/base.d.ts

@@ -89,6 +89,14 @@ export interface FunctionDefinition {
      * how to call the function.
      */
     description?: string;
+    /**
+     * Whether to enable strict schema adherence when generating the function call. If
+     * set to true, the model will follow the exact schema defined in the `parameters`
+     * field. Only a subset of JSON Schema is supported when `strict` is `true`. Learn
+     * more about Structured Outputs in the
+     * [function calling guide](https://platform.openai.com/docs/guides/function-calling).
+     */
+    strict?: boolean;
 }
 export interface ToolDefinition {
     type: "function";

package/dist/language_models/chat_models.d.ts

@@ -6,7 +6,7 @@ import { BaseLanguageModel, StructuredOutputMethodOptions, ToolDefinition, type
 import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches/base.js";
-import { StructuredToolInterface } from "../tools/index.js";
+import { StructuredToolInterface, StructuredToolParams } from "../tools/index.js";
 import { Runnable, RunnableToolLike } from "../runnables/base.js";
 type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
@@ -61,6 +61,7 @@ export type LangSmithParams = {
     ls_max_tokens?: number;
     ls_stop?: Array<string>;
 };
+export type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
 /**
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
@@ -79,7 +80,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
      * matching the provider's specific tool schema.
      * @param kwargs Any additional parameters to bind.
      */
-    bindTools?(tools: (StructuredToolInterface | Record<string, unknown> | ToolDefinition | RunnableToolLike)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;
+    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;
     /**
      * Invokes the chat model with a single input.
      * @param input The input for the language model.

package/dist/runnables/remote.cjs

@@ -229,6 +229,19 @@ function serialize(input) {
     }
     return input;
 }
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 class RemoteRunnable extends base_js_1.Runnable {
     constructor(fields) {
         super(fields);
@@ -244,25 +257,43 @@ class RemoteRunnable extends base_js_1.Runnable {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchImplementation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetch
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchRequestOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ["langchain", "schema", "runnable", "remote"]
         });
-        const { url, options } = fields;
+        const { url, options, fetch: fetchImplementation, fetchRequestOptions, } = fields;
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
+        this.fetchImplementation = fetchImplementation ?? this.fetchImplementation;
+        this.fetchRequestOptions = fetchRequestOptions;
     }
     async post(path, body, signal) {
-        return fetch(`${this.url}${path}`, {
+        return this.fetchImplementation(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
+            ...this.fetchRequestOptions,
             headers: {
                 "Content-Type": "application/json",
+                ...this.fetchRequestOptions?.headers,
                 ...this.options?.headers,
             },
-            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {

package/dist/runnables/remote.d.ts

@@ -7,13 +7,30 @@ type RemoteRunnableOptions = {
     timeout?: number;
     headers?: Record<string, unknown>;
 };
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
     private url;
     private options?;
+    fetchImplementation: (...args: any[]) => any;
+    fetchRequestOptions?: Record<string, any>;
     lc_namespace: string[];
     constructor(fields: {
         url: string;
         options?: RemoteRunnableOptions;
+        fetch?: (...args: any[]) => any;
+        fetchRequestOptions?: Record<string, any>;
     });
     private post;
     _invoke(input: RunInput, options?: Partial<CallOptions>, _?: CallbackManagerForChainRun): Promise<RunOutput>;

package/dist/runnables/remote.js

@@ -226,6 +226,19 @@ function serialize(input) {
     }
     return input;
 }
+/**
+ * Client for interacting with LangChain runnables
+ * that are hosted as LangServe endpoints.
+ *
+ * Allows you to interact with hosted runnables using the standard
+ * `.invoke()`, `.stream()`, `.streamEvents()`, etc. methods that
+ * other runnables support.
+ *
+ * @param url - The base URL of the LangServe endpoint.
+ * @param options - Optional configuration for the remote runnable, including timeout and headers.
+ * @param fetch - Optional custom fetch implementation.
+ * @param fetchRequestOptions - Optional additional options for fetch requests.
+ */
 export class RemoteRunnable extends Runnable {
     constructor(fields) {
         super(fields);
@@ -241,25 +254,43 @@ export class RemoteRunnable extends Runnable {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchImplementation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetch
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "fetchRequestOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: ["langchain", "schema", "runnable", "remote"]
         });
-        const { url, options } = fields;
+        const { url, options, fetch: fetchImplementation, fetchRequestOptions, } = fields;
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
+        this.fetchImplementation = fetchImplementation ?? this.fetchImplementation;
+        this.fetchRequestOptions = fetchRequestOptions;
     }
     async post(path, body, signal) {
-        return fetch(`${this.url}${path}`, {
+        return this.fetchImplementation(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
+            ...this.fetchRequestOptions,
             headers: {
                 "Content-Type": "application/json",
+                ...this.fetchRequestOptions?.headers,
                 ...this.options?.headers,
             },
-            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {

package/dist/tools/index.d.ts

@@ -26,8 +26,17 @@ export interface ToolParams extends BaseLangChainParams {
      */
     responseFormat?: ResponseFormat;
 }
+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.
@@ -43,7 +52,13 @@ export interface StructuredToolInterface<T extends ZodObjectAny = ZodObjectAny>
     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;
     returnDirect: boolean;
 }

package/dist/utils/function_calling.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRunnableToolLike = exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
+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");
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
@@ -12,11 +13,15 @@ const base_js_1 = require("../runnables/base.cjs");
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-function convertToOpenAIFunction(tool) {
+function convertToOpenAIFunction(tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
     return {
         name: tool.name,
         description: tool.description,
         parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+        // Do not include the `strict` field if it is `undefined`.
+        ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 exports.convertToOpenAIFunction = convertToOpenAIFunction;
@@ -32,14 +37,23 @@ exports.convertToOpenAIFunction = convertToOpenAIFunction;
  */
 function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool) {
-    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
-        return {
+tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
+    let toolDef;
+    if (isLangChainTool(tool)) {
+        toolDef = {
             type: "function",
             function: convertToOpenAIFunction(tool),
         };
     }
-    return tool;
+    else {
+        toolDef = tool;
+    }
+    if (fieldsCopy?.strict !== undefined) {
+        toolDef.function.strict = fieldsCopy.strict;
+    }
+    return toolDef;
 }
 exports.convertToOpenAITool = convertToOpenAITool;
 /**
@@ -69,3 +83,33 @@ function isRunnableToolLike(tool) {
         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,4 +1,4 @@
-import { StructuredToolInterface } from "../tools/index.js";
+import { StructuredToolInterface, StructuredToolParams } from "../tools/index.js";
 import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
 import { RunnableToolLike } from "../runnables/base.js";
 /**
@@ -10,7 +10,13 @@ import { RunnableToolLike } from "../runnables/base.js";
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike): FunctionDefinition;
+export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+} | number): FunctionDefinition;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
  * format that is compatible with OpenAI tool calling. It uses the
@@ -21,7 +27,13 @@ export declare function convertToOpenAIFunction(tool: StructuredToolInterface |
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
-export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike): ToolDefinition;
+export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+} | number): ToolDefinition;
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
  *
@@ -36,3 +48,19 @@ export declare function isStructuredTool(tool?: StructuredToolInterface | Record
  * @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,5 +1,6 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { Runnable } from "../runnables/base.js";
+import { isZodSchema } from "./types/is_zod_schema.js";
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
@@ -9,11 +10,15 @@ import { Runnable } from "../runnables/base.js";
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export function convertToOpenAIFunction(tool) {
+export function convertToOpenAIFunction(tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
     return {
         name: tool.name,
         description: tool.description,
         parameters: zodToJsonSchema(tool.schema),
+        // Do not include the `strict` field if it is `undefined`.
+        ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 /**
@@ -28,14 +33,23 @@ export function convertToOpenAIFunction(tool) {
  */
 export function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool) {
-    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
-        return {
+tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
+    let toolDef;
+    if (isLangChainTool(tool)) {
+        toolDef = {
             type: "function",
             function: convertToOpenAIFunction(tool),
         };
     }
-    return tool;
+    else {
+        toolDef = tool;
+    }
+    if (fieldsCopy?.strict !== undefined) {
+        toolDef.function.strict = fieldsCopy.strict;
+    }
+    return toolDef;
 }
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
@@ -62,3 +76,31 @@ export function isRunnableToolLike(tool) {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.20",
+  "version": "0.2.22-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -72,7 +72,7 @@
     "jest-environment-node": "^29.6.4",
     "ml-matrix": "^6.10.4",
     "prettier": "^2.8.3",
-    "release-it": "^15.10.1",
+    "release-it": "^17.6.0",
     "rimraf": "^5.0.1",
     "ts-jest": "^29.1.0",
     "typescript": "~5.1.6",