@langchain/core 0.2.3 → 0.2.5

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/messages/ai.cjs

@@ -76,11 +76,21 @@ class AIMessage extends base_js_1.BaseMessage {
             writable: true,
             value: []
         });
+        /**
+         * If provided, token usage information associated with the message.
+         */
+        Object.defineProperty(this, "usage_metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (typeof initParams !== "string") {
             this.tool_calls = initParams.tool_calls ?? this.tool_calls;
             this.invalid_tool_calls =
                 initParams.invalid_tool_calls ?? this.invalid_tool_calls;
         }
+        this.usage_metadata = initParams.usage_metadata;
     }
     static lc_name() {
         return "AIMessage";
@@ -172,11 +182,21 @@ class AIMessageChunk extends base_js_1.BaseMessageChunk {
             writable: true,
             value: []
         });
+        /**
+         * If provided, token usage information associated with the message.
+         */
+        Object.defineProperty(this, "usage_metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_chunks =
-            initParams?.tool_call_chunks ?? this.tool_call_chunks;
-        this.tool_calls = initParams?.tool_calls ?? this.tool_calls;
+            initParams.tool_call_chunks ?? this.tool_call_chunks;
+        this.tool_calls = initParams.tool_calls ?? this.tool_calls;
         this.invalid_tool_calls =
-            initParams?.invalid_tool_calls ?? this.invalid_tool_calls;
+            initParams.invalid_tool_calls ?? this.invalid_tool_calls;
+        this.usage_metadata = initParams.usage_metadata;
     }
     get lc_aliases() {
         // exclude snake case conversion to pascal case
@@ -207,6 +227,25 @@ class AIMessageChunk extends base_js_1.BaseMessageChunk {
                 combinedFields.tool_call_chunks = rawToolCalls;
             }
         }
+        if (this.usage_metadata !== undefined ||
+            chunk.usage_metadata !== undefined) {
+            const left = this.usage_metadata ?? {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+            };
+            const right = chunk.usage_metadata ?? {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+            };
+            const usage_metadata = {
+                input_tokens: left.input_tokens + right.input_tokens,
+                output_tokens: left.output_tokens + right.output_tokens,
+                total_tokens: left.total_tokens + right.total_tokens,
+            };
+            combinedFields.usage_metadata = usage_metadata;
+        }
         return new AIMessageChunk(combinedFields);
     }
 }

package/dist/messages/ai.d.ts

@@ -3,6 +3,24 @@ import { InvalidToolCall, ToolCall, ToolCallChunk } from "./tool.js";
 export type AIMessageFields = BaseMessageFields & {
     tool_calls?: ToolCall[];
     invalid_tool_calls?: InvalidToolCall[];
+    usage_metadata?: UsageMetadata;
+};
+/**
+ * Usage metadata for a message, such as token counts.
+ */
+export type UsageMetadata = {
+    /**
+     * The count of input (or prompt) tokens.
+     */
+    input_tokens: number;
+    /**
+     * The count of output (or completion) tokens
+     */
+    output_tokens: number;
+    /**
+     * The total token count
+     */
+    total_tokens: number;
 };
 /**
  * Represents an AI message in a conversation.
@@ -10,6 +28,10 @@ export type AIMessageFields = BaseMessageFields & {
 export declare class AIMessage extends BaseMessage {
     tool_calls?: ToolCall[];
     invalid_tool_calls?: InvalidToolCall[];
+    /**
+     * If provided, token usage information associated with the message.
+     */
+    usage_metadata?: UsageMetadata;
     get lc_aliases(): Record<string, string>;
     constructor(fields: string | AIMessageFields, 
     /** @deprecated */
@@ -29,6 +51,10 @@ export declare class AIMessageChunk extends BaseMessageChunk {
     tool_calls?: ToolCall[];
     invalid_tool_calls?: InvalidToolCall[];
     tool_call_chunks?: ToolCallChunk[];
+    /**
+     * If provided, token usage information associated with the message.
+     */
+    usage_metadata?: UsageMetadata;
     constructor(fields: string | AIMessageChunkFields);
     get lc_aliases(): Record<string, string>;
     static lc_name(): string;

package/dist/messages/ai.js

@@ -73,11 +73,21 @@ export class AIMessage extends BaseMessage {
             writable: true,
             value: []
         });
+        /**
+         * If provided, token usage information associated with the message.
+         */
+        Object.defineProperty(this, "usage_metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (typeof initParams !== "string") {
             this.tool_calls = initParams.tool_calls ?? this.tool_calls;
             this.invalid_tool_calls =
                 initParams.invalid_tool_calls ?? this.invalid_tool_calls;
         }
+        this.usage_metadata = initParams.usage_metadata;
     }
     static lc_name() {
         return "AIMessage";
@@ -167,11 +177,21 @@ export class AIMessageChunk extends BaseMessageChunk {
             writable: true,
             value: []
         });
+        /**
+         * If provided, token usage information associated with the message.
+         */
+        Object.defineProperty(this, "usage_metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.tool_call_chunks =
-            initParams?.tool_call_chunks ?? this.tool_call_chunks;
-        this.tool_calls = initParams?.tool_calls ?? this.tool_calls;
+            initParams.tool_call_chunks ?? this.tool_call_chunks;
+        this.tool_calls = initParams.tool_calls ?? this.tool_calls;
         this.invalid_tool_calls =
-            initParams?.invalid_tool_calls ?? this.invalid_tool_calls;
+            initParams.invalid_tool_calls ?? this.invalid_tool_calls;
+        this.usage_metadata = initParams.usage_metadata;
     }
     get lc_aliases() {
         // exclude snake case conversion to pascal case
@@ -202,6 +222,25 @@ export class AIMessageChunk extends BaseMessageChunk {
                 combinedFields.tool_call_chunks = rawToolCalls;
             }
         }
+        if (this.usage_metadata !== undefined ||
+            chunk.usage_metadata !== undefined) {
+            const left = this.usage_metadata ?? {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+            };
+            const right = chunk.usage_metadata ?? {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+            };
+            const usage_metadata = {
+                input_tokens: left.input_tokens + right.input_tokens,
+                output_tokens: left.output_tokens + right.output_tokens,
+                total_tokens: left.total_tokens + right.total_tokens,
+            };
+            combinedFields.usage_metadata = usage_metadata;
+        }
         return new AIMessageChunk(combinedFields);
     }
 }

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");
@@ -480,7 +481,7 @@ class Runnable extends serializable_js_1.Serializable {
     async *_streamEventsV2(input, options, streamOptions) {
         const eventStreamer = new event_stream_js_1.EventStreamCallbackHandler({
             ...streamOptions,
-            autoClose: true,
+            autoClose: false,
         });
         const config = (0, config_js_1.ensureConfig)(options);
         const runId = config.runId ?? (0, uuid_1.v4)();
@@ -502,11 +503,16 @@ class Runnable extends serializable_js_1.Serializable {
         // add each chunk to the output stream
         const outerThis = this;
         async function consumeRunnableStream() {
-            const runnableStream = await outerThis.stream(input, config);
-            const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            for await (const _ of tappedStream) {
-                // Just iterate so that the callback handler picks up events
+            try {
+                const runnableStream = await outerThis.stream(input, config);
+                const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for await (const _ of tappedStream) {
+                    // Just iterate so that the callback handler picks up events
+                }
+            }
+            finally {
+                await eventStreamer.finish();
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();
@@ -1385,6 +1391,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 +1462,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 +1479,7 @@ class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1453,7 +1527,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 +1605,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 &&
@@ -473,7 +474,7 @@ export class Runnable extends Serializable {
     async *_streamEventsV2(input, options, streamOptions) {
         const eventStreamer = new EventStreamCallbackHandler({
             ...streamOptions,
-            autoClose: true,
+            autoClose: false,
         });
         const config = ensureConfig(options);
         const runId = config.runId ?? uuidv4();
@@ -495,11 +496,16 @@ export class Runnable extends Serializable {
         // add each chunk to the output stream
         const outerThis = this;
         async function consumeRunnableStream() {
-            const runnableStream = await outerThis.stream(input, config);
-            const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            for await (const _ of tappedStream) {
-                // Just iterate so that the callback handler picks up events
+            try {
+                const runnableStream = await outerThis.stream(input, config);
+                const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for await (const _ of tappedStream) {
+                    // Just iterate so that the callback handler picks up events
+                }
+            }
+            finally {
+                await eventStreamer.finish();
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();
@@ -1372,6 +1378,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 +1448,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 +1465,7 @@ export class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1440,7 +1513,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 +1591,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/runnables/remote.cjs

@@ -310,7 +310,8 @@ class RemoteRunnable extends base_js_1.Runnable {
     async *_streamIterator(input, options) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let finalOutput;
         let finalOutputSupported = true;
         try {
@@ -360,7 +361,8 @@ class RemoteRunnable extends base_js_1.Runnable {
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -411,7 +413,8 @@ class RemoteRunnable extends base_js_1.Runnable {
         const generator = async function* () {
             const [config, kwargs] = outerThis._separateRunnableConfigFromCallOptions(options);
             const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+            delete config.runId;
             // The type is in camelCase but the API only accepts snake_case.
             const camelCaseStreamOptions = {
                 include_names: streamOptions?.includeNames,

package/dist/runnables/remote.js

@@ -307,7 +307,8 @@ export class RemoteRunnable extends Runnable {
     async *_streamIterator(input, options) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         let finalOutput;
         let finalOutputSupported = true;
         try {
@@ -357,7 +358,8 @@ export class RemoteRunnable extends Runnable {
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+        delete config.runId;
         // The type is in camelCase but the API only accepts snake_case.
         const camelCaseStreamOptions = {
             include_names: streamOptions?.includeNames,
@@ -408,7 +410,8 @@ export class RemoteRunnable extends Runnable {
         const generator = async function* () {
             const [config, kwargs] = outerThis._separateRunnableConfigFromCallOptions(options);
             const callbackManager_ = await getCallbackManagerForConfig(options);
-            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), _coerceToDict(input, "input"), config.runId, undefined, undefined, undefined, config.runName);
+            delete config.runId;
             // The type is in camelCase but the API only accepts snake_case.
             const camelCaseStreamOptions = {
                 include_names: streamOptions?.includeNames,

package/dist/tracers/event_stream.cjs

@@ -70,12 +70,6 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "rootId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "runInfoMap", {
             enumerable: true,
             configurable: true,
@@ -164,7 +158,10 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             return;
         }
         const runInfo = this.runInfoMap.get(runId);
-        // run has finished, don't issue any stream events
+        // Run has finished, don't issue any stream events.
+        // An example of this is for runnables that use the default
+        // implementation of .stream(), which delegates to .invoke()
+        // and calls .onChainEnd() before passing it to the iterator.
         if (runInfo === undefined) {
             yield firstChunk.value;
             return;
@@ -207,7 +204,7 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             finally {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 tappedPromiseResolver();
-                // Don't delete from the map to keep track of which runs have been tapped.
+                // Don't delete from the promises map to keep track of which runs have been tapped.
             }
         }
         else {
@@ -492,18 +489,11 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             metadata: runInfo.metadata,
         }, runInfo);
     }
-    async onRunCreate(run) {
-        if (this.rootId === undefined) {
-            this.rootId = run.id;
-        }
-    }
-    async onRunUpdate(run) {
-        if (run.id === this.rootId && this.autoClose) {
-            const pendingPromises = [...this.tappedPromises.values()];
-            void Promise.all(pendingPromises).finally(() => {
-                void this.writer.close();
-            });
-        }
+    async finish() {
+        const pendingPromises = [...this.tappedPromises.values()];
+        void Promise.all(pendingPromises).finally(() => {
+            void this.writer.close();
+        });
     }
 }
 exports.EventStreamCallbackHandler = EventStreamCallbackHandler;

package/dist/tracers/event_stream.d.ts

@@ -109,7 +109,6 @@ export declare class EventStreamCallbackHandler extends BaseTracer {
     protected excludeNames?: string[];
     protected excludeTypes?: string[];
     protected excludeTags?: string[];
-    protected rootId?: string;
     private runInfoMap;
     private tappedPromises;
     protected transformStream: TransformStream;
@@ -134,7 +133,6 @@ export declare class EventStreamCallbackHandler extends BaseTracer {
     onToolEnd(run: Run): Promise<void>;
     onRetrieverStart(run: Run): Promise<void>;
     onRetrieverEnd(run: Run): Promise<void>;
-    onRunCreate(run: Run): Promise<void>;
-    onRunUpdate(run: Run): Promise<void>;
+    finish(): Promise<void>;
 }
 export {};

package/dist/tracers/event_stream.js

@@ -66,12 +66,6 @@ export class EventStreamCallbackHandler extends BaseTracer {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "rootId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "runInfoMap", {
             enumerable: true,
             configurable: true,
@@ -160,7 +154,10 @@ export class EventStreamCallbackHandler extends BaseTracer {
             return;
         }
         const runInfo = this.runInfoMap.get(runId);
-        // run has finished, don't issue any stream events
+        // Run has finished, don't issue any stream events.
+        // An example of this is for runnables that use the default
+        // implementation of .stream(), which delegates to .invoke()
+        // and calls .onChainEnd() before passing it to the iterator.
         if (runInfo === undefined) {
             yield firstChunk.value;
             return;
@@ -203,7 +200,7 @@ export class EventStreamCallbackHandler extends BaseTracer {
             finally {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 tappedPromiseResolver();
-                // Don't delete from the map to keep track of which runs have been tapped.
+                // Don't delete from the promises map to keep track of which runs have been tapped.
             }
         }
         else {
@@ -488,17 +485,10 @@ export class EventStreamCallbackHandler extends BaseTracer {
             metadata: runInfo.metadata,
         }, runInfo);
     }
-    async onRunCreate(run) {
-        if (this.rootId === undefined) {
-            this.rootId = run.id;
-        }
-    }
-    async onRunUpdate(run) {
-        if (run.id === this.rootId && this.autoClose) {
-            const pendingPromises = [...this.tappedPromises.values()];
-            void Promise.all(pendingPromises).finally(() => {
-                void this.writer.close();
-            });
-        }
+    async finish() {
+        const pendingPromises = [...this.tappedPromises.values()];
+        void Promise.all(pendingPromises).finally(() => {
+            void this.writer.close();
+        });
     }
 }

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.5",
   "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",