@langchain/core 0.1.63 → 0.2.0

package/dist/indexing/record_manager.d.ts

@@ -0,0 +1,64 @@
+import { Serializable } from "../load/serializable.js";
+export declare const UUIDV5_NAMESPACE = "10f90ea3-90a4-4962-bf75-83a0f3c1c62a";
+export type UpdateOptions = {
+    groupIds?: (string | null)[];
+    timeAtLeast?: number;
+};
+export type ListKeyOptions = {
+    before?: number;
+    after?: number;
+    groupIds?: (string | null)[];
+    limit?: number;
+};
+export interface RecordManagerInterface {
+    /**
+     * Creates schema in the record manager.
+     * @returns Promise
+     */
+    createSchema(): Promise<void>;
+    /**
+     * Returns current time from the record manager.
+     * @returns Current time
+     */
+    getTime(): Promise<number>;
+    /**
+     * Updates keys in the record manager.
+     * @param keys List of keys to update
+     * @param groupIds List of groupIds to update
+     * @param timeAtLeast Update only if current time is at least this value
+     * @returns Promise
+     * @throws Error if timeAtLeast is provided and current time is less than timeAtLeast
+     * @throws Error if number of keys does not match number of groupIds
+     */
+    update(keys: string[], updateOptions: UpdateOptions): Promise<void>;
+    /**
+     * Checks if keys exist in the record manager.
+     * @param keys List of keys to check
+     * @returns List of booleans indicating if key exists in same order as provided keys
+     */
+    exists(keys: string[]): Promise<boolean[]>;
+    /**
+     * Lists keys from the record manager.
+     * @param before List keys before this timestamp
+     * @param after List keys after this timestamp
+     * @param groupIds List keys with these groupIds
+     * @param limit Limit the number of keys returned
+     * @returns List of keys
+     *
+     */
+    listKeys(options: ListKeyOptions): Promise<string[]>;
+    /**
+     * Deletes keys from the record manager.
+     * @param keys List of keys to delete
+     */
+    deleteKeys(keys: string[]): Promise<void>;
+}
+export declare abstract class RecordManager extends Serializable implements RecordManagerInterface {
+    lc_namespace: string[];
+    abstract createSchema(): Promise<void>;
+    abstract getTime(): Promise<number>;
+    abstract update(keys: string[], updateOptions?: UpdateOptions): Promise<void>;
+    abstract exists(keys: string[]): Promise<boolean[]>;
+    abstract listKeys(options?: ListKeyOptions): Promise<string[]>;
+    abstract deleteKeys(keys: string[]): Promise<void>;
+}

package/dist/indexing/record_manager.js

@@ -0,0 +1,14 @@
+import { Serializable } from "../load/serializable.js";
+// Arbitrary value, used for generating namespaced UUIDs.
+export const UUIDV5_NAMESPACE = "10f90ea3-90a4-4962-bf75-83a0f3c1c62a";
+export class RecordManager extends Serializable {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "recordmanagers"]
+        });
+    }
+}

package/dist/language_models/chat_models.cjs

@@ -70,7 +70,11 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
             const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
-            const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+            const inheritableMetadata = {
+                ...runnableConfig.metadata,
+                ...this.getLsParams(callOptions),
+            };
+            const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
                 invocation_params: this?.invocationParams(callOptions),
@@ -103,11 +107,21 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
             })));
         }
     }
+    getLsParams(options) {
+        return {
+            ls_model_type: "chat",
+            ls_stop: options.stop,
+        };
+    }
     /** @ignore */
     async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
@@ -164,8 +178,12 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
     }
     async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),

package/dist/language_models/chat_models.d.ts

@@ -35,6 +35,14 @@ export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
  * @returns A TransformStream instance that encodes chat message chunks.
  */
 export declare function createChatMessageChunkEncoderStream(): TransformStream<BaseMessageChunk, any>;
+export type LangSmithParams = {
+    ls_provider?: string;
+    ls_model_name?: string;
+    ls_model_type: "chat";
+    ls_temperature?: number;
+    ls_max_tokens?: number;
+    ls_stop?: Array<string>;
+};
 interface ChatModelGenerateCachedParameters<T extends BaseChatModel<CallOptions>, CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> {
     messages: BaseMessageLike[][];
     cache: BaseCache<Generation[]>;
@@ -70,6 +78,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
     _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
+    protected getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
     _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {

package/dist/language_models/chat_models.js

@@ -66,7 +66,11 @@ export class BaseChatModel extends BaseLanguageModel {
             const prompt = BaseChatModel._convertInputToPromptValue(input);
             const messages = prompt.toChatMessages();
             const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
-            const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+            const inheritableMetadata = {
+                ...runnableConfig.metadata,
+                ...this.getLsParams(callOptions),
+            };
+            const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
             const extra = {
                 options: callOptions,
                 invocation_params: this?.invocationParams(callOptions),
@@ -99,11 +103,21 @@ export class BaseChatModel extends BaseLanguageModel {
             })));
         }
     }
+    getLsParams(options) {
+        return {
+            ls_model_type: "chat",
+            ls_stop: options.stop,
+        };
+    }
     /** @ignore */
     async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
@@ -160,8 +174,12 @@ export class BaseChatModel extends BaseLanguageModel {
     }
     async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        const inheritableMetadata = {
+            ...handledOptions.metadata,
+            ...this.getLsParams(parsedOptions),
+        };
         // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, inheritableMetadata, this.metadata, { verbose: this.verbose });
         const extra = {
             options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),

package/dist/runnables/base.cjs

@@ -168,7 +168,11 @@ class Runnable extends serializable_js_1.Serializable {
     async stream(input, options) {
         // Buffer the first streamed chunk to allow for initial errors
         // to surface immediately.
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this._streamIterator(input, (0, config_js_1.ensureConfig)(options)));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this._streamIterator(input, config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -450,13 +454,13 @@ class Runnable extends serializable_js_1.Serializable {
             await runnableStreamConsumePromise;
         }
     }
-    async *streamEvents(input, options, streamOptions) {
+    streamEvents(input, options, streamOptions) {
+        const stream = this._streamEvents(input, options, streamOptions);
         if (options.encoding === "text/event-stream") {
-            const stream = await this._streamEvents(input, options, streamOptions);
-            yield* (0, wrappers_js_1.convertToHttpEventStream)(stream);
+            return (0, wrappers_js_1.convertToHttpEventStream)(stream);
         }
         else {
-            yield* this._streamEvents(input, options, streamOptions);
+            return stream_js_1.IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
     async *_streamEvents(input, options, streamOptions) {
@@ -740,11 +744,16 @@ class RunnableBinding extends Runnable {
     generator, options) {
         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((0, config_js_1.ensureConfig)(options), this.kwargs)),
-            version: options.version,
-        }, streamOptions);
+    streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            yield* outerThis.bound.streamEvents(input, {
+                ...(await outerThis._mergeConfig((0, config_js_1.ensureConfig)(options), outerThis.kwargs)),
+                version: options.version,
+            }, streamOptions);
+        };
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(generator());
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1292,7 +1301,11 @@ class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1460,7 +1473,11 @@ class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1664,7 +1681,11 @@ class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1732,7 +1753,11 @@ class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = (0, config_js_1.ensureConfig)(options);
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }

package/dist/runnables/base.d.ts

@@ -198,11 +198,11 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
     _streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
@@ -263,11 +263,11 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
     static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.

package/dist/runnables/base.js

@@ -161,7 +161,11 @@ export class Runnable extends Serializable {
     async stream(input, options) {
         // Buffer the first streamed chunk to allow for initial errors
         // to surface immediately.
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this._streamIterator(input, ensureConfig(options)));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this._streamIterator(input, config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -443,13 +447,13 @@ export class Runnable extends Serializable {
             await runnableStreamConsumePromise;
         }
     }
-    async *streamEvents(input, options, streamOptions) {
+    streamEvents(input, options, streamOptions) {
+        const stream = this._streamEvents(input, options, streamOptions);
         if (options.encoding === "text/event-stream") {
-            const stream = await this._streamEvents(input, options, streamOptions);
-            yield* convertToHttpEventStream(stream);
+            return convertToHttpEventStream(stream);
         }
         else {
-            yield* this._streamEvents(input, options, streamOptions);
+            return IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
     async *_streamEvents(input, options, streamOptions) {
@@ -732,11 +736,16 @@ export class RunnableBinding extends Runnable {
     generator, options) {
         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(ensureConfig(options), this.kwargs)),
-            version: options.version,
-        }, streamOptions);
+    streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        const generator = async function* () {
+            yield* outerThis.bound.streamEvents(input, {
+                ...(await outerThis._mergeConfig(ensureConfig(options), outerThis.kwargs)),
+                version: options.version,
+            }, streamOptions);
+        };
+        return IterableReadableStream.fromAsyncGenerator(generator());
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1280,7 +1289,11 @@ export class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1447,7 +1460,11 @@ export class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1647,7 +1664,11 @@ export class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
@@ -1714,7 +1735,11 @@ export class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        const config = ensureConfig(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: this.transform(generator(), config),
+            config,
+        });
         await wrappedGenerator.setup;
         return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }

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") {
+            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 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";
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose"> | undefined): AsyncGenerator<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<Uint8Array>;
+    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
 }
 export {};