@langchain/core 0.2.0-rc.0 → 0.2.1

package/dist/runnables/iter.js

@@ -0,0 +1,39 @@
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
+export function isIterator(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.iterator] === "function" &&
+        // avoid detecting array/set as iterator
+        typeof thing.next === "function");
+}
+export function isAsyncIterable(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        typeof thing[Symbol.asyncIterator] ===
+            "function");
+}
+export function* consumeIteratorInContext(context, iter) {
+    const storage = AsyncLocalStorageProviderSingleton.getInstance();
+    while (true) {
+        const { value, done } = storage.run(context, iter.next.bind(iter));
+        if (done) {
+            break;
+        }
+        else {
+            yield value;
+        }
+    }
+}
+export async function* consumeAsyncIterableInContext(context, iter) {
+    const storage = AsyncLocalStorageProviderSingleton.getInstance();
+    const iterator = iter[Symbol.asyncIterator]();
+    while (true) {
+        const { value, done } = await storage.run(context, iterator.next.bind(iter));
+        if (done) {
+            break;
+        }
+        else {
+            yield value;
+        }
+    }
+}

package/dist/runnables/passthrough.cjs

@@ -30,6 +30,7 @@ const config_js_1 = require("./config.cjs");
  * );
  * ```
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class RunnablePassthrough extends base_js_1.Runnable {
     static lc_name() {
         return "RunnablePassthrough";

package/dist/runnables/passthrough.d.ts

@@ -27,7 +27,7 @@ type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((i
  * );
  * ```
  */
-export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
+export declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {
     static lc_name(): string;
     lc_namespace: string[];
     lc_serializable: boolean;

package/dist/runnables/passthrough.js

@@ -27,6 +27,7 @@ import { ensureConfig } from "./config.js";
  * );
  * ```
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class RunnablePassthrough extends Runnable {
     static lc_name() {
         return "RunnablePassthrough";

package/dist/runnables/remote.cjs

@@ -405,58 +405,70 @@ class RemoteRunnable extends base_js_1.Runnable {
         }
         await runManager?.handleChainEnd(runLog?.state.final_output);
     }
-    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);
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        // 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 events = [];
-        try {
-            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()}`);
+    _streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            const [config, kwargs] = outerThis._separateRunnableConfigFromCallOptions(options);
+            const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+            // 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 events = [];
+            try {
+                const response = await outerThis.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));
+                    const event = {
+                        event: chunk.event,
+                        name: chunk.name,
+                        run_id: chunk.run_id,
+                        tags: chunk.tags,
+                        metadata: chunk.metadata,
+                        data: chunk.data,
+                    };
+                    yield event;
+                    events.push(event);
+                }
             }
-            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));
-                const event = {
-                    event: chunk.event,
-                    name: chunk.name,
-                    run_id: chunk.run_id,
-                    tags: chunk.tags,
-                    metadata: chunk.metadata,
-                    data: chunk.data,
-                };
-                yield event;
-                events.push(event);
+            catch (err) {
+                await runManager?.handleChainError(err);
+                throw err;
             }
+            await runManager?.handleChainEnd(events);
+        };
+        return generator();
+    }
+    streamEvents(input, options, streamOptions) {
+        if (options.version !== "v1" && options.version !== "v2") {
+            throw new Error(`Only versions "v1" and "v2" of the events schema is currently supported.`);
         }
-        catch (err) {
-            await runManager?.handleChainError(err);
-            throw err;
+        if (options.encoding !== undefined) {
+            throw new Error("Special encodings are not supported for this runnable.");
         }
-        await runManager?.handleChainEnd(events);
+        const eventStream = this._streamEvents(input, options, streamOptions);
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(eventStream);
     }
 }
 exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -2,6 +2,7 @@ import { Runnable, RunnableBatchOptions } from "./base.js";
 import { type RunnableConfig } from "./config.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { RunLogPatch, type LogStreamCallbackHandlerInput, type StreamEvent } from "../tracers/log_stream.js";
+import { IterableReadableStream } from "../utils/stream.js";
 type RemoteRunnableOptions = {
     timeout?: number;
     headers?: Record<string, unknown>;
@@ -27,12 +28,15 @@ export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends Run
     batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     _streamIterator(input: RunInput, options?: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+    _streamEvents(input: RunInput, options: Partial<CallOptions> & {
+        version: "v1" | "v2";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose"> | undefined): AsyncGenerator<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+        version: "v1" | "v2";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
 }
 export {};

package/dist/runnables/remote.js

@@ -6,7 +6,7 @@ import { RunLogPatch, RunLog, } 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 { convertEventStreamToIterableReadableDataStream } from "../utils/event_source_parse.js";
-import { concat } from "../utils/stream.js";
+import { IterableReadableStream, concat } from "../utils/stream.js";
 function isSuperset(set, subset) {
     for (const elem of subset) {
         if (!set.has(elem)) {
@@ -402,57 +402,69 @@ export class RemoteRunnable extends Runnable {
         }
         await runManager?.handleChainEnd(runLog?.state.final_output);
     }
-    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);
-        const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        // 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 events = [];
-        try {
-            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()}`);
+    _streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            const [config, kwargs] = outerThis._separateRunnableConfigFromCallOptions(options);
+            const callbackManager_ = await getCallbackManagerForConfig(options);
+            const runManager = await callbackManager_?.handleChainStart(outerThis.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
+            // 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 events = [];
+            try {
+                const response = await outerThis.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));
+                    const event = {
+                        event: chunk.event,
+                        name: chunk.name,
+                        run_id: chunk.run_id,
+                        tags: chunk.tags,
+                        metadata: chunk.metadata,
+                        data: chunk.data,
+                    };
+                    yield event;
+                    events.push(event);
+                }
             }
-            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));
-                const event = {
-                    event: chunk.event,
-                    name: chunk.name,
-                    run_id: chunk.run_id,
-                    tags: chunk.tags,
-                    metadata: chunk.metadata,
-                    data: chunk.data,
-                };
-                yield event;
-                events.push(event);
+            catch (err) {
+                await runManager?.handleChainError(err);
+                throw err;
             }
+            await runManager?.handleChainEnd(events);
+        };
+        return generator();
+    }
+    streamEvents(input, options, streamOptions) {
+        if (options.version !== "v1" && options.version !== "v2") {
+            throw new Error(`Only versions "v1" and "v2" of the events schema is currently supported.`);
         }
-        catch (err) {
-            await runManager?.handleChainError(err);
-            throw err;
+        if (options.encoding !== undefined) {
+            throw new Error("Special encodings are not supported for this runnable.");
         }
-        await runManager?.handleChainEnd(events);
+        const eventStream = this._streamEvents(input, options, streamOptions);
+        return IterableReadableStream.fromAsyncGenerator(eventStream);
     }
 }

package/dist/runnables/tests/runnable.test.d.ts

@@ -0,0 +1 @@
+export {};