@langchain/core 0.3.23 → 0.3.24

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.isBaseCallbackHandler = 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

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

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

package/dist/callbacks/manager.cjs

@@ -766,18 +766,6 @@ class CallbackManager extends BaseCallbackManager {
                 }
             }
         }
-        if (inheritableTags || localTags) {
-            if (callbackManager) {
-                callbackManager.addTags(inheritableTags ?? []);
-                callbackManager.addTags(localTags ?? [], false);
-            }
-        }
-        if (inheritableMetadata || localMetadata) {
-            if (callbackManager) {
-                callbackManager.addMetadata(inheritableMetadata ?? {});
-                callbackManager.addMetadata(localMetadata ?? {}, false);
-            }
-        }
         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;
@@ -790,11 +778,26 @@ class CallbackManager extends BaseCallbackManager {
                 handler = new handlerClass({});
             }
             if (handler !== undefined) {
-                if (!callbackManager?.handlers.some((h) => h.name === handler.name)) {
-                    callbackManager?.addHandler(handler, inheritable);
+                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 ?? []);
+                callbackManager.addTags(localTags ?? [], false);
+            }
+        }
+        if (inheritableMetadata || localMetadata) {
+            if (callbackManager) {
+                callbackManager.addMetadata(inheritableMetadata ?? {});
+                callbackManager.addMetadata(localMetadata ?? {}, false);
+            }
+        }
         return callbackManager;
     }
 }

package/dist/callbacks/manager.js

@@ -756,18 +756,6 @@ export class CallbackManager extends BaseCallbackManager {
                 }
             }
         }
-        if (inheritableTags || localTags) {
-            if (callbackManager) {
-                callbackManager.addTags(inheritableTags ?? []);
-                callbackManager.addTags(localTags ?? [], false);
-            }
-        }
-        if (inheritableMetadata || localMetadata) {
-            if (callbackManager) {
-                callbackManager.addMetadata(inheritableMetadata ?? {});
-                callbackManager.addMetadata(localMetadata ?? {}, false);
-            }
-        }
         for (const { contextVar, inheritable = true, handlerClass, envVar, } of _getConfigureHooks()) {
             const createIfNotInContext = envVar && getEnvironmentVariable(envVar) === "true" && handlerClass;
             let handler;
@@ -780,11 +768,26 @@ export class CallbackManager extends BaseCallbackManager {
                 handler = new handlerClass({});
             }
             if (handler !== undefined) {
-                if (!callbackManager?.handlers.some((h) => h.name === handler.name)) {
-                    callbackManager?.addHandler(handler, inheritable);
+                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 ?? []);
+                callbackManager.addTags(localTags ?? [], false);
+            }
+        }
+        if (inheritableMetadata || localMetadata) {
+            if (callbackManager) {
+                callbackManager.addMetadata(inheritableMetadata ?? {});
+                callbackManager.addMetadata(localMetadata ?? {}, false);
+            }
+        }
         return callbackManager;
     }
 }

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/tracers/event_stream.cjs

@@ -106,6 +106,12 @@ class EventStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: "event_stream_tracer"
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.autoClose = fields?.autoClose ?? true;
         this.includeNames = fields?.includeNames;
         this.includeTypes = fields?.includeTypes;

package/dist/tracers/event_stream.d.ts

@@ -1,5 +1,5 @@
 import { BaseTracer, type Run } from "./base.js";
-import { BaseCallbackHandler, BaseCallbackHandlerInput } from "../callbacks/base.js";
+import { BaseCallbackHandler, BaseCallbackHandlerInput, CallbackHandlerPrefersStreaming } from "../callbacks/base.js";
 import { IterableReadableStream } from "../utils/stream.js";
 /**
  * Data associated with a StreamEvent.
@@ -101,7 +101,7 @@ export declare const isStreamEventsHandler: (handler: BaseCallbackHandler) => ha
  * handler that logs the execution of runs and emits `RunLog` instances to a
  * `RunLogStream`.
  */
-export declare class EventStreamCallbackHandler extends BaseTracer {
+export declare class EventStreamCallbackHandler extends BaseTracer implements CallbackHandlerPrefersStreaming {
     protected autoClose: boolean;
     protected includeNames?: string[];
     protected includeTypes?: string[];
@@ -115,6 +115,7 @@ export declare class EventStreamCallbackHandler extends BaseTracer {
     writer: WritableStreamDefaultWriter;
     receiveStream: IterableReadableStream<StreamEvent>;
     name: string;
+    lc_prefer_streaming: boolean;
     constructor(fields?: EventStreamCallbackHandlerInput);
     [Symbol.asyncIterator](): IterableReadableStream<StreamEvent>;
     protected persistRun(_run: Run): Promise<void>;

package/dist/tracers/event_stream.js

@@ -102,6 +102,12 @@ export class EventStreamCallbackHandler extends BaseTracer {
             writable: true,
             value: "event_stream_tracer"
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.autoClose = fields?.autoClose ?? true;
         this.includeNames = fields?.includeNames;
         this.includeTypes = fields?.includeTypes;

package/dist/tracers/log_stream.cjs

@@ -213,6 +213,12 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: "log_stream_tracer"
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.autoClose = fields?.autoClose ?? true;
         this.includeNames = fields?.includeNames;
         this.includeTypes = fields?.includeTypes;

package/dist/tracers/log_stream.d.ts

@@ -1,6 +1,6 @@
 import { type Operation as JSONPatchOperation } from "../utils/fast-json-patch/index.js";
 import { BaseTracer, type Run } from "./base.js";
-import { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields } from "../callbacks/base.js";
+import { BaseCallbackHandler, BaseCallbackHandlerInput, CallbackHandlerPrefersStreaming, HandleLLMNewTokenCallbackFields } from "../callbacks/base.js";
 import { IterableReadableStream } from "../utils/stream.js";
 import type { StreamEvent, StreamEventData } from "./event_stream.js";
 export type { StreamEvent, StreamEventData };
@@ -90,7 +90,7 @@ export declare const isLogStreamHandler: (handler: BaseCallbackHandler) => handl
  * handler that logs the execution of runs and emits `RunLog` instances to a
  * `RunLogStream`.
  */
-export declare class LogStreamCallbackHandler extends BaseTracer {
+export declare class LogStreamCallbackHandler extends BaseTracer implements CallbackHandlerPrefersStreaming {
     protected autoClose: boolean;
     protected includeNames?: string[];
     protected includeTypes?: string[];
@@ -106,6 +106,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     writer: WritableStreamDefaultWriter;
     receiveStream: IterableReadableStream<RunLogPatch>;
     name: string;
+    lc_prefer_streaming: boolean;
     constructor(fields?: LogStreamCallbackHandlerInput);
     [Symbol.asyncIterator](): IterableReadableStream<RunLogPatch>;
     protected persistRun(_run: Run): Promise<void>;

package/dist/tracers/log_stream.js

@@ -207,6 +207,12 @@ export class LogStreamCallbackHandler extends BaseTracer {
             writable: true,
             value: "log_stream_tracer"
         });
+        Object.defineProperty(this, "lc_prefer_streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.autoClose = fields?.autoClose ?? true;
         this.includeNames = fields?.includeNames;
         this.includeTypes = fields?.includeTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {