@langchain/core 0.1.35 → 0.1.37

package/dist/language_models/base.cjs

@@ -253,21 +253,5 @@ class BaseLanguageModel extends BaseLangChain {
     static async deserialize(_data) {
         throw new Error("Use .toJSON() instead");
     }
-    /**
-     * Return a new runnable which calls an LLM with structured output.
-     * Only available for LLMs that support structured output.
-     *
-     * @template {any} RunInput The input type for the Runnable.
-     * @template {z.ZodObject<any, any, any, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
-     *
-     * @param {z.ZodEffects<RunOutput> | Record<string, any>} schema The schema for the structured output. Either as a ZOD class or a valid JSON schema object.
-     * @param {string} name The name of the function to call.
-     * @returns {Runnable<RunInput, RunOutput>} A new runnable that calls the LLM with structured output.
-     */
-    withStructuredOutput(
-    // @ts-expect-error Var is unused in this base method implementation.
-    { schema, name, }) {
-        throw new Error("Method not implemented.");
-    }
 }
 exports.BaseLanguageModel = BaseLanguageModel;

package/dist/language_models/base.d.ts

@@ -177,21 +177,50 @@ export declare abstract class BaseLanguageModel<RunOutput = any, CallOptions ext
      * Load an LLM from a json-like object describing it.
      */
     static deserialize(_data: SerializedLLM): Promise<BaseLanguageModel>;
+    withStructuredOutput?<RunInput = BaseLanguageModelInput, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, method, includeRaw, }: {
+        schema: z.ZodEffects<RunOutput> | Record<string, any>;
+        name: string;
+        method?: "functionCalling" | "jsonMode";
+        includeRaw: true;
+    }): Runnable<RunInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
+    withStructuredOutput?<RunInput = BaseLanguageModelInput, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, method, includeRaw, }: {
+        schema: z.ZodEffects<RunOutput> | Record<string, any>;
+        name: string;
+        method?: "functionCalling" | "jsonMode";
+        includeRaw?: false;
+    }): Runnable<RunInput, RunOutput>;
     /**
-     * Return a new runnable which calls an LLM with structured output.
-     * Only available for LLMs that support structured output.
+     * Model wrapper that returns outputs formatted to match the given schema.
      *
-     * @template {any} RunInput The input type for the Runnable.
+     * @template {BaseLanguageModelInput} RunInput The input type for the Runnable, expected to be the same input for the LLM.
      * @template {z.ZodObject<any, any, any, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
      *
-     * @param {z.ZodEffects<RunOutput> | Record<string, any>} schema The schema for the structured output. Either as a ZOD class or a valid JSON schema object.
+     * @param {z.ZodEffects<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.
      * @param {string} name The name of the function to call.
-     * @returns {Runnable<RunInput, RunOutput>} A new runnable that calls the LLM with structured output.
+     * @param {"functionCalling" | "jsonMode"} [method=functionCalling] The method to use for getting the structured output. Defaults to "functionCalling".
+     * @param {boolean | undefined} [includeRaw=false] Whether to include the raw output in the result. Defaults to false.
+     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.
      */
-    withStructuredOutput<RunInput = any, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, }: {
+    withStructuredOutput?<RunInput extends BaseLanguageModelInput = BaseLanguageModelInput, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, 
+    /**
+     * @default functionCalling
+     */
+    method, 
+    /**
+     * @default false
+     */
+    includeRaw, }: {
         schema: z.ZodEffects<RunOutput> | Record<string, any>;
         name: string;
-    }): Runnable<RunInput, RunOutput>;
+        method?: "functionCalling" | "jsonMode";
+        includeRaw?: boolean;
+    }): Runnable<RunInput, RunOutput> | Runnable<RunInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
 }
 /**
  * Shared interface for token usage

package/dist/language_models/base.js

@@ -245,20 +245,4 @@ export class BaseLanguageModel extends BaseLangChain {
     static async deserialize(_data) {
         throw new Error("Use .toJSON() instead");
     }
-    /**
-     * Return a new runnable which calls an LLM with structured output.
-     * Only available for LLMs that support structured output.
-     *
-     * @template {any} RunInput The input type for the Runnable.
-     * @template {z.ZodObject<any, any, any, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
-     *
-     * @param {z.ZodEffects<RunOutput> | Record<string, any>} schema The schema for the structured output. Either as a ZOD class or a valid JSON schema object.
-     * @param {string} name The name of the function to call.
-     * @returns {Runnable<RunInput, RunOutput>} A new runnable that calls the LLM with structured output.
-     */
-    withStructuredOutput(
-    // @ts-expect-error Var is unused in this base method implementation.
-    { schema, name, }) {
-        throw new Error("Method not implemented.");
-    }
 }

package/dist/output_parsers/openai_tools/index.cjs

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./json_output_tools_parsers.cjs"), exports);
+__exportStar(require("./json_output_functions_parsers.cjs"), exports);

package/dist/output_parsers/openai_tools/index.d.ts

@@ -1 +1,2 @@
 export * from "./json_output_tools_parsers.js";
+export * from "./json_output_functions_parsers.js";

package/dist/output_parsers/openai_tools/index.js

@@ -1 +1,2 @@
 export * from "./json_output_tools_parsers.js";
+export * from "./json_output_functions_parsers.js";

package/dist/output_parsers/openai_tools/json_output_functions_parsers.cjs

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonKeyOutputFunctionsParser = exports.JsonOutputFunctionsParser = exports.OutputFunctionsParser = void 0;
+const base_js_1 = require("../base.cjs");
+const json_js_1 = require("../json.cjs");
+const transform_js_1 = require("../transform.cjs");
+const json_patch_js_1 = require("../../utils/json_patch.cjs");
+/**
+ * Class for parsing the output of an LLM. Can be configured to return
+ * only the arguments of the function call in the output.
+ */
+class OutputFunctionsParser extends base_js_1.BaseLLMOutputParser {
+    static lc_name() {
+        return "OutputFunctionsParser";
+    }
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "argsOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.argsOnly = config?.argsOnly ?? this.argsOnly;
+    }
+    /**
+     * Parses the output and returns a string representation of the function
+     * call or its arguments.
+     * @param generations The output of the LLM to parse.
+     * @returns A string representation of the function call or its arguments.
+     */
+    async parseResult(generations) {
+        if ("message" in generations[0]) {
+            const gen = generations[0];
+            const functionCall = gen.message.additional_kwargs.function_call;
+            if (!functionCall) {
+                throw new Error(`No function_call in message ${JSON.stringify(generations)}`);
+            }
+            if (!functionCall.arguments) {
+                throw new Error(`No arguments in function_call ${JSON.stringify(generations)}`);
+            }
+            if (this.argsOnly) {
+                return functionCall.arguments;
+            }
+            return JSON.stringify(functionCall);
+        }
+        else {
+            throw new Error(`No message in generations ${JSON.stringify(generations)}`);
+        }
+    }
+}
+exports.OutputFunctionsParser = OutputFunctionsParser;
+/**
+ * Class for parsing the output of an LLM into a JSON object. Uses an
+ * instance of `OutputFunctionsParser` to parse the output.
+ */
+class JsonOutputFunctionsParser extends transform_js_1.BaseCumulativeTransformOutputParser {
+    static lc_name() {
+        return "JsonOutputFunctionsParser";
+    }
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "argsOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.argsOnly = config?.argsOnly ?? this.argsOnly;
+        this.outputParser = new OutputFunctionsParser(config);
+    }
+    _diff(prev, next) {
+        if (!next) {
+            return undefined;
+        }
+        const ops = (0, json_patch_js_1.compare)(prev ?? {}, next);
+        return ops;
+    }
+    async parsePartialResult(generations) {
+        const generation = generations[0];
+        if (!generation.message) {
+            return undefined;
+        }
+        const { message } = generation;
+        const functionCall = message.additional_kwargs.function_call;
+        if (!functionCall) {
+            return undefined;
+        }
+        if (this.argsOnly) {
+            return (0, json_js_1.parsePartialJson)(functionCall.arguments);
+        }
+        return {
+            ...functionCall,
+            arguments: (0, json_js_1.parsePartialJson)(functionCall.arguments),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+    }
+    /**
+     * Parses the output and returns a JSON object. If `argsOnly` is true,
+     * only the arguments of the function call are returned.
+     * @param generations The output of the LLM to parse.
+     * @returns A JSON object representation of the function call or its arguments.
+     */
+    async parseResult(generations) {
+        const result = await this.outputParser.parseResult(generations);
+        if (!result) {
+            throw new Error(`No result from "OutputFunctionsParser" ${JSON.stringify(generations)}`);
+        }
+        return this.parse(result);
+    }
+    async parse(text) {
+        const parsedResult = JSON.parse(text);
+        if (this.argsOnly) {
+            return parsedResult;
+        }
+        parsedResult.arguments = JSON.parse(parsedResult.arguments);
+        return parsedResult;
+    }
+    getFormatInstructions() {
+        return "";
+    }
+}
+exports.JsonOutputFunctionsParser = JsonOutputFunctionsParser;
+/**
+ * Class for parsing the output of an LLM into a JSON object and returning
+ * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`
+ * to parse the output.
+ */
+class JsonKeyOutputFunctionsParser extends base_js_1.BaseLLMOutputParser {
+    static lc_name() {
+        return "JsonKeyOutputFunctionsParser";
+    }
+    get lc_aliases() {
+        return {
+            attrName: "key_name",
+        };
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new JsonOutputFunctionsParser()
+        });
+        Object.defineProperty(this, "attrName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.attrName = fields.attrName;
+    }
+    /**
+     * Parses the output and returns a specific attribute of the parsed JSON
+     * object.
+     * @param generations The output of the LLM to parse.
+     * @returns The value of a specific attribute of the parsed JSON object.
+     */
+    async parseResult(generations) {
+        const result = await this.outputParser.parseResult(generations);
+        return result[this.attrName];
+    }
+}
+exports.JsonKeyOutputFunctionsParser = JsonKeyOutputFunctionsParser;

package/dist/output_parsers/openai_tools/json_output_functions_parsers.d.ts

@@ -0,0 +1,80 @@
+import { JsonSchema7ObjectType } from "zod-to-json-schema";
+import { Optional } from "../../types/type-utils.js";
+import { Generation, ChatGeneration } from "../../outputs.js";
+import { BaseLLMOutputParser } from "../base.js";
+import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput } from "../transform.js";
+import { type Operation as JSONPatchOperation } from "../../utils/json_patch.js";
+/**
+ * Represents optional parameters for a function in a JSON Schema.
+ */
+export type FunctionParameters = Optional<JsonSchema7ObjectType, "additionalProperties">;
+/**
+ * Class for parsing the output of an LLM. Can be configured to return
+ * only the arguments of the function call in the output.
+ */
+export declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    argsOnly: boolean;
+    constructor(config?: {
+        argsOnly?: boolean;
+    });
+    /**
+     * Parses the output and returns a string representation of the function
+     * call or its arguments.
+     * @param generations The output of the LLM to parse.
+     * @returns A string representation of the function call or its arguments.
+     */
+    parseResult(generations: Generation[] | ChatGeneration[]): Promise<string>;
+}
+/**
+ * Class for parsing the output of an LLM into a JSON object. Uses an
+ * instance of `OutputFunctionsParser` to parse the output.
+ */
+export declare class JsonOutputFunctionsParser<Output extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<Output> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    outputParser: OutputFunctionsParser;
+    argsOnly: boolean;
+    constructor(config?: {
+        argsOnly?: boolean;
+    } & BaseCumulativeTransformOutputParserInput);
+    protected _diff(prev: unknown | undefined, next: unknown): JSONPatchOperation[] | undefined;
+    parsePartialResult(generations: ChatGeneration[]): Promise<Output | undefined>;
+    /**
+     * Parses the output and returns a JSON object. If `argsOnly` is true,
+     * only the arguments of the function call are returned.
+     * @param generations The output of the LLM to parse.
+     * @returns A JSON object representation of the function call or its arguments.
+     */
+    parseResult(generations: Generation[] | ChatGeneration[]): Promise<Output>;
+    parse(text: string): Promise<Output>;
+    getFormatInstructions(): string;
+}
+/**
+ * Class for parsing the output of an LLM into a JSON object and returning
+ * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`
+ * to parse the output.
+ */
+export declare class JsonKeyOutputFunctionsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    outputParser: JsonOutputFunctionsParser<Record<string, any>>;
+    attrName: string;
+    get lc_aliases(): {
+        attrName: string;
+    };
+    constructor(fields: {
+        attrName: string;
+    });
+    /**
+     * Parses the output and returns a specific attribute of the parsed JSON
+     * object.
+     * @param generations The output of the LLM to parse.
+     * @returns The value of a specific attribute of the parsed JSON object.
+     */
+    parseResult(generations: Generation[] | ChatGeneration[]): Promise<T>;
+}

package/dist/output_parsers/openai_tools/json_output_functions_parsers.js

@@ -0,0 +1,201 @@
+import { BaseLLMOutputParser } from "../base.js";
+import { parsePartialJson } from "../json.js";
+import { BaseCumulativeTransformOutputParser, } from "../transform.js";
+import { compare, } from "../../utils/json_patch.js";
+/**
+ * Class for parsing the output of an LLM. Can be configured to return
+ * only the arguments of the function call in the output.
+ */
+export class OutputFunctionsParser extends BaseLLMOutputParser {
+    static lc_name() {
+        return "OutputFunctionsParser";
+    }
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "argsOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.argsOnly = config?.argsOnly ?? this.argsOnly;
+    }
+    /**
+     * Parses the output and returns a string representation of the function
+     * call or its arguments.
+     * @param generations The output of the LLM to parse.
+     * @returns A string representation of the function call or its arguments.
+     */
+    async parseResult(generations) {
+        if ("message" in generations[0]) {
+            const gen = generations[0];
+            const functionCall = gen.message.additional_kwargs.function_call;
+            if (!functionCall) {
+                throw new Error(`No function_call in message ${JSON.stringify(generations)}`);
+            }
+            if (!functionCall.arguments) {
+                throw new Error(`No arguments in function_call ${JSON.stringify(generations)}`);
+            }
+            if (this.argsOnly) {
+                return functionCall.arguments;
+            }
+            return JSON.stringify(functionCall);
+        }
+        else {
+            throw new Error(`No message in generations ${JSON.stringify(generations)}`);
+        }
+    }
+}
+/**
+ * Class for parsing the output of an LLM into a JSON object. Uses an
+ * instance of `OutputFunctionsParser` to parse the output.
+ */
+export class JsonOutputFunctionsParser extends BaseCumulativeTransformOutputParser {
+    static lc_name() {
+        return "JsonOutputFunctionsParser";
+    }
+    constructor(config) {
+        super(config);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "argsOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.argsOnly = config?.argsOnly ?? this.argsOnly;
+        this.outputParser = new OutputFunctionsParser(config);
+    }
+    _diff(prev, next) {
+        if (!next) {
+            return undefined;
+        }
+        const ops = compare(prev ?? {}, next);
+        return ops;
+    }
+    async parsePartialResult(generations) {
+        const generation = generations[0];
+        if (!generation.message) {
+            return undefined;
+        }
+        const { message } = generation;
+        const functionCall = message.additional_kwargs.function_call;
+        if (!functionCall) {
+            return undefined;
+        }
+        if (this.argsOnly) {
+            return parsePartialJson(functionCall.arguments);
+        }
+        return {
+            ...functionCall,
+            arguments: parsePartialJson(functionCall.arguments),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+    }
+    /**
+     * Parses the output and returns a JSON object. If `argsOnly` is true,
+     * only the arguments of the function call are returned.
+     * @param generations The output of the LLM to parse.
+     * @returns A JSON object representation of the function call or its arguments.
+     */
+    async parseResult(generations) {
+        const result = await this.outputParser.parseResult(generations);
+        if (!result) {
+            throw new Error(`No result from "OutputFunctionsParser" ${JSON.stringify(generations)}`);
+        }
+        return this.parse(result);
+    }
+    async parse(text) {
+        const parsedResult = JSON.parse(text);
+        if (this.argsOnly) {
+            return parsedResult;
+        }
+        parsedResult.arguments = JSON.parse(parsedResult.arguments);
+        return parsedResult;
+    }
+    getFormatInstructions() {
+        return "";
+    }
+}
+/**
+ * Class for parsing the output of an LLM into a JSON object and returning
+ * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`
+ * to parse the output.
+ */
+export class JsonKeyOutputFunctionsParser extends BaseLLMOutputParser {
+    static lc_name() {
+        return "JsonKeyOutputFunctionsParser";
+    }
+    get lc_aliases() {
+        return {
+            attrName: "key_name",
+        };
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "openai_functions"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new JsonOutputFunctionsParser()
+        });
+        Object.defineProperty(this, "attrName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.attrName = fields.attrName;
+    }
+    /**
+     * Parses the output and returns a specific attribute of the parsed JSON
+     * object.
+     * @param generations The output of the LLM to parse.
+     * @returns The value of a specific attribute of the parsed JSON object.
+     */
+    async parseResult(generations) {
+        const result = await this.outputParser.parseResult(generations);
+        return result[this.attrName];
+    }
+}

package/dist/output_parsers/openai_tools/json_output_tools_parsers.cjs

@@ -77,7 +77,6 @@ exports.JsonOutputToolsParser = JsonOutputToolsParser;
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class JsonOutputKeyToolsParser extends base_js_1.BaseLLMOutputParser {
     static lc_name() {
         return "JsonOutputKeyToolsParser";

package/dist/output_parsers/openai_tools/json_output_tools_parsers.d.ts

@@ -40,7 +40,7 @@ export type JsonOutputKeyToolsParserParams = {
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
  */
-export declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
+export declare class JsonOutputKeyToolsParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;

package/dist/output_parsers/openai_tools/json_output_tools_parsers.js

@@ -73,7 +73,6 @@ export class JsonOutputToolsParser extends BaseLLMOutputParser {
  * Class for parsing the output of a tool-calling LLM into a JSON object if you are
  * expecting only a single tool to be called.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class JsonOutputKeyToolsParser extends BaseLLMOutputParser {
     static lc_name() {
         return "JsonOutputKeyToolsParser";

package/dist/runnables/base.cjs

@@ -1283,17 +1283,24 @@ class RunnableLambda extends Runnable {
     }
     async _invoke(input, config, runManager) {
         return new Promise((resolve, reject) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            const childConfig = (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+            });
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
-                    let output = await this.func(input, { ...config, config });
+                    let output = await this.func(input, {
+                        ...childConfig,
+                        config: childConfig,
+                    });
                     if (output && Runnable.isRunnable(output)) {
                         if (config?.recursionLimit === 0) {
                             throw new Error("Recursion limit reached.");
                         }
-                        output = await output.invoke(input, (0, config_js_1.patchConfig)(config, {
-                            callbacks: runManager?.getChild(),
-                            recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-                        }));
+                        output = await output.invoke(input, {
+                            ...childConfig,
+                            recursionLimit: (childConfig.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+                        });
                     }
                     resolve(output);
                 }

package/dist/runnables/base.js

@@ -1270,17 +1270,24 @@ export class RunnableLambda extends Runnable {
     }
     async _invoke(input, config, runManager) {
         return new Promise((resolve, reject) => {
-            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            const childConfig = patchConfig(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+            });
+            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
-                    let output = await this.func(input, { ...config, config });
+                    let output = await this.func(input, {
+                        ...childConfig,
+                        config: childConfig,
+                    });
                     if (output && Runnable.isRunnable(output)) {
                         if (config?.recursionLimit === 0) {
                             throw new Error("Recursion limit reached.");
                         }
-                        output = await output.invoke(input, patchConfig(config, {
-                            callbacks: runManager?.getChild(),
-                            recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-                        }));
+                        output = await output.invoke(input, {
+                            ...childConfig,
+                            recursionLimit: (childConfig.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+                        });
                     }
                     resolve(output);
                 }

package/dist/types/type-utils.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/type-utils.d.ts

@@ -0,0 +1 @@
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/types/type-utils.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -43,7 +43,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.8",
-    "langsmith": "~0.1.1",
+    "langsmith": "~0.1.7",
     "ml-distance": "^4.0.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",