@langchain/core 0.1.44 → 0.1.45

package/dist/callbacks/base.cjs

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCallbackHandler = void 0;
 const uuid = __importStar(require("uuid"));
 const serializable_js_1 = require("../load/serializable.cjs");
+const env_js_1 = require("../utils/env.cjs");
 /**
  * Abstract class that provides a set of optional methods that can be
  * overridden in derived classes to handle various events during the
@@ -112,10 +113,7 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: typeof process !== "undefined"
-                ? // eslint-disable-next-line no-process-env
-                    process.env?.LANGCHAIN_CALLBACKS_BACKGROUND !== "true"
-                : true
+            value: (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !== "true"
         });
         this.lc_kwargs = input || {};
         if (input) {
@@ -123,6 +121,7 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
             this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
             this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
+            this.awaitHandlers = input._awaitHandler ?? this.awaitHandlers;
         }
     }
     copy() {

package/dist/callbacks/base.d.ts

@@ -16,6 +16,7 @@ export interface BaseCallbackHandlerInput {
     ignoreChain?: boolean;
     ignoreAgent?: boolean;
     ignoreRetriever?: boolean;
+    _awaitHandler?: boolean;
 }
 /**
  * Interface for the indices of a new token produced by an LLM or Chat

package/dist/callbacks/base.js

@@ -1,5 +1,6 @@
 import * as uuid from "uuid";
 import { Serializable, get_lc_unique_name, } from "../load/serializable.js";
+import { getEnvironmentVariable } from "../utils/env.js";
 /**
  * Abstract class that provides a set of optional methods that can be
  * overridden in derived classes to handle various events during the
@@ -86,10 +87,7 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: typeof process !== "undefined"
-                ? // eslint-disable-next-line no-process-env
-                    process.env?.LANGCHAIN_CALLBACKS_BACKGROUND !== "true"
-                : true
+            value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !== "true"
         });
         this.lc_kwargs = input || {};
         if (input) {
@@ -97,6 +95,7 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
             this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
             this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
             this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
+            this.awaitHandlers = input._awaitHandler ?? this.awaitHandlers;
         }
     }
     copy() {

package/dist/callbacks/manager.cjs

@@ -9,6 +9,16 @@ const index_js_1 = require("../messages/index.cjs");
 const env_js_1 = require("../utils/env.cjs");
 const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
+if (
+/* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" &&
+    /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !==
+        "true") {
+    /* #__PURE__ */ console.warn([
+        "[WARN]: You have enabled LangSmith tracing without backgrounding callbacks.",
+        "[WARN]: If you are not using a serverless environment where you must wait for tracing calls to finish,",
+        `[WARN]: we suggest setting "process.env.LANGCHAIN_CALLBACKS_BACKGROUND=true" to avoid additional latency.`,
+    ].join("\n"));
+}
 function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};

package/dist/callbacks/manager.js

@@ -6,6 +6,16 @@ import { getBufferString } from "../messages/index.js";
 import { getEnvironmentVariable } from "../utils/env.js";
 import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
+if (
+/* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" &&
+    /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !==
+        "true") {
+    /* #__PURE__ */ console.warn([
+        "[WARN]: You have enabled LangSmith tracing without backgrounding callbacks.",
+        "[WARN]: If you are not using a serverless environment where you must wait for tracing calls to finish,",
+        `[WARN]: we suggest setting "process.env.LANGCHAIN_CALLBACKS_BACKGROUND=true" to avoid additional latency.`,
+    ].join("\n"));
+}
 export function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};

package/dist/load/serializable.d.ts

@@ -3,6 +3,8 @@ export interface BaseSerialized<T extends string> {
     lc: number;
     type: T;
     id: string[];
+    name?: string;
+    graph?: Record<string, any>;
 }
 export interface SerializedConstructor extends BaseSerialized<"constructor"> {
     kwargs: SerializedFields;
@@ -17,7 +19,10 @@ export type Serialized = SerializedConstructor | SerializedSecret | SerializedNo
  * Should not be subclassed, subclass lc_name above instead.
  */
 export declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
-export declare abstract class Serializable {
+export interface SerializableInterface {
+    get lc_id(): string[];
+}
+export declare abstract class Serializable implements SerializableInterface {
     lc_serializable: boolean;
     lc_kwargs: SerializedFields;
     /**

package/dist/output_parsers/base.cjs

@@ -19,6 +19,14 @@ class BaseLLMOutputParser extends index_js_1.Runnable {
     parseResultWithPrompt(generations, _prompt, callbacks) {
         return this.parseResult(generations, callbacks);
     }
+    _baseMessageToString(message) {
+        return typeof message.content === "string"
+            ? message.content
+            : this._baseMessageContentToString(message.content);
+    }
+    _baseMessageContentToString(content) {
+        return JSON.stringify(content);
+    }
     /**
      * Calls the parser with a given input and optional configuration options.
      * If the input is a string, it creates a generation with the input as
@@ -37,9 +45,7 @@ class BaseLLMOutputParser extends index_js_1.Runnable {
             return this._callWithConfig(async (input) => this.parseResult([
                 {
                     message: input,
-                    text: typeof input.content === "string"
-                        ? input.content
-                        : JSON.stringify(input.content),
+                    text: this._baseMessageToString(input),
                 },
             ]), input, { ...options, runType: "parser" });
         }

package/dist/output_parsers/base.d.ts

@@ -1,7 +1,7 @@
 import { Runnable } from "../runnables/index.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BasePromptValueInterface } from "../prompt_values.js";
-import type { BaseMessage } from "../messages/index.js";
+import type { BaseMessage, MessageContentComplex } from "../messages/index.js";
 import type { Callbacks } from "../callbacks/manager.js";
 import type { Generation, ChatGeneration } from "../outputs.js";
 /**
@@ -33,6 +33,8 @@ export declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<
      * @returns A promise of the parsed output.
      */
     parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
+    protected _baseMessageToString(message: BaseMessage): string;
+    protected _baseMessageContentToString(content: MessageContentComplex[]): string;
     /**
      * Calls the parser with a given input and optional configuration options.
      * If the input is a string, it creates a generation with the input as

package/dist/output_parsers/base.js

@@ -16,6 +16,14 @@ export class BaseLLMOutputParser extends Runnable {
     parseResultWithPrompt(generations, _prompt, callbacks) {
         return this.parseResult(generations, callbacks);
     }
+    _baseMessageToString(message) {
+        return typeof message.content === "string"
+            ? message.content
+            : this._baseMessageContentToString(message.content);
+    }
+    _baseMessageContentToString(content) {
+        return JSON.stringify(content);
+    }
     /**
      * Calls the parser with a given input and optional configuration options.
      * If the input is a string, it creates a generation with the input as
@@ -34,9 +42,7 @@ export class BaseLLMOutputParser extends Runnable {
             return this._callWithConfig(async (input) => this.parseResult([
                 {
                     message: input,
-                    text: typeof input.content === "string"
-                        ? input.content
-                        : JSON.stringify(input.content),
+                    text: this._baseMessageToString(input),
                 },
             ]), input, { ...options, runType: "parser" });
         }

package/dist/output_parsers/string.cjs

@@ -53,5 +53,26 @@ class StringOutputParser extends transform_js_1.BaseTransformOutputParser {
     getFormatInstructions() {
         return "";
     }
+    _textContentToString(content) {
+        return content.text;
+    }
+    _imageUrlContentToString(_content) {
+        throw new Error(`Cannot coerce a multimodal "image_url" message part into a string.`);
+    }
+    _messageContentComplexToString(content) {
+        switch (content.type) {
+            case "text":
+                return this._textContentToString(content);
+            case "image_url":
+                return this._imageUrlContentToString(content);
+            default:
+                throw new Error(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                `Cannot coerce "${content.type}" message part into a string.`);
+        }
+    }
+    _baseMessageContentToString(content) {
+        return content.reduce((acc, item) => acc + this._messageContentComplexToString(item), "");
+    }
 }
 exports.StringOutputParser = StringOutputParser;

package/dist/output_parsers/string.d.ts

@@ -1,4 +1,5 @@
 import { BaseTransformOutputParser } from "./transform.js";
+import { MessageContentComplex, MessageContentImageUrl, MessageContentText } from "../messages/index.js";
 /**
  * OutputParser that parses LLMResult into the top likely string.
  * @example
@@ -31,4 +32,8 @@ export declare class StringOutputParser extends BaseTransformOutputParser<string
      */
     parse(text: string): Promise<string>;
     getFormatInstructions(): string;
+    protected _textContentToString(content: MessageContentText): string;
+    protected _imageUrlContentToString(_content: MessageContentImageUrl): string;
+    protected _messageContentComplexToString(content: MessageContentComplex): string;
+    protected _baseMessageContentToString(content: MessageContentComplex[]): string;
 }

package/dist/output_parsers/string.js

@@ -50,4 +50,25 @@ export class StringOutputParser extends BaseTransformOutputParser {
     getFormatInstructions() {
         return "";
     }
+    _textContentToString(content) {
+        return content.text;
+    }
+    _imageUrlContentToString(_content) {
+        throw new Error(`Cannot coerce a multimodal "image_url" message part into a string.`);
+    }
+    _messageContentComplexToString(content) {
+        switch (content.type) {
+            case "text":
+                return this._textContentToString(content);
+            case "image_url":
+                return this._imageUrlContentToString(content);
+            default:
+                throw new Error(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                `Cannot coerce "${content.type}" message part into a string.`);
+        }
+    }
+    _baseMessageContentToString(content) {
+        return content.reduce((acc, item) => acc + this._messageContentComplexToString(item), "");
+    }
 }

package/dist/output_parsers/transform.cjs

@@ -18,9 +18,7 @@ class BaseTransformOutputParser extends base_js_1.BaseOutputParser {
                 yield this.parseResult([
                     {
                         message: chunk,
-                        text: typeof chunk.content === "string"
-                            ? chunk.content
-                            : JSON.stringify(chunk.content),
+                        text: this._baseMessageToString(chunk),
                     },
                 ]);
             }

package/dist/output_parsers/transform.js

@@ -15,9 +15,7 @@ export class BaseTransformOutputParser extends BaseOutputParser {
                 yield this.parseResult([
                     {
                         message: chunk,
-                        text: typeof chunk.content === "string"
-                            ? chunk.content
-                            : JSON.stringify(chunk.content),
+                        text: this._baseMessageToString(chunk),
                     },
                 ]);
             }

package/dist/runnables/base.cjs

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0;
+const zod_1 = require("zod");
 const p_retry_1 = __importDefault(require("p-retry"));
 const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
@@ -14,6 +15,7 @@ const async_caller_js_1 = require("../utils/async_caller.cjs");
 const root_listener_js_1 = require("../tracers/root_listener.cjs");
 const utils_js_1 = require("./utils.cjs");
 const index_js_1 = require("../singletons/index.cjs");
+const graph_js_1 = require("./graph.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value &&
@@ -291,6 +293,23 @@ class Runnable extends serializable_js_1.Serializable {
         }
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
+    getGraph(_) {
+        const graph = new graph_js_1.Graph();
+        // TODO: Add input schema for runnables
+        const inputNode = graph.addNode({
+            name: `${this.getName()}Input`,
+            schema: zod_1.z.any(),
+        });
+        const runnableNode = graph.addNode(this);
+        // TODO: Add output schemas for runnables
+        const outputNode = graph.addNode({
+            name: `${this.getName()}Output`,
+            schema: zod_1.z.any(),
+        });
+        graph.addEdge(inputNode, runnableNode);
+        graph.addEdge(runnableNode, outputNode);
+        return graph;
+    }
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
      * piping the output of one runnable into another runnable or runnable-like.
@@ -593,7 +612,7 @@ class Runnable extends serializable_js_1.Serializable {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
-        return thing ? thing.lc_runnable : false;
+        return (0, utils_js_1.isRunnableInterface)(thing);
     }
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -1106,6 +1125,30 @@ class RunnableSequence extends Runnable {
         }
         await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
     }
+    getGraph(config) {
+        const graph = new graph_js_1.Graph();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let currentLastNode = null;
+        this.steps.forEach((step, index) => {
+            const stepGraph = step.getGraph(config);
+            if (index !== 0) {
+                stepGraph.trimFirstNode();
+            }
+            if (index !== this.steps.length - 1) {
+                stepGraph.trimLastNode();
+            }
+            graph.extend(stepGraph);
+            const stepFirstNode = stepGraph.firstNode();
+            if (!stepFirstNode) {
+                throw new Error(`Runnable ${step} has no first node`);
+            }
+            if (currentLastNode) {
+                graph.addEdge(currentLastNode, stepFirstNode);
+            }
+            currentLastNode = stepGraph.lastNode();
+        });
+        return graph;
+    }
     pipe(coerceable) {
         if (RunnableSequence.isRunnableSequence(coerceable)) {
             return new RunnableSequence({

package/dist/runnables/base.d.ts

@@ -1,28 +1,12 @@
+import type { RunnableInterface, RunnableBatchOptions } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, LogStreamCallbackHandlerInput, RunLogPatch, StreamEvent } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream, type IterableReadableStreamInterface } from "../utils/stream.js";
+import { IterableReadableStream } from "../utils/stream.js";
 import { RunnableConfig } from "./config.js";
 import { Run } from "../tracers/base.js";
-/**
- * Base interface implemented by all runnables.
- * Used for cross-compatibility between different versions of LangChain core.
- *
- * Should not change on patch releases.
- */
-export interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> {
-    lc_serializable: boolean;
-    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
-    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
-        returnExceptions?: false;
-    }): Promise<RunOutput[]>;
-    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
-        returnExceptions: true;
-    }): Promise<(RunOutput | Error)[]>;
-    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
-    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;
-    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
-}
+import { Graph } from "./graph.js";
+export { type RunnableInterface, RunnableBatchOptions };
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: ({
     config?: RunnableConfig;
 } & RunnableConfig) | Record<string, any> | (Record<string, any> & {
@@ -32,11 +16,6 @@ export type RunnableMapLike<RunInput, RunOutput> = {
     [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]>;
 };
 export type RunnableLike<RunInput = any, RunOutput = any> = RunnableInterface<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | RunnableMapLike<RunInput, RunOutput>;
-export type RunnableBatchOptions = {
-    /** @deprecated Pass in via the standard runnable config object instead */
-    maxConcurrency?: number;
-    returnExceptions?: boolean;
-};
 export type RunnableRetryFailedAttemptHandler = (error: any) => any;
 export declare function _coerceToDict(value: any, defaultKey: string): any;
 /**
@@ -141,6 +120,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<CallOptions>) => AsyncGenerator<O>, options?: CallOptions & {
         runType?: string;
     }): AsyncGenerator<O>;
+    getGraph(_?: RunnableConfig): Graph;
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
      * piping the output of one runnable into another runnable or runnable-like.
@@ -413,6 +393,7 @@ export declare class RunnableSequence<RunInput = any, RunOutput = any> extends R
     }): Promise<(RunOutput | Error)[]>;
     batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     _streamIterator(input: RunInput, options?: RunnableConfig): AsyncGenerator<RunOutput>;
+    getGraph(config?: RunnableConfig): Graph;
     pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>>;
     static isRunnableSequence(thing: any): thing is RunnableSequence;
     static from<RunInput = any, RunOutput = any>([first, ...runnables]: [

package/dist/runnables/base.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import pRetry from "p-retry";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_stream.js";
@@ -6,8 +7,9 @@ import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGene
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
-import { _RootEventFilter } from "./utils.js";
+import { _RootEventFilter, isRunnableInterface } from "./utils.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
+import { Graph } from "./graph.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -284,6 +286,23 @@ export class Runnable extends Serializable {
         }
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
+    getGraph(_) {
+        const graph = new Graph();
+        // TODO: Add input schema for runnables
+        const inputNode = graph.addNode({
+            name: `${this.getName()}Input`,
+            schema: z.any(),
+        });
+        const runnableNode = graph.addNode(this);
+        // TODO: Add output schemas for runnables
+        const outputNode = graph.addNode({
+            name: `${this.getName()}Output`,
+            schema: z.any(),
+        });
+        graph.addEdge(inputNode, runnableNode);
+        graph.addEdge(runnableNode, outputNode);
+        return graph;
+    }
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
      * piping the output of one runnable into another runnable or runnable-like.
@@ -586,7 +605,7 @@ export class Runnable extends Serializable {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
-        return thing ? thing.lc_runnable : false;
+        return isRunnableInterface(thing);
     }
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -1095,6 +1114,30 @@ export class RunnableSequence extends Runnable {
         }
         await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
     }
+    getGraph(config) {
+        const graph = new Graph();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let currentLastNode = null;
+        this.steps.forEach((step, index) => {
+            const stepGraph = step.getGraph(config);
+            if (index !== 0) {
+                stepGraph.trimFirstNode();
+            }
+            if (index !== this.steps.length - 1) {
+                stepGraph.trimLastNode();
+            }
+            graph.extend(stepGraph);
+            const stepFirstNode = stepGraph.firstNode();
+            if (!stepFirstNode) {
+                throw new Error(`Runnable ${step} has no first node`);
+            }
+            if (currentLastNode) {
+                graph.addEdge(currentLastNode, stepFirstNode);
+            }
+            currentLastNode = stepGraph.lastNode();
+        });
+        return graph;
+    }
     pipe(coerceable) {
         if (RunnableSequence.isRunnableSequence(coerceable)) {
             return new RunnableSequence({

package/dist/runnables/graph.cjs

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = exports.nodeDataStr = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const uuid_1 = require("uuid");
+const utils_js_1 = require("./utils.cjs");
+const MAX_DATA_DISPLAY_NAME_LENGTH = 42;
+function nodeDataStr(node) {
+    if (!(0, uuid_1.validate)(node.id)) {
+        return node.id;
+    }
+    else if ((0, utils_js_1.isRunnableInterface)(node.data)) {
+        try {
+            let data = node.data.toString();
+            if (data.startsWith("<") ||
+                data[0] !== data[0].toUpperCase() ||
+                data.split("\n").length > 1) {
+                data = node.data.getName();
+            }
+            else if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
+                data = `${data.substring(0, MAX_DATA_DISPLAY_NAME_LENGTH)}...`;
+            }
+            return data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+        }
+        catch (error) {
+            return node.data.getName();
+        }
+    }
+    else {
+        return node.data.name ?? "UnknownSchema";
+    }
+}
+exports.nodeDataStr = nodeDataStr;
+function nodeDataJson(node) {
+    // if node.data is implements Runnable
+    if ((0, utils_js_1.isRunnableInterface)(node.data)) {
+        return {
+            type: "runnable",
+            data: {
+                id: node.data.lc_id,
+                name: node.data.getName(),
+            },
+        };
+    }
+    else {
+        return {
+            type: "schema",
+            data: { ...(0, zod_to_json_schema_1.zodToJsonSchema)(node.data.schema), title: node.data.name },
+        };
+    }
+}
+class Graph {
+    constructor() {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    // Convert the graph to a JSON-serializable format.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const stableNodeIds = {};
+        Object.values(this.nodes).forEach((node, i) => {
+            stableNodeIds[node.id] = (0, uuid_1.validate)(node.id) ? i : node.id;
+        });
+        return {
+            nodes: Object.values(this.nodes).map((node) => ({
+                id: stableNodeIds[node.id],
+                ...nodeDataJson(node),
+            })),
+            edges: this.edges.map((edge) => edge.data
+                ? {
+                    source: stableNodeIds[edge.source],
+                    target: stableNodeIds[edge.target],
+                    data: edge.data,
+                }
+                : {
+                    source: stableNodeIds[edge.source],
+                    target: stableNodeIds[edge.target],
+                }),
+        };
+    }
+    addNode(data, id) {
+        if (id !== undefined && this.nodes[id] !== undefined) {
+            throw new Error(`Node with id ${id} already exists`);
+        }
+        const nodeId = id || (0, uuid_1.v4)();
+        const node = { id: nodeId, data };
+        this.nodes[nodeId] = node;
+        return node;
+    }
+    removeNode(node) {
+        // Remove the node from the nodes map
+        delete this.nodes[node.id];
+        // Filter out edges connected to the node
+        this.edges = this.edges.filter((edge) => edge.source !== node.id && edge.target !== node.id);
+    }
+    addEdge(source, target, data) {
+        if (this.nodes[source.id] === undefined) {
+            throw new Error(`Source node ${source.id} not in graph`);
+        }
+        if (this.nodes[target.id] === undefined) {
+            throw new Error(`Target node ${target.id} not in graph`);
+        }
+        const edge = { source: source.id, target: target.id, data };
+        this.edges.push(edge);
+        return edge;
+    }
+    firstNode() {
+        const targets = new Set(this.edges.map((edge) => edge.target));
+        const found = [];
+        Object.values(this.nodes).forEach((node) => {
+            if (!targets.has(node.id)) {
+                found.push(node);
+            }
+        });
+        return found[0];
+    }
+    lastNode() {
+        const sources = new Set(this.edges.map((edge) => edge.source));
+        const found = [];
+        Object.values(this.nodes).forEach((node) => {
+            if (!sources.has(node.id)) {
+                found.push(node);
+            }
+        });
+        return found[0];
+    }
+    extend(graph) {
+        // Add all nodes from the other graph, taking care to avoid duplicates
+        Object.entries(graph.nodes).forEach(([key, value]) => {
+            this.nodes[key] = value;
+        });
+        // Add all edges from the other graph
+        this.edges = [...this.edges, ...graph.edges];
+    }
+    trimFirstNode() {
+        const firstNode = this.firstNode();
+        if (firstNode) {
+            const outgoingEdges = this.edges.filter((edge) => edge.source === firstNode.id);
+            if (Object.keys(this.nodes).length === 1 || outgoingEdges.length === 1) {
+                this.removeNode(firstNode);
+            }
+        }
+    }
+    trimLastNode() {
+        const lastNode = this.lastNode();
+        if (lastNode) {
+            const incomingEdges = this.edges.filter((edge) => edge.target === lastNode.id);
+            if (Object.keys(this.nodes).length === 1 || incomingEdges.length === 1) {
+                this.removeNode(lastNode);
+            }
+        }
+    }
+}
+exports.Graph = Graph;

package/dist/runnables/graph.d.ts

@@ -0,0 +1,25 @@
+import type { RunnableInterface, RunnableIOSchema } from "./types.js";
+interface Edge {
+    source: string;
+    target: string;
+    data?: string;
+}
+interface Node {
+    id: string;
+    data: RunnableIOSchema | RunnableInterface;
+}
+export declare function nodeDataStr(node: Node): string;
+export declare class Graph {
+    nodes: Record<string, Node>;
+    edges: Edge[];
+    toJSON(): Record<string, any>;
+    addNode(data: RunnableInterface | RunnableIOSchema, id?: string): Node;
+    removeNode(node: Node): void;
+    addEdge(source: Node, target: Node, data?: string): Edge;
+    firstNode(): Node | undefined;
+    lastNode(): Node | undefined;
+    extend(graph: Graph): void;
+    trimFirstNode(): void;
+    trimLastNode(): void;
+}
+export {};

package/dist/runnables/graph.js

@@ -0,0 +1,159 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { v4 as uuidv4, validate as isUuid } from "uuid";
+import { isRunnableInterface } from "./utils.js";
+const MAX_DATA_DISPLAY_NAME_LENGTH = 42;
+export function nodeDataStr(node) {
+    if (!isUuid(node.id)) {
+        return node.id;
+    }
+    else if (isRunnableInterface(node.data)) {
+        try {
+            let data = node.data.toString();
+            if (data.startsWith("<") ||
+                data[0] !== data[0].toUpperCase() ||
+                data.split("\n").length > 1) {
+                data = node.data.getName();
+            }
+            else if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
+                data = `${data.substring(0, MAX_DATA_DISPLAY_NAME_LENGTH)}...`;
+            }
+            return data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+        }
+        catch (error) {
+            return node.data.getName();
+        }
+    }
+    else {
+        return node.data.name ?? "UnknownSchema";
+    }
+}
+function nodeDataJson(node) {
+    // if node.data is implements Runnable
+    if (isRunnableInterface(node.data)) {
+        return {
+            type: "runnable",
+            data: {
+                id: node.data.lc_id,
+                name: node.data.getName(),
+            },
+        };
+    }
+    else {
+        return {
+            type: "schema",
+            data: { ...zodToJsonSchema(node.data.schema), title: node.data.name },
+        };
+    }
+}
+export class Graph {
+    constructor() {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    // Convert the graph to a JSON-serializable format.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON() {
+        const stableNodeIds = {};
+        Object.values(this.nodes).forEach((node, i) => {
+            stableNodeIds[node.id] = isUuid(node.id) ? i : node.id;
+        });
+        return {
+            nodes: Object.values(this.nodes).map((node) => ({
+                id: stableNodeIds[node.id],
+                ...nodeDataJson(node),
+            })),
+            edges: this.edges.map((edge) => edge.data
+                ? {
+                    source: stableNodeIds[edge.source],
+                    target: stableNodeIds[edge.target],
+                    data: edge.data,
+                }
+                : {
+                    source: stableNodeIds[edge.source],
+                    target: stableNodeIds[edge.target],
+                }),
+        };
+    }
+    addNode(data, id) {
+        if (id !== undefined && this.nodes[id] !== undefined) {
+            throw new Error(`Node with id ${id} already exists`);
+        }
+        const nodeId = id || uuidv4();
+        const node = { id: nodeId, data };
+        this.nodes[nodeId] = node;
+        return node;
+    }
+    removeNode(node) {
+        // Remove the node from the nodes map
+        delete this.nodes[node.id];
+        // Filter out edges connected to the node
+        this.edges = this.edges.filter((edge) => edge.source !== node.id && edge.target !== node.id);
+    }
+    addEdge(source, target, data) {
+        if (this.nodes[source.id] === undefined) {
+            throw new Error(`Source node ${source.id} not in graph`);
+        }
+        if (this.nodes[target.id] === undefined) {
+            throw new Error(`Target node ${target.id} not in graph`);
+        }
+        const edge = { source: source.id, target: target.id, data };
+        this.edges.push(edge);
+        return edge;
+    }
+    firstNode() {
+        const targets = new Set(this.edges.map((edge) => edge.target));
+        const found = [];
+        Object.values(this.nodes).forEach((node) => {
+            if (!targets.has(node.id)) {
+                found.push(node);
+            }
+        });
+        return found[0];
+    }
+    lastNode() {
+        const sources = new Set(this.edges.map((edge) => edge.source));
+        const found = [];
+        Object.values(this.nodes).forEach((node) => {
+            if (!sources.has(node.id)) {
+                found.push(node);
+            }
+        });
+        return found[0];
+    }
+    extend(graph) {
+        // Add all nodes from the other graph, taking care to avoid duplicates
+        Object.entries(graph.nodes).forEach(([key, value]) => {
+            this.nodes[key] = value;
+        });
+        // Add all edges from the other graph
+        this.edges = [...this.edges, ...graph.edges];
+    }
+    trimFirstNode() {
+        const firstNode = this.firstNode();
+        if (firstNode) {
+            const outgoingEdges = this.edges.filter((edge) => edge.source === firstNode.id);
+            if (Object.keys(this.nodes).length === 1 || outgoingEdges.length === 1) {
+                this.removeNode(firstNode);
+            }
+        }
+    }
+    trimLastNode() {
+        const lastNode = this.lastNode();
+        if (lastNode) {
+            const incomingEdges = this.edges.filter((edge) => edge.target === lastNode.id);
+            if (Object.keys(this.nodes).length === 1 || incomingEdges.length === 1) {
+                this.removeNode(lastNode);
+            }
+        }
+    }
+}

package/dist/runnables/index.d.ts

@@ -1,4 +1,5 @@
-export { type RunnableFunc, type RunnableLike, type RunnableBatchOptions, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableInterface, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
+export { type RunnableBatchOptions, type RunnableInterface, type RunnableIOSchema, } from "./types.js";
 export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { type RouterInput, RouterRunnable } from "./router.js";

package/dist/runnables/types.cjs

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

package/dist/runnables/types.d.ts

@@ -0,0 +1,33 @@
+import type { z } from "zod";
+import type { RunnableConfig } from "./config.js";
+import type { IterableReadableStreamInterface } from "../utils/stream.js";
+import type { SerializableInterface } from "../load/serializable.js";
+export type RunnableBatchOptions = {
+    /** @deprecated Pass in via the standard runnable config object instead */
+    maxConcurrency?: number;
+    returnExceptions?: boolean;
+};
+export type RunnableIOSchema = {
+    name?: string;
+    schema: z.ZodType;
+};
+/**
+ * Base interface implemented by all runnables.
+ * Used for cross-compatibility between different versions of LangChain core.
+ *
+ * Should not change on patch releases.
+ */
+export interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends SerializableInterface {
+    lc_serializable: boolean;
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    getName(suffix?: string): string;
+}

package/dist/runnables/types.js

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

package/dist/runnables/utils.cjs

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._RootEventFilter = void 0;
+exports._RootEventFilter = exports.isRunnableInterface = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isRunnableInterface(thing) {
+    return thing ? thing.lc_runnable : false;
+}
+exports.isRunnableInterface = isRunnableInterface;
 /**
  * Utility to filter the root event in the streamEvents implementation.
  * This is simply binding the arguments to the namespace to make save on

package/dist/runnables/utils.d.ts

@@ -1,4 +1,6 @@
 import { StreamEvent } from "../tracers/log_stream.js";
+import type { RunnableInterface } from "./types.js";
+export declare function isRunnableInterface(thing: any): thing is RunnableInterface;
 /**
  * Utility to filter the root event in the streamEvents implementation.
  * This is simply binding the arguments to the namespace to make save on

package/dist/runnables/utils.js

@@ -1,3 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isRunnableInterface(thing) {
+    return thing ? thing.lc_runnable : false;
+}
 /**
  * Utility to filter the root event in the streamEvents implementation.
  * This is simply binding the arguments to the namespace to make save on

package/dist/tracers/log_stream.cjs

@@ -120,7 +120,7 @@ function isChatGenerationChunk(x) {
  */
 class LogStreamCallbackHandler extends base_js_1.BaseTracer {
     constructor(fields) {
-        super(fields);
+        super({ _awaitHandler: true, ...fields });
         Object.defineProperty(this, "autoClose", {
             enumerable: true,
             configurable: true,

package/dist/tracers/log_stream.js

@@ -115,7 +115,7 @@ function isChatGenerationChunk(x) {
  */
 export class LogStreamCallbackHandler extends BaseTracer {
     constructor(fields) {
-        super(fields);
+        super({ _awaitHandler: true, ...fields });
         Object.defineProperty(this, "autoClose", {
             enumerable: true,
             configurable: true,

package/dist/tracers/root_listener.cjs

@@ -4,7 +4,7 @@ exports.RootListenersTracer = void 0;
 const base_js_1 = require("./base.cjs");
 class RootListenersTracer extends base_js_1.BaseTracer {
     constructor({ config, onStart, onEnd, onError, }) {
-        super();
+        super({ _awaitHandler: true });
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,

package/dist/tracers/root_listener.js

@@ -1,7 +1,7 @@
 import { BaseTracer } from "./base.js";
 export class RootListenersTracer extends BaseTracer {
     constructor({ config, onStart, onEnd, onError, }) {
-        super();
+        super({ _awaitHandler: true });
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,

package/dist/tracers/run_collector.cjs

@@ -12,7 +12,7 @@ class RunCollectorCallbackHandler extends base_js_1.BaseTracer {
      * @param exampleId The ID of the example.
      */
     constructor({ exampleId } = {}) {
-        super();
+        super({ _awaitHandler: true });
         /** The name of the callback handler. */
         Object.defineProperty(this, "name", {
             enumerable: true,

package/dist/tracers/run_collector.js

@@ -9,7 +9,7 @@ export class RunCollectorCallbackHandler extends BaseTracer {
      * @param exampleId The ID of the example.
      */
     constructor({ exampleId } = {}) {
-        super();
+        super({ _awaitHandler: true });
         /** The name of the callback handler. */
         Object.defineProperty(this, "name", {
             enumerable: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {