@langchain/core 0.1.43 → 0.1.45-rc.0

package/dist/output_parsers/structured.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { BaseOutputParser, FormatInstructionsOptions } from "./base.js";
+export type JsonMarkdownStructuredOutputParserInput = {
+    interpolationDepth?: number;
+};
+export interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {
+    interpolationDepth?: number;
+}
+export declare class StructuredOutputParser<T extends z.ZodTypeAny> extends BaseOutputParser<z.infer<T>> {
+    schema: T;
+    static lc_name(): string;
+    lc_namespace: string[];
+    toJSON(): import("../load/serializable.js").SerializedNotImplemented;
+    constructor(schema: T);
+    /**
+     * Creates a new StructuredOutputParser from a Zod schema.
+     * @param schema The Zod schema which the output should match
+     * @returns A new instance of StructuredOutputParser.
+     */
+    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): StructuredOutputParser<T>;
+    /**
+     * Creates a new StructuredOutputParser from a set of names and
+     * descriptions.
+     * @param schemas An object where each key is a name and each value is a description
+     * @returns A new instance of StructuredOutputParser.
+     */
+    static fromNamesAndDescriptions<S extends {
+        [key: string]: string;
+    }>(schemas: S): StructuredOutputParser<z.ZodObject<{
+        [k: string]: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: string;
+    }, {
+        [x: string]: string;
+    }>>;
+    /**
+     * Returns a markdown code snippet with a JSON object formatted according
+     * to the schema.
+     * @param options Optional. The options for formatting the instructions
+     * @returns A markdown code snippet with a JSON object formatted according to the schema.
+     */
+    getFormatInstructions(): string;
+    /**
+     * Parses the given text according to the schema.
+     * @param text The text to parse
+     * @returns The parsed output.
+     */
+    parse(text: string): Promise<z.infer<T>>;
+}
+/**
+ * A specific type of `StructuredOutputParser` that parses JSON data
+ * formatted as a markdown code snippet.
+ */
+export declare class JsonMarkdownStructuredOutputParser<T extends z.ZodTypeAny> extends StructuredOutputParser<T> {
+    static lc_name(): string;
+    getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;
+    private _schemaToInstruction;
+    static fromZodSchema<T extends z.ZodTypeAny>(schema: T): JsonMarkdownStructuredOutputParser<T>;
+    static fromNamesAndDescriptions<S extends {
+        [key: string]: string;
+    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{
+        [k: string]: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: string;
+    }, {
+        [x: string]: string;
+    }>>;
+}
+export interface AsymmetricStructuredOutputParserFields<T extends z.ZodTypeAny> {
+    inputSchema: T;
+}
+/**
+ * A type of `StructuredOutputParser` that handles asymmetric input and
+ * output schemas.
+ */
+export declare abstract class AsymmetricStructuredOutputParser<T extends z.ZodTypeAny, Y = unknown> extends BaseOutputParser<Y> {
+    private structuredInputParser;
+    constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);
+    /**
+     * Processes the parsed input into the desired output format. Must be
+     * implemented by subclasses.
+     * @param input The parsed input
+     * @returns The processed output.
+     */
+    abstract outputProcessor(input: z.infer<T>): Promise<Y>;
+    parse(text: string): Promise<Y>;
+    getFormatInstructions(): string;
+}

package/dist/output_parsers/structured.js

@@ -0,0 +1,184 @@
+import { z } from "zod";
+import { zodToJsonSchema, } from "zod-to-json-schema";
+import { BaseOutputParser, OutputParserException, } from "./base.js";
+export class StructuredOutputParser extends BaseOutputParser {
+    static lc_name() {
+        return "StructuredOutputParser";
+    }
+    toJSON() {
+        return this.toJSONNotImplemented();
+    }
+    constructor(schema) {
+        super(schema);
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: schema
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "structured"]
+        });
+    }
+    /**
+     * Creates a new StructuredOutputParser from a Zod schema.
+     * @param schema The Zod schema which the output should match
+     * @returns A new instance of StructuredOutputParser.
+     */
+    static fromZodSchema(schema) {
+        return new this(schema);
+    }
+    /**
+     * Creates a new StructuredOutputParser from a set of names and
+     * descriptions.
+     * @param schemas An object where each key is a name and each value is a description
+     * @returns A new instance of StructuredOutputParser.
+     */
+    static fromNamesAndDescriptions(schemas) {
+        const zodSchema = z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, z.string().describe(description)])));
+        return new this(zodSchema);
+    }
+    /**
+     * Returns a markdown code snippet with a JSON object formatted according
+     * to the schema.
+     * @param options Optional. The options for formatting the instructions
+     * @returns A markdown code snippet with a JSON object formatted according to the schema.
+     */
+    getFormatInstructions() {
+        return `You must format your output as a JSON value that adheres to a given "JSON Schema" instance.
+
+"JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.
+
+For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}
+would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.
+Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
+
+Your output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match the schema exactly and there are no trailing commas!
+
+Here is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:
+\`\`\`json
+${JSON.stringify(zodToJsonSchema(this.schema))}
+\`\`\`
+`;
+    }
+    /**
+     * Parses the given text according to the schema.
+     * @param text The text to parse
+     * @returns The parsed output.
+     */
+    async parse(text) {
+        try {
+            const json = text.includes("```")
+                ? text.trim().split(/```(?:json)?/)[1]
+                : text.trim();
+            return await this.schema.parseAsync(JSON.parse(json));
+        }
+        catch (e) {
+            throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+        }
+    }
+}
+/**
+ * A specific type of `StructuredOutputParser` that parses JSON data
+ * formatted as a markdown code snippet.
+ */
+export class JsonMarkdownStructuredOutputParser extends StructuredOutputParser {
+    static lc_name() {
+        return "JsonMarkdownStructuredOutputParser";
+    }
+    getFormatInstructions(options) {
+        const interpolationDepth = options?.interpolationDepth ?? 1;
+        if (interpolationDepth < 1) {
+            throw new Error("f string interpolation depth must be at least 1");
+        }
+        return `Return a markdown code snippet with a JSON object formatted to look like:\n\`\`\`json\n${this._schemaToInstruction(zodToJsonSchema(this.schema))
+            .replaceAll("{", "{".repeat(interpolationDepth))
+            .replaceAll("}", "}".repeat(interpolationDepth))}\n\`\`\``;
+    }
+    _schemaToInstruction(schemaInput, indent = 2) {
+        const schema = schemaInput;
+        if ("type" in schema) {
+            let nullable = false;
+            let type;
+            if (Array.isArray(schema.type)) {
+                const nullIdx = schema.type.findIndex((type) => type === "null");
+                if (nullIdx !== -1) {
+                    nullable = true;
+                    schema.type.splice(nullIdx, 1);
+                }
+                type = schema.type.join(" | ");
+            }
+            else {
+                type = schema.type;
+            }
+            if (schema.type === "object" && schema.properties) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                const properties = Object.entries(schema.properties)
+                    .map(([key, value]) => {
+                    const isOptional = schema.required?.includes(key)
+                        ? ""
+                        : " (optional)";
+                    return `${" ".repeat(indent)}"${key}": ${this._schemaToInstruction(value, indent + 2)}${isOptional}`;
+                })
+                    .join("\n");
+                return `{\n${properties}\n${" ".repeat(indent - 2)}}${description}`;
+            }
+            if (schema.type === "array" && schema.items) {
+                const description = schema.description
+                    ? ` // ${schema.description}`
+                    : "";
+                return `array[\n${" ".repeat(indent)}${this._schemaToInstruction(schema.items, indent + 2)}\n${" ".repeat(indent - 2)}] ${description}`;
+            }
+            const isNullable = nullable ? " (nullable)" : "";
+            const description = schema.description ? ` // ${schema.description}` : "";
+            return `${type}${description}${isNullable}`;
+        }
+        if ("anyOf" in schema) {
+            return schema.anyOf
+                .map((s) => this._schemaToInstruction(s, indent))
+                .join(`\n${" ".repeat(indent - 2)}`);
+        }
+        throw new Error("unsupported schema type");
+    }
+    static fromZodSchema(schema) {
+        return new this(schema);
+    }
+    static fromNamesAndDescriptions(schemas) {
+        const zodSchema = z.object(Object.fromEntries(Object.entries(schemas).map(([name, description]) => [name, z.string().describe(description)])));
+        return new this(zodSchema);
+    }
+}
+/**
+ * A type of `StructuredOutputParser` that handles asymmetric input and
+ * output schemas.
+ */
+export class AsymmetricStructuredOutputParser extends BaseOutputParser {
+    constructor({ inputSchema }) {
+        super(...arguments);
+        Object.defineProperty(this, "structuredInputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.structuredInputParser = new JsonMarkdownStructuredOutputParser(inputSchema);
+    }
+    async parse(text) {
+        let parsedInput;
+        try {
+            parsedInput = await this.structuredInputParser.parse(text);
+        }
+        catch (e) {
+            throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+        }
+        return this.outputProcessor(parsedInput);
+    }
+    getFormatInstructions() {
+        return this.structuredInputParser.getFormatInstructions();
+    }
+}

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;