@langchain/core 0.2.0-rc.0 → 0.2.0

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") {
+            throw new Error(`Only version "v1" 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/singletons/index.cjs

@@ -7,7 +7,7 @@ class MockAsyncLocalStorage {
         return undefined;
     }
     run(_store, callback) {
-        callback();
+        return callback();
     }
 }
 exports.MockAsyncLocalStorage = MockAsyncLocalStorage;

package/dist/singletons/index.d.ts

@@ -1,10 +1,10 @@
 export interface AsyncLocalStorageInterface {
     getStore: () => any | undefined;
-    run: (store: any, callback: () => any) => any;
+    run: <T>(store: any, callback: () => T) => T;
 }
 export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
     getStore(): any;
-    run(_store: any, callback: () => any): any;
+    run<T>(_store: any, callback: () => T): T;
 }
 declare class AsyncLocalStorageProvider {
     private asyncLocalStorage;

package/dist/singletons/index.js

@@ -4,7 +4,7 @@ export class MockAsyncLocalStorage {
         return undefined;
     }
     run(_store, callback) {
-        callback();
+        return callback();
     }
 }
 class AsyncLocalStorageProvider {

package/dist/utils/stream.cjs

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0;
+// Make this a type to override ReadableStream's async iterator type in case
+// the popular web-streams-polyfill is imported - the supplied types
+const index_js_1 = require("../singletons/index.cjs");
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -167,7 +170,7 @@ function concat(first, second) {
 }
 exports.concat = concat;
 class AsyncGeneratorWithSetup {
-    constructor(generator, startSetup) {
+    constructor(params) {
         Object.defineProperty(this, "generator", {
             enumerable: true,
             configurable: true,
@@ -180,6 +183,12 @@ class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -192,19 +201,23 @@ class AsyncGeneratorWithSetup {
             writable: true,
             value: false
         });
-        this.generator = generator;
+        this.generator = params.generator;
+        this.config = params.config;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            this.firstResult = generator.next();
-            if (startSetup) {
-                this.firstResult.then(startSetup).then(resolve, reject);
-            }
-            else {
-                this.firstResult.then((_result) => resolve(undefined), reject);
-            }
+            const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+            void storage.run(params.config, async () => {
+                this.firstResult = params.generator.next();
+                if (params.startSetup) {
+                    this.firstResult.then(params.startSetup).then(resolve, reject);
+                }
+                else {
+                    this.firstResult.then((_result) => resolve(undefined), reject);
+                }
+            });
         });
     }
     async next(...args) {
@@ -212,7 +225,10 @@ class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return this.generator.next(...args);
+        const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
+        return storage.run(this.config, async () => {
+            return this.generator.next(...args);
+        });
     }
     async return(value) {
         return this.generator.return(value);
@@ -226,7 +242,7 @@ class AsyncGeneratorWithSetup {
 }
 exports.AsyncGeneratorWithSetup = AsyncGeneratorWithSetup;
 async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
-    const gen = new AsyncGeneratorWithSetup(generator, startSetup);
+    const gen = new AsyncGeneratorWithSetup({ generator, startSetup });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };
 }

package/dist/utils/stream.d.ts

@@ -14,9 +14,14 @@ export declare function concat<T extends Array<any> | string | number | Record<s
 export declare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn = unknown, TNext = unknown> implements AsyncGenerator<T, TReturn, TNext> {
     private generator;
     setup: Promise<S>;
+    config?: unknown;
     private firstResult;
     private firstResultUsed;
-    constructor(generator: AsyncGenerator<T>, startSetup?: () => Promise<S>);
+    constructor(params: {
+        generator: AsyncGenerator<T>;
+        startSetup?: () => Promise<S>;
+        config?: unknown;
+    });
     next(...args: [] | [TNext]): Promise<IteratorResult<T>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
     throw(e: Error): Promise<IteratorResult<T>>;

package/dist/utils/stream.js

@@ -1,3 +1,6 @@
+// Make this a type to override ReadableStream's async iterator type in case
+// the popular web-streams-polyfill is imported - the supplied types
+import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 /*
  * Support async iterator syntax for ReadableStreams in all environments.
  * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
@@ -161,7 +164,7 @@ export function concat(first, second) {
     }
 }
 export class AsyncGeneratorWithSetup {
-    constructor(generator, startSetup) {
+    constructor(params) {
         Object.defineProperty(this, "generator", {
             enumerable: true,
             configurable: true,
@@ -174,6 +177,12 @@ export class AsyncGeneratorWithSetup {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "firstResult", {
             enumerable: true,
             configurable: true,
@@ -186,19 +195,23 @@ export class AsyncGeneratorWithSetup {
             writable: true,
             value: false
         });
-        this.generator = generator;
+        this.generator = params.generator;
+        this.config = params.config;
         // setup is a promise that resolves only after the first iterator value
         // is available. this is useful when setup of several piped generators
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            this.firstResult = generator.next();
-            if (startSetup) {
-                this.firstResult.then(startSetup).then(resolve, reject);
-            }
-            else {
-                this.firstResult.then((_result) => resolve(undefined), reject);
-            }
+            const storage = AsyncLocalStorageProviderSingleton.getInstance();
+            void storage.run(params.config, async () => {
+                this.firstResult = params.generator.next();
+                if (params.startSetup) {
+                    this.firstResult.then(params.startSetup).then(resolve, reject);
+                }
+                else {
+                    this.firstResult.then((_result) => resolve(undefined), reject);
+                }
+            });
         });
     }
     async next(...args) {
@@ -206,7 +219,10 @@ export class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return this.generator.next(...args);
+        const storage = AsyncLocalStorageProviderSingleton.getInstance();
+        return storage.run(this.config, async () => {
+            return this.generator.next(...args);
+        });
     }
     async return(value) {
         return this.generator.return(value);
@@ -219,7 +235,7 @@ export class AsyncGeneratorWithSetup {
     }
 }
 export async function pipeGeneratorWithSetup(to, generator, startSetup, ...args) {
-    const gen = new AsyncGeneratorWithSetup(generator, startSetup);
+    const gen = new AsyncGeneratorWithSetup({ generator, startSetup });
     const setup = await gen.setup;
     return { output: to(gen, setup, ...args), setup };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.0-rc.0",
+  "version": "0.2.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -43,7 +43,7 @@
     "ansi-styles": "^5.0.0",
     "camelcase": "6",
     "decamelize": "1.2.0",
-    "js-tiktoken": "^1.0.8",
+    "js-tiktoken": "^1.0.12",
     "langsmith": "~0.1.7",
     "ml-distance": "^4.0.0",
     "mustache": "^4.2.0",