@langchain/core 0.1.48 → 0.1.50

package/dist/runnables/base.cjs

@@ -730,28 +730,28 @@ class RunnableBinding extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
+        return this.bound.invoke(input, await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(individualOption, this.kwargs)))
-            : await this._mergeConfig(options, this.kwargs);
+            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig((0, config_js_1.ensureConfig)(individualOption), this.kwargs)))
+            : await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, await this._mergeConfig(options, this.kwargs));
+        yield* this.bound._streamIterator(input, await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
     async stream(input, options) {
-        return this.bound.stream(input, await this._mergeConfig(options, this.kwargs));
+        return this.bound.stream(input, await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
+        yield* this.bound.transform(generator, await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs));
     }
     async *streamEvents(input, options, streamOptions) {
         yield* this.bound.streamEvents(input, {
-            ...(await this._mergeConfig(options, this.kwargs)),
+            ...(await this._mergeConfig((0, config_js_1.ensureConfig)(options), this.kwargs)),
             version: options.version,
         }, streamOptions);
     }

package/dist/runnables/base.js

@@ -722,28 +722,28 @@ export class RunnableBinding extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
+        return this.bound.invoke(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(individualOption, this.kwargs)))
-            : await this._mergeConfig(options, this.kwargs);
+            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(ensureConfig(individualOption), this.kwargs)))
+            : await this._mergeConfig(ensureConfig(options), this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, await this._mergeConfig(options, this.kwargs));
+        yield* this.bound._streamIterator(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
     async stream(input, options) {
-        return this.bound.stream(input, await this._mergeConfig(options, this.kwargs));
+        return this.bound.stream(input, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
+        yield* this.bound.transform(generator, await this._mergeConfig(ensureConfig(options), this.kwargs));
     }
     async *streamEvents(input, options, streamOptions) {
         yield* this.bound.streamEvents(input, {
-            ...(await this._mergeConfig(options, this.kwargs)),
+            ...(await this._mergeConfig(ensureConfig(options), this.kwargs)),
             version: options.version,
         }, streamOptions);
     }

package/dist/runnables/config.cjs

@@ -9,15 +9,17 @@ async function getCallbackManagerForConfig(config) {
 }
 exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
 function mergeConfigs(...configs) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const copy = ensureConfig();
+    // We do not want to call ensureConfig on the empty state here as this may cause
+    // double loading of callbacks if async local storage is being used.
+    const copy = {};
     for (const options of configs.filter((c) => !!c)) {
         for (const key of Object.keys(options)) {
             if (key === "metadata") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "tags") {
-                copy[key] = [...new Set(copy[key].concat(options[key] ?? []))];
+                const baseKeys = copy[key] ?? [];
+                copy[key] = [...new Set(baseKeys.concat(options[key] ?? []))];
             }
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };

package/dist/runnables/config.js

@@ -5,15 +5,17 @@ export async function getCallbackManagerForConfig(config) {
     return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 export function mergeConfigs(...configs) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const copy = ensureConfig();
+    // We do not want to call ensureConfig on the empty state here as this may cause
+    // double loading of callbacks if async local storage is being used.
+    const copy = {};
     for (const options of configs.filter((c) => !!c)) {
         for (const key of Object.keys(options)) {
             if (key === "metadata") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "tags") {
-                copy[key] = [...new Set(copy[key].concat(options[key] ?? []))];
+                const baseKeys = copy[key] ?? [];
+                copy[key] = [...new Set(baseKeys.concat(options[key] ?? []))];
             }
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };

package/dist/runnables/remote.cjs

@@ -268,6 +268,9 @@ class RemoteRunnable extends base_js_1.Runnable {
             config: removeCallbacks(config),
             kwargs: kwargs ?? {},
         });
+        if (!response.ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         return revive((await response.json()).output);
     }
     async _batch(inputs, options, _, batchOptions) {
@@ -286,6 +289,9 @@ class RemoteRunnable extends base_js_1.Runnable {
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
         });
+        if (!response.ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         const body = await response.json();
         if (!body.output)
             throw new Error("Invalid response from remote runnable");
@@ -315,21 +321,13 @@ class RemoteRunnable extends base_js_1.Runnable {
         if (!body) {
             throw new Error("Could not begin remote stream. Please check the given URL and try again.");
         }
-        const stream = new ReadableStream({
-            async start(controller) {
-                const enqueueLine = (0, event_source_parse_js_1.getMessages)((msg) => {
-                    if (msg.data)
-                        controller.enqueue(deserialize(msg.data));
-                });
-                const onLine = (line, fieldLength, flush) => {
-                    enqueueLine(line, fieldLength, flush);
-                    if (flush)
-                        controller.close();
-                };
-                await (0, event_source_parse_js_1.getBytes)(body, (0, event_source_parse_js_1.getLines)(onLine));
-            },
-        });
-        return stream_js_1.IterableReadableStream.fromReadableStream(stream);
+        const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+        async function* wrapper() {
+            for await (const chunk of runnableStream) {
+                yield deserialize(chunk);
+            }
+        }
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrapper());
     }
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
@@ -365,7 +363,10 @@ class RemoteRunnable extends base_js_1.Runnable {
             ...camelCaseStreamOptions,
             diff: false,
         });
-        const { body } = response;
+        const { body, ok } = response;
+        if (!ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         if (!body) {
             throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
         }
@@ -375,5 +376,46 @@ class RemoteRunnable extends base_js_1.Runnable {
             yield new log_stream_js_1.RunLogPatch({ ops: chunk.ops });
         }
     }
+    async *streamEvents(input, options, streamOptions) {
+        if (options?.version !== "v1") {
+            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        }
+        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        // The type is in camelCase but the API only accepts snake_case.
+        const camelCaseStreamOptions = {
+            include_names: streamOptions?.includeNames,
+            include_types: streamOptions?.includeTypes,
+            include_tags: streamOptions?.includeTags,
+            exclude_names: streamOptions?.excludeNames,
+            exclude_types: streamOptions?.excludeTypes,
+            exclude_tags: streamOptions?.excludeTags,
+        };
+        const response = await this.post("/stream_events", {
+            input,
+            config: removeCallbacks(config),
+            kwargs,
+            ...camelCaseStreamOptions,
+            diff: false,
+        });
+        const { body, ok } = response;
+        if (!ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
+        if (!body) {
+            throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+        }
+        const runnableStream = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+        for await (const log of runnableStream) {
+            const chunk = revive(JSON.parse(log));
+            yield {
+                event: chunk.event,
+                name: chunk.name,
+                run_id: chunk.id,
+                tags: chunk.tags,
+                metadata: chunk.metadata,
+                data: chunk.data,
+            };
+        }
+    }
 }
 exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -1,7 +1,7 @@
 import { Runnable, RunnableBatchOptions } from "./base.js";
 import type { RunnableConfig } from "./config.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
-import { RunLogPatch, type LogStreamCallbackHandlerInput } from "../tracers/log_stream.js";
+import { RunLogPatch, type LogStreamCallbackHandlerInput, type StreamEvent } from "../tracers/log_stream.js";
 import { IterableReadableStream } from "../utils/stream.js";
 type RemoteRunnableOptions = {
     timeout?: number;
@@ -27,5 +27,8 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+    streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
 }
 export {};

package/dist/runnables/remote.js

@@ -4,7 +4,7 @@ import { ChatPromptValue, StringPromptValue } from "../prompt_values.js";
 import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
 import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, isBaseMessage, } from "../messages/index.js";
 import { GenerationChunk, ChatGenerationChunk, RUN_KEY } from "../outputs.js";
-import { getBytes, getLines, getMessages, convertEventStreamToIterableReadableDataStream, } from "../utils/event_source_parse.js";
+import { convertEventStreamToIterableReadableDataStream } from "../utils/event_source_parse.js";
 import { IterableReadableStream } from "../utils/stream.js";
 function isSuperset(set, subset) {
     for (const elem of subset) {
@@ -265,6 +265,9 @@ export class RemoteRunnable extends Runnable {
             config: removeCallbacks(config),
             kwargs: kwargs ?? {},
         });
+        if (!response.ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         return revive((await response.json()).output);
     }
     async _batch(inputs, options, _, batchOptions) {
@@ -283,6 +286,9 @@ export class RemoteRunnable extends Runnable {
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
         });
+        if (!response.ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         const body = await response.json();
         if (!body.output)
             throw new Error("Invalid response from remote runnable");
@@ -312,21 +318,13 @@ export class RemoteRunnable extends Runnable {
         if (!body) {
             throw new Error("Could not begin remote stream. Please check the given URL and try again.");
         }
-        const stream = new ReadableStream({
-            async start(controller) {
-                const enqueueLine = getMessages((msg) => {
-                    if (msg.data)
-                        controller.enqueue(deserialize(msg.data));
-                });
-                const onLine = (line, fieldLength, flush) => {
-                    enqueueLine(line, fieldLength, flush);
-                    if (flush)
-                        controller.close();
-                };
-                await getBytes(body, getLines(onLine));
-            },
-        });
-        return IterableReadableStream.fromReadableStream(stream);
+        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
+        async function* wrapper() {
+            for await (const chunk of runnableStream) {
+                yield deserialize(chunk);
+            }
+        }
+        return IterableReadableStream.fromAsyncGenerator(wrapper());
     }
     async *streamLog(input, options, streamOptions) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
@@ -362,7 +360,10 @@ export class RemoteRunnable extends Runnable {
             ...camelCaseStreamOptions,
             diff: false,
         });
-        const { body } = response;
+        const { body, ok } = response;
+        if (!ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
         if (!body) {
             throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
         }
@@ -372,4 +373,45 @@ export class RemoteRunnable extends Runnable {
             yield new RunLogPatch({ ops: chunk.ops });
         }
     }
+    async *streamEvents(input, options, streamOptions) {
+        if (options?.version !== "v1") {
+            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+        }
+        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        // The type is in camelCase but the API only accepts snake_case.
+        const camelCaseStreamOptions = {
+            include_names: streamOptions?.includeNames,
+            include_types: streamOptions?.includeTypes,
+            include_tags: streamOptions?.includeTags,
+            exclude_names: streamOptions?.excludeNames,
+            exclude_types: streamOptions?.excludeTypes,
+            exclude_tags: streamOptions?.excludeTags,
+        };
+        const response = await this.post("/stream_events", {
+            input,
+            config: removeCallbacks(config),
+            kwargs,
+            ...camelCaseStreamOptions,
+            diff: false,
+        });
+        const { body, ok } = response;
+        if (!ok) {
+            throw new Error(`${response.status} Error: ${await response.text()}`);
+        }
+        if (!body) {
+            throw new Error("Could not begin remote stream events. Please check the given URL and try again.");
+        }
+        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
+        for await (const log of runnableStream) {
+            const chunk = revive(JSON.parse(log));
+            yield {
+                event: chunk.event,
+                name: chunk.name,
+                run_id: chunk.id,
+                tags: chunk.tags,
+                metadata: chunk.metadata,
+                data: chunk.data,
+            };
+        }
+    }
 }

package/dist/utils/event_source_parse.cjs

@@ -184,12 +184,20 @@ function newMessage() {
         retry: undefined,
     };
 }
-function convertEventStreamToIterableReadableDataStream(stream) {
+function convertEventStreamToIterableReadableDataStream(stream, onMetadataEvent) {
     const dataStream = new ReadableStream({
         async start(controller) {
             const enqueueLine = getMessages((msg) => {
-                if (msg.data)
-                    controller.enqueue(msg.data);
+                if (msg.event === "error") {
+                    throw new Error(msg.data ?? "Unspecified event streaming error.");
+                }
+                else if (msg.event === "metadata") {
+                    onMetadataEvent?.(msg);
+                }
+                else {
+                    if (msg.data)
+                        controller.enqueue(msg.data);
+                }
             });
             const onLine = (line, fieldLength, flush) => {
                 enqueueLine(line, fieldLength, flush);

package/dist/utils/event_source_parse.d.ts

@@ -36,4 +36,4 @@ export declare function getLines(onLine: (line: Uint8Array, fieldLength: number,
  * @returns A function that should be called for each incoming line buffer.
  */
 export declare function getMessages(onMessage?: (msg: EventSourceMessage) => void, onId?: (id: string) => void, onRetry?: (retry: number) => void): (line: Uint8Array, fieldLength: number, flush?: boolean) => void;
-export declare function convertEventStreamToIterableReadableDataStream(stream: ReadableStream): IterableReadableStream<any>;
+export declare function convertEventStreamToIterableReadableDataStream(stream: ReadableStream, onMetadataEvent?: (e: unknown) => unknown): IterableReadableStream<any>;

package/dist/utils/event_source_parse.js

@@ -178,12 +178,20 @@ function newMessage() {
         retry: undefined,
     };
 }
-export function convertEventStreamToIterableReadableDataStream(stream) {
+export function convertEventStreamToIterableReadableDataStream(stream, onMetadataEvent) {
     const dataStream = new ReadableStream({
         async start(controller) {
             const enqueueLine = getMessages((msg) => {
-                if (msg.data)
-                    controller.enqueue(msg.data);
+                if (msg.event === "error") {
+                    throw new Error(msg.data ?? "Unspecified event streaming error.");
+                }
+                else if (msg.event === "metadata") {
+                    onMetadataEvent?.(msg);
+                }
+                else {
+                    if (msg.data)
+                        controller.enqueue(msg.data);
+                }
             });
             const onLine = (line, fieldLength, flush) => {
                 enqueueLine(line, fieldLength, flush);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -14,7 +14,8 @@
   },
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/langchain-core/",
   "scripts": {
-    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn run build:scripts",
+    "build": "yarn build:deps && yarn clean && yarn build:esm && yarn build:cjs && yarn run build:scripts",
+    "build:deps": "yarn turbo:command build --filter=@langchain/scripts",
     "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/ && rimraf dist/tests dist/**/tests",
     "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && yarn move-cjs-to-dist && rimraf dist-cjs",
     "build:watch": "yarn create-entrypoints && tsc --outDir dist/ --watch",