@langchain/core 0.1.43 → 0.1.45-rc.0

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.43",
+  "version": "0.1.45-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {