@langchain/core 0.2.2 → 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

@@ -601,7 +601,8 @@ class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true";
+        const tracingV2Enabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" ||
+            (0, env_js_1.getEnvironmentVariable)("LANGSMITH_TRACING") === "true";
         const tracingEnabled = tracingV2Enabled ||
             ((0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -616,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

@@ -592,7 +592,8 @@ export class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true";
+        const tracingV2Enabled = getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" ||
+            getEnvironmentVariable("LANGSMITH_TRACING") === "true";
         const tracingEnabled = tracingV2Enabled ||
             (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -607,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/language_models/chat_models.cjs

@@ -5,6 +5,9 @@ const index_js_1 = require("../messages/index.cjs");
 const outputs_js_1 = require("../outputs.cjs");
 const base_js_1 = require("./base.cjs");
 const manager_js_1 = require("../callbacks/manager.cjs");
+const event_stream_js_1 = require("../tracers/event_stream.cjs");
+const log_stream_js_1 = require("../tracers/log_stream.cjs");
+const stream_js_1 = require("../utils/stream.cjs");
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -128,39 +131,76 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             batch_size: 1,
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
-        // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
-        // handle results
         const generations = [];
         const llmOutputs = [];
-        await Promise.all(results.map(async (pResult, i) => {
-            if (pResult.status === "fulfilled") {
-                const result = pResult.value;
-                for (const generation of result.generations) {
-                    generation.message.response_metadata = {
-                        ...generation.generationInfo,
-                        ...generation.message.response_metadata,
-                    };
+        // Even if stream is not explicitly called, check if model is implicitly
+        // called from streamEvents() or streamLog() to get all streamed events.
+        // Bail out if _streamResponseChunks not overridden
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find((handler) => {
+            return (0, event_stream_js_1.isStreamEventsHandler)(handler) || (0, log_stream_js_1.isLogStreamHandler)(handler);
+        });
+        if (hasStreamingHandler &&
+            baseMessages.length === 1 &&
+            this._streamResponseChunks !==
+                BaseChatModel.prototype._streamResponseChunks) {
+            try {
+                const stream = await this._streamResponseChunks(baseMessages[0], parsedOptions, runManagers?.[0]);
+                let aggregated;
+                for await (const chunk of stream) {
+                    if (aggregated === undefined) {
+                        aggregated = chunk;
+                    }
+                    else {
+                        aggregated = (0, stream_js_1.concat)(aggregated, chunk);
+                    }
                 }
-                if (result.generations.length === 1) {
-                    result.generations[0].message.response_metadata = {
-                        ...result.llmOutput,
-                        ...result.generations[0].message.response_metadata,
-                    };
+                if (aggregated === undefined) {
+                    throw new Error("Received empty response from chat model call.");
                 }
-                generations[i] = result.generations;
-                llmOutputs[i] = result.llmOutput;
-                return runManagers?.[i]?.handleLLMEnd({
-                    generations: [result.generations],
-                    llmOutput: result.llmOutput,
+                generations.push([aggregated]);
+                await runManagers?.[0].handleLLMEnd({
+                    generations,
+                    llmOutput: {},
                 });
             }
-            else {
-                // status === "rejected"
-                await runManagers?.[i]?.handleLLMError(pResult.reason);
-                return Promise.reject(pResult.reason);
+            catch (e) {
+                await runManagers?.[0].handleLLMError(e);
+                throw e;
             }
-        }));
+        }
+        else {
+            // generate results
+            const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
+            // handle results
+            await Promise.all(results.map(async (pResult, i) => {
+                if (pResult.status === "fulfilled") {
+                    const result = pResult.value;
+                    for (const generation of result.generations) {
+                        generation.message.response_metadata = {
+                            ...generation.generationInfo,
+                            ...generation.message.response_metadata,
+                        };
+                    }
+                    if (result.generations.length === 1) {
+                        result.generations[0].message.response_metadata = {
+                            ...result.llmOutput,
+                            ...result.generations[0].message.response_metadata,
+                        };
+                    }
+                    generations[i] = result.generations;
+                    llmOutputs[i] = result.llmOutput;
+                    return runManagers?.[i]?.handleLLMEnd({
+                        generations: [result.generations],
+                        llmOutput: result.llmOutput,
+                    });
+                }
+                else {
+                    // status === "rejected"
+                    await runManagers?.[i]?.handleLLMError(pResult.reason);
+                    return Promise.reject(pResult.reason);
+                }
+            }));
+        }
         // create combined output
         const output = {
             generations,

package/dist/language_models/chat_models.js

@@ -2,6 +2,9 @@ import { AIMessage, HumanMessage, coerceMessageLikeToMessage, } from "../message
 import { RUN_KEY, } from "../outputs.js";
 import { BaseLanguageModel, } from "./base.js";
 import { CallbackManager, } from "../callbacks/manager.js";
+import { isStreamEventsHandler } from "../tracers/event_stream.js";
+import { isLogStreamHandler } from "../tracers/log_stream.js";
+import { concat } from "../utils/stream.js";
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -124,39 +127,76 @@ export class BaseChatModel extends BaseLanguageModel {
             batch_size: 1,
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions.runName);
-        // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
-        // handle results
         const generations = [];
         const llmOutputs = [];
-        await Promise.all(results.map(async (pResult, i) => {
-            if (pResult.status === "fulfilled") {
-                const result = pResult.value;
-                for (const generation of result.generations) {
-                    generation.message.response_metadata = {
-                        ...generation.generationInfo,
-                        ...generation.message.response_metadata,
-                    };
+        // Even if stream is not explicitly called, check if model is implicitly
+        // called from streamEvents() or streamLog() to get all streamed events.
+        // Bail out if _streamResponseChunks not overridden
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find((handler) => {
+            return isStreamEventsHandler(handler) || isLogStreamHandler(handler);
+        });
+        if (hasStreamingHandler &&
+            baseMessages.length === 1 &&
+            this._streamResponseChunks !==
+                BaseChatModel.prototype._streamResponseChunks) {
+            try {
+                const stream = await this._streamResponseChunks(baseMessages[0], parsedOptions, runManagers?.[0]);
+                let aggregated;
+                for await (const chunk of stream) {
+                    if (aggregated === undefined) {
+                        aggregated = chunk;
+                    }
+                    else {
+                        aggregated = concat(aggregated, chunk);
+                    }
                 }
-                if (result.generations.length === 1) {
-                    result.generations[0].message.response_metadata = {
-                        ...result.llmOutput,
-                        ...result.generations[0].message.response_metadata,
-                    };
+                if (aggregated === undefined) {
+                    throw new Error("Received empty response from chat model call.");
                 }
-                generations[i] = result.generations;
-                llmOutputs[i] = result.llmOutput;
-                return runManagers?.[i]?.handleLLMEnd({
-                    generations: [result.generations],
-                    llmOutput: result.llmOutput,
+                generations.push([aggregated]);
+                await runManagers?.[0].handleLLMEnd({
+                    generations,
+                    llmOutput: {},
                 });
             }
-            else {
-                // status === "rejected"
-                await runManagers?.[i]?.handleLLMError(pResult.reason);
-                return Promise.reject(pResult.reason);
+            catch (e) {
+                await runManagers?.[0].handleLLMError(e);
+                throw e;
             }
-        }));
+        }
+        else {
+            // generate results
+            const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
+            // handle results
+            await Promise.all(results.map(async (pResult, i) => {
+                if (pResult.status === "fulfilled") {
+                    const result = pResult.value;
+                    for (const generation of result.generations) {
+                        generation.message.response_metadata = {
+                            ...generation.generationInfo,
+                            ...generation.message.response_metadata,
+                        };
+                    }
+                    if (result.generations.length === 1) {
+                        result.generations[0].message.response_metadata = {
+                            ...result.llmOutput,
+                            ...result.generations[0].message.response_metadata,
+                        };
+                    }
+                    generations[i] = result.generations;
+                    llmOutputs[i] = result.llmOutput;
+                    return runManagers?.[i]?.handleLLMEnd({
+                        generations: [result.generations],
+                        llmOutput: result.llmOutput,
+                    });
+                }
+                else {
+                    // status === "rejected"
+                    await runManagers?.[i]?.handleLLMError(pResult.reason);
+                    return Promise.reject(pResult.reason);
+                }
+            }));
+        }
         // create combined output
         const output = {
             generations,

package/dist/language_models/llms.cjs

@@ -5,6 +5,9 @@ const index_js_1 = require("../messages/index.cjs");
 const outputs_js_1 = require("../outputs.cjs");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_1 = require("./base.cjs");
+const event_stream_js_1 = require("../tracers/event_stream.cjs");
+const log_stream_js_1 = require("../tracers/log_stream.cjs");
+const stream_js_1 = require("../utils/stream.cjs");
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
@@ -133,16 +136,49 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
             batch_size: prompts.length,
         };
         const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        // Even if stream is not explicitly called, check if model is implicitly
+        // called from streamEvents() or streamLog() to get all streamed events.
+        // Bail out if _streamResponseChunks not overridden
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find((handler) => {
+            return (0, event_stream_js_1.isStreamEventsHandler)(handler) || (0, log_stream_js_1.isLogStreamHandler)(handler);
+        });
         let output;
-        try {
-            output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
+        if (hasStreamingHandler &&
+            prompts.length === 1 &&
+            this._streamResponseChunks !== BaseLLM.prototype._streamResponseChunks) {
+            try {
+                const stream = await this._streamResponseChunks(prompts[0], parsedOptions, runManagers?.[0]);
+                let aggregated;
+                for await (const chunk of stream) {
+                    if (aggregated === undefined) {
+                        aggregated = chunk;
+                    }
+                    else {
+                        aggregated = (0, stream_js_1.concat)(aggregated, chunk);
+                    }
+                }
+                if (aggregated === undefined) {
+                    throw new Error("Received empty response from chat model call.");
+                }
+                output = { generations: [[aggregated]], llmOutput: {} };
+                await runManagers?.[0].handleLLMEnd(output);
+            }
+            catch (e) {
+                await runManagers?.[0].handleLLMError(e);
+                throw e;
+            }
         }
-        catch (err) {
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-            throw err;
+        else {
+            try {
+                output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
+            }
+            catch (err) {
+                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+                throw err;
+            }
+            const flattenedOutputs = this._flattenLLMResult(output);
+            await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
         }
-        const flattenedOutputs = this._flattenLLMResult(output);
-        await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
         const runIds = runManagers?.map((manager) => manager.runId) || undefined;
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that

package/dist/language_models/llms.js

@@ -2,6 +2,9 @@ import { AIMessage, getBufferString, } from "../messages/index.js";
 import { RUN_KEY, GenerationChunk, } from "../outputs.js";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { BaseLanguageModel, } from "./base.js";
+import { isStreamEventsHandler } from "../tracers/event_stream.js";
+import { isLogStreamHandler } from "../tracers/log_stream.js";
+import { concat } from "../utils/stream.js";
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
@@ -130,16 +133,49 @@ export class BaseLLM extends BaseLanguageModel {
             batch_size: prompts.length,
         };
         const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, handledOptions.runId, undefined, extra, undefined, undefined, handledOptions?.runName);
+        // Even if stream is not explicitly called, check if model is implicitly
+        // called from streamEvents() or streamLog() to get all streamed events.
+        // Bail out if _streamResponseChunks not overridden
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find((handler) => {
+            return isStreamEventsHandler(handler) || isLogStreamHandler(handler);
+        });
         let output;
-        try {
-            output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
+        if (hasStreamingHandler &&
+            prompts.length === 1 &&
+            this._streamResponseChunks !== BaseLLM.prototype._streamResponseChunks) {
+            try {
+                const stream = await this._streamResponseChunks(prompts[0], parsedOptions, runManagers?.[0]);
+                let aggregated;
+                for await (const chunk of stream) {
+                    if (aggregated === undefined) {
+                        aggregated = chunk;
+                    }
+                    else {
+                        aggregated = concat(aggregated, chunk);
+                    }
+                }
+                if (aggregated === undefined) {
+                    throw new Error("Received empty response from chat model call.");
+                }
+                output = { generations: [[aggregated]], llmOutput: {} };
+                await runManagers?.[0].handleLLMEnd(output);
+            }
+            catch (e) {
+                await runManagers?.[0].handleLLMError(e);
+                throw e;
+            }
         }
-        catch (err) {
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-            throw err;
+        else {
+            try {
+                output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
+            }
+            catch (err) {
+                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+                throw err;
+            }
+            const flattenedOutputs = this._flattenLLMResult(output);
+            await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
         }
-        const flattenedOutputs = this._flattenLLMResult(output);
-        await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
         const runIds = runManagers?.map((manager) => manager.runId) || undefined;
         // This defines RUN_KEY as a non-enumerable property on the output object
         // so that it is not serialized when the output is stringified, and so that

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");
@@ -287,14 +288,12 @@ class Runnable extends serializable_js_1.Serializable {
             const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
             delete config.runId;
             runManager = pipe.setup;
-            const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
-            const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
+            const streamEventsHandler = runManager?.handlers.find(event_stream_js_1.isStreamEventsHandler);
             let iterator = pipe.output;
             if (streamEventsHandler !== undefined && runManager !== undefined) {
                 iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
             }
-            const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
-            const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
+            const streamLogHandler = runManager?.handlers.find(log_stream_js_1.isLogStreamHandler);
             if (streamLogHandler !== undefined && runManager !== undefined) {
                 iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
             }
@@ -1387,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.
  */
@@ -1395,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,
@@ -1408,6 +1474,7 @@ class RunnableLambda extends Runnable {
             writable: true,
             value: void 0
         });
+        assertNonTraceableFunction(fields.func);
         this.func = fields.func;
     }
     static from(func) {
@@ -1455,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) {
@@ -1533,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>;