@langchain/core 0.2.1 → 0.2.3

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) {

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) {

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

@@ -287,14 +287,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);
             }
@@ -482,7 +480,7 @@ class Runnable extends serializable_js_1.Serializable {
     async *_streamEventsV2(input, options, streamOptions) {
         const eventStreamer = new event_stream_js_1.EventStreamCallbackHandler({
             ...streamOptions,
-            autoClose: false,
+            autoClose: true,
         });
         const config = (0, config_js_1.ensureConfig)(options);
         const runId = config.runId ?? (0, uuid_1.v4)();
@@ -504,16 +502,11 @@ class Runnable extends serializable_js_1.Serializable {
         // add each chunk to the output stream
         const outerThis = this;
         async function consumeRunnableStream() {
-            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.writer.close();
+            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
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();

package/dist/runnables/base.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
 import { CallbackManager, } from "../callbacks/manager.js";
-import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_stream.js";
-import { EventStreamCallbackHandler, } from "../tracers/event_stream.js";
+import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } from "../tracers/log_stream.js";
+import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
@@ -280,13 +280,11 @@ export class Runnable extends Serializable {
             const pipe = await 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);
             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);
             if (streamLogHandler !== undefined && runManager !== undefined) {
                 iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
@@ -475,7 +473,7 @@ export class Runnable extends Serializable {
     async *_streamEventsV2(input, options, streamOptions) {
         const eventStreamer = new EventStreamCallbackHandler({
             ...streamOptions,
-            autoClose: false,
+            autoClose: true,
         });
         const config = ensureConfig(options);
         const runId = config.runId ?? uuidv4();
@@ -497,16 +495,11 @@ export class Runnable extends Serializable {
         // add each chunk to the output stream
         const outerThis = this;
         async function consumeRunnableStream() {
-            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.writer.close();
+            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
             }
         }
         const runnableStreamConsumePromise = consumeRunnableStream();