@langchain/core 0.2.3 → 0.2.4

package/README.md

@@ -83,7 +83,7 @@ Streaming (and streaming of intermediate steps) is needed to show the user that
 Async interfaces are nice when moving into production.
 Rather than having to write multiple implementations for all of those, LCEL allows you to write a runnable once and invoke it in many different ways.
 
-For more check out the [LCEL docs](https://js.langchain.com/docs/expression_language/).
+For more check out the [LCEL docs](https://js.langchain.com/v0.2/docs/concepts#langchain-expression-language).
 
 ![LangChain Stack](../docs/core_docs/static/img/langchain_stack_feb_2024.webp)
 

package/dist/callbacks/manager.cjs

@@ -617,7 +617,12 @@ class CallbackManager extends BaseCallbackManager {
             if (tracingEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
                 if (tracingV2Enabled) {
-                    callbackManager.addHandler(await (0, initialize_js_1.getTracingV2CallbackHandler)(), true);
+                    const tracerV2 = await (0, initialize_js_1.getTracingV2CallbackHandler)();
+                    callbackManager.addHandler(tracerV2, true);
+                    // handoff between langchain and langsmith/traceable
+                    // override the parent run ID
+                    callbackManager._parentRunId =
+                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
                 }
             }
         }

package/dist/callbacks/manager.d.ts

@@ -120,7 +120,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     metadata: Record<string, unknown>;
     inheritableMetadata: Record<string, unknown>;
     name: string;
-    readonly _parentRunId?: string;
+    _parentRunId?: string;
     constructor(parentRunId?: string, options?: {
         handlers?: BaseCallbackHandler[];
         inheritableHandlers?: BaseCallbackHandler[];

package/dist/callbacks/manager.js

@@ -608,7 +608,12 @@ export class CallbackManager extends BaseCallbackManager {
             if (tracingEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
                 if (tracingV2Enabled) {
-                    callbackManager.addHandler(await getTracingV2CallbackHandler(), true);
+                    const tracerV2 = await getTracingV2CallbackHandler();
+                    callbackManager.addHandler(tracerV2, true);
+                    // handoff between langchain and langsmith/traceable
+                    // override the parent run ID
+                    callbackManager._parentRunId =
+                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
                 }
             }
         }

package/dist/runnables/base.cjs

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": 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;
+exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableTraceable = 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 uuid_1 = require("uuid");
+const traceable_1 = require("langsmith/singletons/traceable");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
 const event_stream_js_1 = require("../tracers/event_stream.cjs");
@@ -1385,6 +1386,69 @@ class RunnableMap extends Runnable {
     }
 }
 exports.RunnableMap = RunnableMap;
+/**
+ * A runnable that wraps a traced LangSmith function.
+ */
+class RunnableTraceable extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!(0, traceable_1.isTraceableFunction)(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        const callbacks = await (0, config_js_1.getCallbackManagerForConfig)(config);
+        return (await this.func((0, config_js_1.patchConfig)(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if ((0, iter_js_1.isAsyncIterable)(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if ((0, iter_js_1.isIterator)(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+exports.RunnableTraceable = RunnableTraceable;
+function assertNonTraceableFunction(func) {
+    if ((0, traceable_1.isTraceableFunction)(func)) {
+        throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
+    }
+}
 /**
  * A runnable that runs a callable.
  */
@@ -1393,6 +1457,10 @@ class RunnableLambda extends Runnable {
         return "RunnableLambda";
     }
     constructor(fields) {
+        if ((0, traceable_1.isTraceableFunction)(fields.func)) {
+            // eslint-disable-next-line no-constructor-return
+            return RunnableTraceable.from(fields.func);
+        }
         super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -1406,6 +1474,7 @@ class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1453,7 +1522,7 @@ class RunnableLambda extends Runnable {
                         }
                         output = finalOutput;
                     }
-                    else if ((0, iter_js_1.isIterator)(output)) {
+                    else if ((0, iter_js_1.isIterableIterator)(output)) {
                         let finalOutput;
                         for (const chunk of (0, iter_js_1.consumeIteratorInContext)(childConfig, output)) {
                             if (finalOutput === undefined) {
@@ -1531,7 +1600,7 @@ class RunnableLambda extends Runnable {
                 yield chunk;
             }
         }
-        else if ((0, iter_js_1.isIterator)(output)) {
+        else if ((0, iter_js_1.isIterableIterator)(output)) {
             for (const chunk of (0, iter_js_1.consumeIteratorInContext)(config, output)) {
                 yield chunk;
             }

package/dist/runnables/base.d.ts

@@ -1,3 +1,4 @@
+import { type TraceableFunction } from "langsmith/singletons/traceable";
 import type { RunnableInterface, RunnableBatchOptions } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, LogStreamCallbackHandlerInput, RunLogPatch } from "../tracers/log_stream.js";
@@ -463,6 +464,21 @@ export declare class RunnableMap<RunInput = any, RunOutput extends Record<string
     transform(generator: AsyncGenerator<RunInput>, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
     stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
 }
+type AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;
+/**
+ * A runnable that wraps a traced LangSmith function.
+ */
+export declare class RunnableTraceable<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    lc_serializable: boolean;
+    lc_namespace: string[];
+    protected func: AnyTraceableFunction;
+    constructor(fields: {
+        func: AnyTraceableFunction;
+    });
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    _streamIterator(input: RunInput, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
+    static from(func: AnyTraceableFunction): RunnableTraceable<unknown, unknown>;
+}
 /**
  * A runnable that runs a callable.
  */
@@ -471,9 +487,10 @@ export declare class RunnableLambda<RunInput, RunOutput> extends Runnable<RunInp
     lc_namespace: string[];
     protected func: RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>>;
     constructor(fields: {
-        func: RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>>;
+        func: RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>> | TraceableFunction<RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>>>;
     });
     static from<RunInput, RunOutput>(func: RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>>): RunnableLambda<RunInput, RunOutput>;
+    static from<RunInput, RunOutput>(func: TraceableFunction<RunnableFunc<RunInput, RunOutput | Runnable<RunInput, RunOutput>>>): RunnableLambda<RunInput, RunOutput>;
     _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
     _transform(generator: AsyncGenerator<RunInput>, runManager?: CallbackManagerForChainRun, config?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;

package/dist/runnables/base.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
+import { isTraceableFunction, } from "langsmith/singletons/traceable";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } from "../tracers/log_stream.js";
 import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
@@ -13,7 +14,7 @@ import { _RootEventFilter, isRunnableInterface } from "./utils.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { Graph } from "./graph.js";
 import { convertToHttpEventStream } from "./wrappers.js";
-import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterator, } from "./iter.js";
+import { consumeAsyncIterableInContext, consumeIteratorInContext, isAsyncIterable, isIterableIterator, isIterator, } from "./iter.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function _coerceToDict(value, defaultKey) {
     return value &&
@@ -1372,6 +1373,68 @@ export class RunnableMap extends Runnable {
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
+/**
+ * A runnable that wraps a traced LangSmith function.
+ */
+export class RunnableTraceable extends Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isTraceableFunction(fields.func)) {
+            throw new Error("RunnableTraceable requires a function that is wrapped in traceable higher-order function");
+        }
+        this.func = fields.func;
+    }
+    async invoke(input, options) {
+        const [config] = this._getOptionsList(options ?? {}, 1);
+        const callbacks = await getCallbackManagerForConfig(config);
+        return (await this.func(patchConfig(config, { callbacks }), input));
+    }
+    async *_streamIterator(input, options) {
+        const result = await this.invoke(input, options);
+        if (isAsyncIterable(result)) {
+            for await (const item of result) {
+                yield item;
+            }
+            return;
+        }
+        if (isIterator(result)) {
+            while (true) {
+                const state = result.next();
+                if (state.done)
+                    break;
+                yield state.value;
+            }
+            return;
+        }
+        yield result;
+    }
+    static from(func) {
+        return new RunnableTraceable({ func });
+    }
+}
+function assertNonTraceableFunction(func) {
+    if (isTraceableFunction(func)) {
+        throw new Error("RunnableLambda requires a function that is not wrapped in traceable higher-order function. This shouldn't happen.");
+    }
+}
 /**
  * A runnable that runs a callable.
  */
@@ -1380,6 +1443,10 @@ export class RunnableLambda extends Runnable {
         return "RunnableLambda";
     }
     constructor(fields) {
+        if (isTraceableFunction(fields.func)) {
+            // eslint-disable-next-line no-constructor-return
+            return RunnableTraceable.from(fields.func);
+        }
         super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -1393,6 +1460,7 @@ export class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1440,7 +1508,7 @@ export class RunnableLambda extends Runnable {
                         }
                         output = finalOutput;
                     }
-                    else if (isIterator(output)) {
+                    else if (isIterableIterator(output)) {
                         let finalOutput;
                         for (const chunk of consumeIteratorInContext(childConfig, output)) {
                             if (finalOutput === undefined) {
@@ -1518,7 +1586,7 @@ export class RunnableLambda extends Runnable {
                 yield chunk;
             }
         }
-        else if (isIterator(output)) {
+        else if (isIterableIterator(output)) {
             for (const chunk of consumeIteratorInContext(config, output)) {
                 yield chunk;
             }

package/dist/runnables/iter.cjs

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = void 0;
+exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = exports.isIterableIterator = void 0;
 const index_js_1 = require("../singletons/index.cjs");
-function isIterator(thing) {
+function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
         typeof thing[Symbol.iterator] === "function" &&
         // avoid detecting array/set as iterator
         typeof thing.next === "function");
 }
+exports.isIterableIterator = isIterableIterator;
+const isIterator = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
 exports.isIterator = isIterator;
 function isAsyncIterable(thing) {
     return (typeof thing === "object" &&

package/dist/runnables/iter.d.ts

@@ -1,5 +1,6 @@
 import { RunnableConfig } from "./config.js";
-export declare function isIterator(thing: unknown): thing is IterableIterator<unknown>;
+export declare function isIterableIterator(thing: unknown): thing is IterableIterator<unknown>;
+export declare const isIterator: (x: unknown) => x is Iterator<unknown, any, undefined>;
 export declare function isAsyncIterable(thing: unknown): thing is AsyncIterable<unknown>;
 export declare function consumeIteratorInContext<T>(context: Partial<RunnableConfig> | undefined, iter: IterableIterator<T>): IterableIterator<T>;
 export declare function consumeAsyncIterableInContext<T>(context: Partial<RunnableConfig> | undefined, iter: AsyncIterable<T>): AsyncIterableIterator<T>;

package/dist/runnables/iter.js

@@ -1,11 +1,15 @@
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
-export function isIterator(thing) {
+export function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
         typeof thing[Symbol.iterator] === "function" &&
         // avoid detecting array/set as iterator
         typeof thing.next === "function");
 }
+export const isIterator = (x) => x != null &&
+    typeof x === "object" &&
+    "next" in x &&
+    typeof x.next === "function";
 export function isAsyncIterable(thing) {
     return (typeof thing === "object" &&
         thing !== null &&

package/dist/tracers/tracer_langchain.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainTracer = void 0;
 const langsmith_1 = require("langsmith");
+const traceable_1 = require("langsmith/singletons/traceable");
 const env_js_1 = require("../utils/env.cjs");
 const base_js_1 = require("./base.cjs");
 class LangChainTracer extends base_js_1.BaseTracer {
@@ -38,6 +39,38 @@ class LangChainTracer extends base_js_1.BaseTracer {
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
         this.client = client ?? new langsmith_1.Client({});
+        // if we're inside traceable, we can obtain the traceable tree
+        // and populate the run map, which is used to correctly
+        // infer dotted order and execution order
+        const traceableTree = this.getTraceableRunTree();
+        if (traceableTree) {
+            let rootRun = traceableTree;
+            const visited = new Set();
+            while (rootRun.parent_run) {
+                if (visited.has(rootRun.id))
+                    break;
+                visited.add(rootRun.id);
+                if (!rootRun.parent_run)
+                    break;
+                rootRun = rootRun.parent_run;
+            }
+            visited.clear();
+            const queue = [rootRun];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current || visited.has(current.id))
+                    continue;
+                visited.add(current.id);
+                // @ts-expect-error Types of property 'events' are incompatible.
+                this.runMap.set(current.id, current);
+                if (current.child_runs) {
+                    queue.push(...current.child_runs);
+                }
+            }
+            this.client = traceableTree.client ?? this.client;
+            this.projectName = traceableTree.project_name ?? this.projectName;
+            this.exampleId = traceableTree.reference_example_id ?? this.exampleId;
+        }
     }
     async _convertToCreate(run, example_id = undefined) {
         return {
@@ -72,5 +105,13 @@ class LangChainTracer extends base_js_1.BaseTracer {
     getRun(id) {
         return this.runMap.get(id);
     }
+    getTraceableRunTree() {
+        try {
+            return (0, traceable_1.getCurrentRunTree)();
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 exports.LangChainTracer = LangChainTracer;

package/dist/tracers/tracer_langchain.d.ts

@@ -1,4 +1,5 @@
 import { Client } from "langsmith";
+import { RunTree } from "langsmith/run_trees";
 import { BaseRun, RunCreate, RunUpdate as BaseRunUpdate, KVMap } from "langsmith/schemas";
 import { BaseTracer } from "./base.js";
 import { BaseCallbackHandlerInput } from "../callbacks/base.js";
@@ -35,4 +36,5 @@ export declare class LangChainTracer extends BaseTracer implements LangChainTrac
     onRunCreate(run: Run): Promise<void>;
     onRunUpdate(run: Run): Promise<void>;
     getRun(id: string): Run | undefined;
+    getTraceableRunTree(): RunTree | undefined;
 }

package/dist/tracers/tracer_langchain.js

@@ -1,4 +1,5 @@
 import { Client } from "langsmith";
+import { getCurrentRunTree } from "langsmith/singletons/traceable";
 import { getEnvironmentVariable, getRuntimeEnvironment } from "../utils/env.js";
 import { BaseTracer } from "./base.js";
 export class LangChainTracer extends BaseTracer {
@@ -35,6 +36,38 @@ export class LangChainTracer extends BaseTracer {
                 getEnvironmentVariable("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
         this.client = client ?? new Client({});
+        // if we're inside traceable, we can obtain the traceable tree
+        // and populate the run map, which is used to correctly
+        // infer dotted order and execution order
+        const traceableTree = this.getTraceableRunTree();
+        if (traceableTree) {
+            let rootRun = traceableTree;
+            const visited = new Set();
+            while (rootRun.parent_run) {
+                if (visited.has(rootRun.id))
+                    break;
+                visited.add(rootRun.id);
+                if (!rootRun.parent_run)
+                    break;
+                rootRun = rootRun.parent_run;
+            }
+            visited.clear();
+            const queue = [rootRun];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current || visited.has(current.id))
+                    continue;
+                visited.add(current.id);
+                // @ts-expect-error Types of property 'events' are incompatible.
+                this.runMap.set(current.id, current);
+                if (current.child_runs) {
+                    queue.push(...current.child_runs);
+                }
+            }
+            this.client = traceableTree.client ?? this.client;
+            this.projectName = traceableTree.project_name ?? this.projectName;
+            this.exampleId = traceableTree.reference_example_id ?? this.exampleId;
+        }
     }
     async _convertToCreate(run, example_id = undefined) {
         return {
@@ -69,4 +102,12 @@ export class LangChainTracer extends BaseTracer {
     getRun(id) {
         return this.runMap.get(id);
     }
+    getTraceableRunTree() {
+        try {
+            return getCurrentRunTree();
+        }
+        catch {
+            return undefined;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -45,7 +45,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "~0.1.7",
+    "langsmith": "~0.1.30",
     "ml-distance": "^4.0.0",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",