@langchain/core 0.1.49 → 0.1.51

package/dist/runnables/base.cjs

@@ -165,16 +165,22 @@ class Runnable extends serializable_js_1.Serializable {
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
-    _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = (0, config_js_1.ensureConfig)({
-            callbacks: options.callbacks,
-            tags: options.tags,
-            metadata: options.metadata,
-            runName: options.runName,
-            configurable: options.configurable,
-            recursionLimit: options.recursionLimit,
-            maxConcurrency: options.maxConcurrency,
-        });
+    _separateRunnableConfigFromCallOptions(options) {
+        let runnableConfig;
+        if (options === undefined) {
+            runnableConfig = (0, config_js_1.ensureConfig)(options);
+        }
+        else {
+            runnableConfig = (0, config_js_1.ensureConfig)({
+                callbacks: options.callbacks,
+                tags: options.tags,
+                metadata: options.metadata,
+                runName: options.runName,
+                configurable: options.configurable,
+                recursionLimit: options.recursionLimit,
+                maxConcurrency: options.maxConcurrency,
+            });
+        }
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;

package/dist/runnables/base.js

@@ -158,16 +158,22 @@ export class Runnable extends Serializable {
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
-    _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = ensureConfig({
-            callbacks: options.callbacks,
-            tags: options.tags,
-            metadata: options.metadata,
-            runName: options.runName,
-            configurable: options.configurable,
-            recursionLimit: options.recursionLimit,
-            maxConcurrency: options.maxConcurrency,
-        });
+    _separateRunnableConfigFromCallOptions(options) {
+        let runnableConfig;
+        if (options === undefined) {
+            runnableConfig = ensureConfig(options);
+        }
+        else {
+            runnableConfig = ensureConfig({
+                callbacks: options.callbacks,
+                tags: options.tags,
+                metadata: options.metadata,
+                runName: options.runName,
+                configurable: options.configurable,
+                recursionLimit: options.recursionLimit,
+                maxConcurrency: options.maxConcurrency,
+            });
+        }
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;

package/dist/runnables/config.cjs

@@ -84,6 +84,9 @@ exports.mergeConfigs = mergeConfigs;
 const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
+ *
+ * Note: To make sure async local storage loading works correctly, this
+ * should not be called with a default or prepopulated config argument.
  */
 function ensureConfig(config) {
     const loadedConfig = config ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();

package/dist/runnables/config.d.ts

@@ -17,6 +17,9 @@ export declare function getCallbackManagerForConfig(config?: RunnableConfig): Pr
 export declare function mergeConfigs<CallOptions extends RunnableConfig>(...configs: (CallOptions | RunnableConfig | undefined | null)[]): Partial<CallOptions>;
 /**
  * Ensure that a passed config is an object with all required keys present.
+ *
+ * Note: To make sure async local storage loading works correctly, this
+ * should not be called with a default or prepopulated config argument.
  */
 export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): CallOptions;
 /**

package/dist/runnables/config.js

@@ -79,6 +79,9 @@ export function mergeConfigs(...configs) {
 const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
+ *
+ * Note: To make sure async local storage loading works correctly, this
+ * should not be called with a default or prepopulated config argument.
  */
 export function ensureConfig(config) {
     const loadedConfig = config ?? AsyncLocalStorageProviderSingleton.getInstance().getStore();

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.run_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.run_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.49",
+  "version": "0.1.51",
   "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",