@langchain/core 0.3.22 → 0.3.24-rc.0

package/dist/callbacks/base.cjs

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCallbackHandler = void 0;
+exports.isBaseCallbackHandler = exports.BaseCallbackHandler = exports.callbackHandlerPrefersStreaming = void 0;
 const uuid = __importStar(require("uuid"));
 const serializable_js_1 = require("../load/serializable.cjs");
 const env_js_1 = require("../utils/env.cjs");
@@ -34,6 +34,10 @@ const env_js_1 = require("../utils/env.cjs");
  */
 class BaseCallbackHandlerMethodsClass {
 }
+function callbackHandlerPrefersStreaming(x) {
+    return "lc_prefer_streaming" in x && x.lc_prefer_streaming;
+}
+exports.callbackHandlerPrefersStreaming = callbackHandlerPrefersStreaming;
 /**
  * Abstract base class for creating callback handlers in the LangChain
  * framework. It provides a set of optional methods that can be overridden
@@ -166,3 +170,11 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
     }
 }
 exports.BaseCallbackHandler = BaseCallbackHandler;
+const isBaseCallbackHandler = (x) => {
+    const callbackHandler = x;
+    return (callbackHandler !== undefined &&
+        typeof callbackHandler.copy === "function" &&
+        typeof callbackHandler.name === "string" &&
+        typeof callbackHandler.awaitHandlers === "boolean");
+};
+exports.isBaseCallbackHandler = isBaseCallbackHandler;

package/dist/callbacks/base.d.ts

@@ -137,6 +137,15 @@ declare abstract class BaseCallbackHandlerMethodsClass {
  * @interface
  */
 export type CallbackHandlerMethods = BaseCallbackHandlerMethodsClass;
+/**
+ * Interface for handlers that can indicate a preference for streaming responses.
+ * When implemented, this allows the handler to signal whether it prefers to receive
+ * streaming responses from language models rather than complete responses.
+ */
+export interface CallbackHandlerPrefersStreaming {
+    readonly lc_prefer_streaming: boolean;
+}
+export declare function callbackHandlerPrefersStreaming(x: BaseCallbackHandler): unknown;
 /**
  * Abstract base class for creating callback handlers in the LangChain
  * framework. It provides a set of optional methods that can be overridden
@@ -276,4 +285,5 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[] | undefined, metadata?: Record<string, any> | undefined): any;
     };
 }
+export declare const isBaseCallbackHandler: (x: unknown) => boolean;
 export {};

package/dist/callbacks/base.js

@@ -8,6 +8,9 @@ import { getEnvironmentVariable } from "../utils/env.js";
  */
 class BaseCallbackHandlerMethodsClass {
 }
+export function callbackHandlerPrefersStreaming(x) {
+    return "lc_prefer_streaming" in x && x.lc_prefer_streaming;
+}
 /**
  * Abstract base class for creating callback handlers in the LangChain
  * framework. It provides a set of optional methods that can be overridden
@@ -139,3 +142,10 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
         return new Handler();
     }
 }
+export const isBaseCallbackHandler = (x) => {
+    const callbackHandler = x;
+    return (callbackHandler !== undefined &&
+        typeof callbackHandler.copy === "function" &&
+        typeof callbackHandler.name === "string" &&
+        typeof callbackHandler.awaitHandlers === "boolean");
+};

package/dist/callbacks/manager.cjs

@@ -10,6 +10,7 @@ const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
 const callbacks_js_1 = require("../utils/callbacks.cjs");
 const base_js_2 = require("../tracers/base.cjs");
+const context_js_1 = require("../singletons/async_local_storage/context.cjs");
 function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};
@@ -765,6 +766,26 @@ class CallbackManager extends BaseCallbackManager {
                 }
             }
         }
+        for (const { contextVar, inheritable = true, handlerClass, envVar, } of (0, context_js_1._getConfigureHooks)()) {
+            const createIfNotInContext = envVar && (0, env_js_1.getEnvironmentVariable)(envVar) === "true" && handlerClass;
+            let handler;
+            const contextVarValue = contextVar !== undefined ? (0, context_js_1.getContextVariable)(contextVar) : undefined;
+            if (contextVarValue && (0, base_js_1.isBaseCallbackHandler)(contextVarValue)) {
+                handler = contextVarValue;
+            }
+            else if (createIfNotInContext) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                handler = new handlerClass({});
+            }
+            if (handler !== undefined) {
+                if (!callbackManager) {
+                    callbackManager = new CallbackManager();
+                }
+                if (!callbackManager.handlers.some((h) => h.name === handler.name)) {
+                    callbackManager.addHandler(handler, inheritable);
+                }
+            }
+        }
         if (inheritableTags || localTags) {
             if (callbackManager) {
                 callbackManager.addTags(inheritableTags ?? []);

package/dist/callbacks/manager.js

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from "uuid";
-import { BaseCallbackHandler, } from "./base.js";
+import { BaseCallbackHandler, isBaseCallbackHandler, } from "./base.js";
 import { ConsoleCallbackHandler } from "../tracers/console.js";
 import { getBufferString } from "../messages/utils.js";
 import { getEnvironmentVariable } from "../utils/env.js";
@@ -7,6 +7,7 @@ import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
 import { isTracingEnabled } from "../utils/callbacks.js";
 import { isBaseTracer } from "../tracers/base.js";
+import { getContextVariable, _getConfigureHooks, } from "../singletons/async_local_storage/context.js";
 export function parseCallbackConfigArg(arg) {
     if (!arg) {
         return {};
@@ -755,6 +756,26 @@ export class CallbackManager extends BaseCallbackManager {
                 }
             }
         }
+        for (const { contextVar, inheritable = true, handlerClass, envVar, } of _getConfigureHooks()) {
+            const createIfNotInContext = envVar && getEnvironmentVariable(envVar) === "true" && handlerClass;
+            let handler;
+            const contextVarValue = contextVar !== undefined ? getContextVariable(contextVar) : undefined;
+            if (contextVarValue && isBaseCallbackHandler(contextVarValue)) {
+                handler = contextVarValue;
+            }
+            else if (createIfNotInContext) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                handler = new handlerClass({});
+            }
+            if (handler !== undefined) {
+                if (!callbackManager) {
+                    callbackManager = new CallbackManager();
+                }
+                if (!callbackManager.handlers.some((h) => h.name === handler.name)) {
+                    callbackManager.addHandler(handler, inheritable);
+                }
+            }
+        }
         if (inheritableTags || localTags) {
             if (callbackManager) {
                 callbackManager.addTags(inheritableTags ?? []);

package/dist/context.cjs

@@ -1,128 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContextVariable = exports.setContextVariable = void 0;
 /* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
-const node_async_hooks_1 = require("node:async_hooks");
-const langsmith_1 = require("langsmith");
-const run_trees_1 = require("langsmith/run_trees");
-const index_js_1 = require("./singletons/index.cjs");
-index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
-/**
- * Set a context variable. Context variables are scoped to any
- * child runnables called by the current runnable, or globally if set outside
- * of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- * @param value The value to set.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function setContextVariable(name, value) {
-    const runTree = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    const contextVars = { ...runTree?.[index_js_1._CONTEXT_VARIABLES_KEY] };
-    contextVars[name] = value;
-    let newValue = {};
-    if ((0, run_trees_1.isRunTree)(runTree)) {
-        newValue = new langsmith_1.RunTree(runTree);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    newValue[index_js_1._CONTEXT_VARIABLES_KEY] = contextVars;
-    index_js_1.AsyncLocalStorageProviderSingleton.getInstance().enterWith(newValue);
-}
-exports.setContextVariable = setContextVariable;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigureHook = exports.setContextVariable = exports.getContextVariable = void 0;
 /**
- * Get the value of a previously set context variable. Context variables
- * are scoped to any child runnables called by the current runnable,
- * or globally if set outside of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
+ * This file exists as a convenient public entrypoint for functionality
+ * related to context variables.
  *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
+ * Because it automatically initializes AsyncLocalStorage, internal
+ * functionality SHOULD NEVER import from this file outside of tests.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function getContextVariable(name) {
-    const runTree = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    return runTree?.[index_js_1._CONTEXT_VARIABLES_KEY]?.[name];
-}
-exports.getContextVariable = getContextVariable;
+const node_async_hooks_1 = require("node:async_hooks");
+const index_js_1 = require("./singletons/index.cjs");
+const context_js_1 = require("./singletons/async_local_storage/context.cjs");
+Object.defineProperty(exports, "getContextVariable", { enumerable: true, get: function () { return context_js_1.getContextVariable; } });
+Object.defineProperty(exports, "setContextVariable", { enumerable: true, get: function () { return context_js_1.setContextVariable; } });
+Object.defineProperty(exports, "registerConfigureHook", { enumerable: true, get: function () { return context_js_1.registerConfigureHook; } });
+index_js_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());

package/dist/context.d.ts

@@ -1,101 +1,2 @@
-/**
- * Set a context variable. Context variables are scoped to any
- * child runnables called by the current runnable, or globally if set outside
- * of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- * @param value The value to set.
- */
-export declare function setContextVariable<T>(name: PropertyKey, value: T): void;
-/**
- * Get the value of a previously set context variable. Context variables
- * are scoped to any child runnables called by the current runnable,
- * or globally if set outside of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- */
-export declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
+import { getContextVariable, setContextVariable, type ConfigureHook, registerConfigureHook } from "./singletons/async_local_storage/context.js";
+export { getContextVariable, setContextVariable, registerConfigureHook, type ConfigureHook, };

package/dist/context.js

@@ -1,123 +1,13 @@
 /* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
-import { AsyncLocalStorage } from "node:async_hooks";
-import { RunTree } from "langsmith";
-import { isRunTree } from "langsmith/run_trees";
-import { _CONTEXT_VARIABLES_KEY, AsyncLocalStorageProviderSingleton, } from "./singletons/index.js";
-AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
 /**
- * Set a context variable. Context variables are scoped to any
- * child runnables called by the current runnable, or globally if set outside
- * of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
+ * This file exists as a convenient public entrypoint for functionality
+ * related to context variables.
  *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- * @param value The value to set.
+ * Because it automatically initializes AsyncLocalStorage, internal
+ * functionality SHOULD NEVER import from this file outside of tests.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function setContextVariable(name, value) {
-    const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };
-    contextVars[name] = value;
-    let newValue = {};
-    if (isRunTree(runTree)) {
-        newValue = new RunTree(runTree);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    newValue[_CONTEXT_VARIABLES_KEY] = contextVars;
-    AsyncLocalStorageProviderSingleton.getInstance().enterWith(newValue);
-}
-/**
- * Get the value of a previously set context variable. Context variables
- * are scoped to any child runnables called by the current runnable,
- * or globally if set outside of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getContextVariable(name) {
-    const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
-}
+import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorageProviderSingleton } from "./singletons/index.js";
+import { getContextVariable, setContextVariable, registerConfigureHook, } from "./singletons/async_local_storage/context.js";
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+export { getContextVariable, setContextVariable, registerConfigureHook, };

package/dist/language_models/chat_models.cjs

@@ -7,11 +7,10 @@ const outputs_js_1 = require("../outputs.cjs");
 const base_js_1 = require("./base.cjs");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const base_js_2 = require("../runnables/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");
 const passthrough_js_1 = require("../runnables/passthrough.cjs");
 const is_zod_schema_js_1 = require("../utils/types/is_zod_schema.cjs");
+const base_js_3 = require("../callbacks/base.cjs");
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -161,9 +160,7 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         // 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);
-        });
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find(base_js_3.callbackHandlerPrefersStreaming);
         if (hasStreamingHandler &&
             baseMessages.length === 1 &&
             this._streamResponseChunks !==

package/dist/language_models/chat_models.js

@@ -4,11 +4,10 @@ import { RUN_KEY, } from "../outputs.js";
 import { BaseLanguageModel, } from "./base.js";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { RunnableLambda, RunnableSequence, } from "../runnables/base.js";
-import { isStreamEventsHandler } from "../tracers/event_stream.js";
-import { isLogStreamHandler } from "../tracers/log_stream.js";
 import { concat } from "../utils/stream.js";
 import { RunnablePassthrough } from "../runnables/passthrough.js";
 import { isZodSchema } from "../utils/types/is_zod_schema.js";
+import { callbackHandlerPrefersStreaming } from "../callbacks/base.js";
 /**
  * Creates a transform stream for encoding chat message chunks.
  * @deprecated Use {@link BytesOutputParser} instead
@@ -157,9 +156,7 @@ export class BaseChatModel extends BaseLanguageModel {
         // 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);
-        });
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersStreaming);
         if (hasStreamingHandler &&
             baseMessages.length === 1 &&
             this._streamResponseChunks !==

package/dist/language_models/llms.cjs

@@ -5,9 +5,8 @@ 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");
+const base_js_2 = require("../callbacks/base.cjs");
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
@@ -138,9 +137,7 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         // 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);
-        });
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find(base_js_2.callbackHandlerPrefersStreaming);
         let output;
         if (hasStreamingHandler &&
             prompts.length === 1 &&

package/dist/language_models/llms.js

@@ -2,9 +2,8 @@ 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";
+import { callbackHandlerPrefersStreaming } from "../callbacks/base.js";
 /**
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
@@ -135,9 +134,7 @@ export class BaseLLM extends BaseLanguageModel {
         // 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);
-        });
+        const hasStreamingHandler = !!runManagers?.[0].handlers.find(callbackHandlerPrefersStreaming);
         let output;
         if (hasStreamingHandler &&
             prompts.length === 1 &&

package/dist/messages/tool.cjs

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isToolMessageChunk = exports.isToolMessage = exports.defaultToolCallParser = exports.ToolMessageChunk = exports.ToolMessage = void 0;
+exports.isToolMessageChunk = exports.isToolMessage = exports.defaultToolCallParser = exports.ToolMessageChunk = exports.ToolMessage = exports.isDirectToolOutput = void 0;
 const base_js_1 = require("./base.cjs");
+function isDirectToolOutput(x) {
+    return (x != null &&
+        typeof x === "object" &&
+        "lc_direct_tool_output" in x &&
+        x.lc_direct_tool_output === true);
+}
+exports.isDirectToolOutput = isDirectToolOutput;
 /**
  * Represents a tool message in a conversation.
  */
@@ -19,6 +26,12 @@ class ToolMessage extends base_js_1.BaseMessage {
             fields = { content: fields, name, tool_call_id: tool_call_id };
         }
         super(fields);
+        Object.defineProperty(this, "lc_direct_tool_output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         /**
          * Status of the tool invocation.
          * @version 0.2.19