@langchain/core 0.1.1 → 0.1.2-rc.0

package/dist/language_models/chat_models.cjs

@@ -146,6 +146,68 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         });
         return output;
     }
+    async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
+        const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
+        // 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 extra = {
+            options: parsedOptions,
+            invocation_params: this?.invocationParams(parsedOptions),
+            batch_size: 1,
+            cached: true,
+        };
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        // generate results
+        const missingPromptIndices = [];
+        const results = await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {
+            // Join all content into one string for the prompt index
+            const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
+            const result = await cache.lookup(prompt, llmStringKey);
+            if (result == null) {
+                missingPromptIndices.push(index);
+            }
+            return result;
+        }));
+        // Map run managers to the results before filtering out null results
+        // Null results are just absent from the cache.
+        const cachedResults = results
+            .map((result, index) => ({ result, runManager: runManagers?.[index] }))
+            .filter(({ result }) => (result.status === "fulfilled" && result.value != null) ||
+            result.status === "rejected");
+        // Handle results and call run managers
+        const generations = [];
+        await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
+            if (promiseResult.status === "fulfilled") {
+                const result = promiseResult.value;
+                generations[i] = result;
+                if (result.length) {
+                    await runManager?.handleLLMNewToken(result[0].text);
+                }
+                return runManager?.handleLLMEnd({
+                    generations: [result],
+                });
+            }
+            else {
+                // status === "rejected"
+                await runManager?.handleLLMError(promiseResult.reason);
+                return Promise.reject(promiseResult.reason);
+            }
+        }));
+        const output = {
+            generations,
+            missingPromptIndices,
+        };
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, outputs_js_1.RUN_KEY, {
+            value: runManagers
+                ? { runIds: runManagers?.map((manager) => manager.runId) }
+                : undefined,
+            configurable: true,
+        });
+        return output;
+    }
     /**
      * Generates chat based on the input messages.
      * @param messages An array of arrays of BaseMessage instances.
@@ -170,16 +232,13 @@ class BaseChatModel extends base_js_1.BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(baseMessages.map(async (baseMessage, index) => {
-            // Join all content into one string for the prompt index
-            const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
-            const result = await cache.lookup(prompt, llmStringKey);
-            if (!result) {
-                missingPromptIndices.push(index);
-            }
-            return result;
-        }));
+        const { generations, missingPromptIndices } = await this._generateCached({
+            messages: baseMessages,
+            cache,
+            llmStringKey,
+            parsedOptions: callOptions,
+            handledOptions: runnableConfig,
+        });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
             const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig);

package/dist/language_models/chat_models.d.ts

@@ -1,9 +1,10 @@
-import { BaseMessage, BaseMessageChunk, BaseMessageLike } from "../messages/index.js";
+import { type BaseMessage, BaseMessageChunk, type BaseMessageLike } from "../messages/index.js";
 import { BasePromptValue } from "../prompt_values.js";
-import { LLMResult, ChatGenerationChunk, ChatResult } from "../outputs.js";
+import { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from "../outputs.js";
 import { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from "./base.js";
-import { CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
-import { RunnableConfig } from "../runnables/config.js";
+import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
+import type { RunnableConfig } from "../runnables/config.js";
+import type { BaseCache } from "../caches.js";
 /**
  * Represents a serialized chat model.
  */
@@ -32,6 +33,13 @@ export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
  * @returns A TransformStream instance that encodes chat message chunks.
  */
 export declare function createChatMessageChunkEncoderStream(): TransformStream<BaseMessageChunk, any>;
+interface ChatModelGenerateCachedParameters<T extends BaseChatModel<CallOptions>, CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> {
+    messages: BaseMessageLike[][];
+    cache: BaseCache<Generation[]>;
+    llmStringKey: string;
+    parsedOptions: T["ParsedCallOptions"];
+    handledOptions: RunnableConfig;
+}
 /**
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
@@ -53,6 +61,9 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<BaseMessageChunk>;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
+    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {
+        missingPromptIndices: number[];
+    }>;
     /**
      * Generates chat based on the input messages.
      * @param messages An array of arrays of BaseMessage instances.
@@ -122,3 +133,4 @@ export declare abstract class SimpleChatModel<CallOptions extends BaseChatModelC
     abstract _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
+export {};

package/dist/language_models/chat_models.js

@@ -142,6 +142,68 @@ export class BaseChatModel extends BaseLanguageModel {
         });
         return output;
     }
+    async _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }) {
+        const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        // 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 extra = {
+            options: parsedOptions,
+            invocation_params: this?.invocationParams(parsedOptions),
+            batch_size: 1,
+            cached: true,
+        };
+        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
+        // generate results
+        const missingPromptIndices = [];
+        const results = await Promise.allSettled(baseMessages.map(async (baseMessage, index) => {
+            // Join all content into one string for the prompt index
+            const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
+            const result = await cache.lookup(prompt, llmStringKey);
+            if (result == null) {
+                missingPromptIndices.push(index);
+            }
+            return result;
+        }));
+        // Map run managers to the results before filtering out null results
+        // Null results are just absent from the cache.
+        const cachedResults = results
+            .map((result, index) => ({ result, runManager: runManagers?.[index] }))
+            .filter(({ result }) => (result.status === "fulfilled" && result.value != null) ||
+            result.status === "rejected");
+        // Handle results and call run managers
+        const generations = [];
+        await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
+            if (promiseResult.status === "fulfilled") {
+                const result = promiseResult.value;
+                generations[i] = result;
+                if (result.length) {
+                    await runManager?.handleLLMNewToken(result[0].text);
+                }
+                return runManager?.handleLLMEnd({
+                    generations: [result],
+                });
+            }
+            else {
+                // status === "rejected"
+                await runManager?.handleLLMError(promiseResult.reason);
+                return Promise.reject(promiseResult.reason);
+            }
+        }));
+        const output = {
+            generations,
+            missingPromptIndices,
+        };
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, RUN_KEY, {
+            value: runManagers
+                ? { runIds: runManagers?.map((manager) => manager.runId) }
+                : undefined,
+            configurable: true,
+        });
+        return output;
+    }
     /**
      * Generates chat based on the input messages.
      * @param messages An array of arrays of BaseMessage instances.
@@ -166,16 +228,13 @@ export class BaseChatModel extends BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(baseMessages.map(async (baseMessage, index) => {
-            // Join all content into one string for the prompt index
-            const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
-            const result = await cache.lookup(prompt, llmStringKey);
-            if (!result) {
-                missingPromptIndices.push(index);
-            }
-            return result;
-        }));
+        const { generations, missingPromptIndices } = await this._generateCached({
+            messages: baseMessages,
+            cache,
+            llmStringKey,
+            parsedOptions: callOptions,
+            handledOptions: runnableConfig,
+        });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
             const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig);

package/dist/language_models/llms.cjs

@@ -153,6 +153,64 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         });
         return output;
     }
+    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }) {
+        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const extra = {
+            options: parsedOptions,
+            invocation_params: this?.invocationParams(parsedOptions),
+            batch_size: prompts.length,
+            cached: true,
+        };
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        // generate results
+        const missingPromptIndices = [];
+        const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
+            const result = await cache.lookup(prompt, llmStringKey);
+            if (result == null) {
+                missingPromptIndices.push(index);
+            }
+            return result;
+        }));
+        // Map run managers to the results before filtering out null results
+        // Null results are just absent from the cache.
+        const cachedResults = results
+            .map((result, index) => ({ result, runManager: runManagers?.[index] }))
+            .filter(({ result }) => (result.status === "fulfilled" && result.value != null) ||
+            result.status === "rejected");
+        // Handle results and call run managers
+        const generations = [];
+        await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
+            if (promiseResult.status === "fulfilled") {
+                const result = promiseResult.value;
+                generations[i] = result;
+                if (result.length) {
+                    await runManager?.handleLLMNewToken(result[0].text);
+                }
+                return runManager?.handleLLMEnd({
+                    generations: [result],
+                });
+            }
+            else {
+                // status === "rejected"
+                await runManager?.handleLLMError(promiseResult.reason);
+                return Promise.reject(promiseResult.reason);
+            }
+        }));
+        const output = {
+            generations,
+            missingPromptIndices,
+        };
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, outputs_js_1.RUN_KEY, {
+            value: runManagers
+                ? { runIds: runManagers?.map((manager) => manager.runId) }
+                : undefined,
+            configurable: true,
+        });
+        return output;
+    }
     /**
      * Run the LLM on the given prompts and input, handling caching.
      */
@@ -174,14 +232,13 @@ class BaseLLM extends base_js_1.BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(prompts.map(async (prompt, index) => {
-            const result = await cache.lookup(prompt, llmStringKey);
-            if (!result) {
-                missingPromptIndices.push(index);
-            }
-            return result;
-        }));
+        const { generations, missingPromptIndices } = await this._generateCached({
+            prompts,
+            cache,
+            llmStringKey,
+            parsedOptions: callOptions,
+            handledOptions: runnableConfig,
+        });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
             const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig);

package/dist/language_models/llms.d.ts

@@ -1,9 +1,10 @@
-import { BaseMessage } from "../messages/index.js";
-import { BasePromptValue } from "../prompt_values.js";
-import { LLMResult, GenerationChunk } from "../outputs.js";
-import { BaseCallbackConfig, CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
+import { type BaseMessage } from "../messages/index.js";
+import type { BasePromptValue } from "../prompt_values.js";
+import { type LLMResult, type Generation, GenerationChunk } from "../outputs.js";
+import { type BaseCallbackConfig, type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
 import { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from "./base.js";
-import { RunnableConfig } from "../runnables/config.js";
+import type { RunnableConfig } from "../runnables/config.js";
+import type { BaseCache } from "../caches.js";
 export type SerializedLLM = {
     _model: string;
     _type: string;
@@ -16,6 +17,13 @@ export interface BaseLLMParams extends BaseLanguageModelParams {
 }
 export interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {
 }
+interface LLMGenerateCachedParameters<T extends BaseLLM<CallOptions>, CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> {
+    prompts: string[];
+    cache: BaseCache<Generation[]>;
+    llmStringKey: string;
+    parsedOptions: T["ParsedCallOptions"];
+    handledOptions: RunnableConfig;
+}
 /**
  * LLM Wrapper. Provides an {@link call} (an {@link generate}) function that takes in a prompt (or prompts) and returns a string.
  */
@@ -55,6 +63,9 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
     _flattenLLMResult(llmResult: LLMResult): LLMResult[];
     /** @ignore */
     _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig): Promise<LLMResult>;
+    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }: LLMGenerateCachedParameters<typeof this>): Promise<LLMResult & {
+        missingPromptIndices: number[];
+    }>;
     /**
      * Run the LLM on the given prompts and input, handling caching.
      */
@@ -110,3 +121,4 @@ export declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseL
     abstract _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
     _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
 }
+export {};

package/dist/language_models/llms.js

@@ -1,5 +1,5 @@
-import { AIMessage, getBufferString } from "../messages/index.js";
-import { RUN_KEY, GenerationChunk } from "../outputs.js";
+import { AIMessage, getBufferString, } from "../messages/index.js";
+import { RUN_KEY, GenerationChunk, } from "../outputs.js";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { BaseLanguageModel, } from "./base.js";
 /**
@@ -150,6 +150,64 @@ export class BaseLLM extends BaseLanguageModel {
         });
         return output;
     }
+    async _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, }) {
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
+        const extra = {
+            options: parsedOptions,
+            invocation_params: this?.invocationParams(parsedOptions),
+            batch_size: prompts.length,
+            cached: true,
+        };
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
+        // generate results
+        const missingPromptIndices = [];
+        const results = await Promise.allSettled(prompts.map(async (prompt, index) => {
+            const result = await cache.lookup(prompt, llmStringKey);
+            if (result == null) {
+                missingPromptIndices.push(index);
+            }
+            return result;
+        }));
+        // Map run managers to the results before filtering out null results
+        // Null results are just absent from the cache.
+        const cachedResults = results
+            .map((result, index) => ({ result, runManager: runManagers?.[index] }))
+            .filter(({ result }) => (result.status === "fulfilled" && result.value != null) ||
+            result.status === "rejected");
+        // Handle results and call run managers
+        const generations = [];
+        await Promise.all(cachedResults.map(async ({ result: promiseResult, runManager }, i) => {
+            if (promiseResult.status === "fulfilled") {
+                const result = promiseResult.value;
+                generations[i] = result;
+                if (result.length) {
+                    await runManager?.handleLLMNewToken(result[0].text);
+                }
+                return runManager?.handleLLMEnd({
+                    generations: [result],
+                });
+            }
+            else {
+                // status === "rejected"
+                await runManager?.handleLLMError(promiseResult.reason);
+                return Promise.reject(promiseResult.reason);
+            }
+        }));
+        const output = {
+            generations,
+            missingPromptIndices,
+        };
+        // This defines RUN_KEY as a non-enumerable property on the output object
+        // so that it is not serialized when the output is stringified, and so that
+        // it isnt included when listing the keys of the output object.
+        Object.defineProperty(output, RUN_KEY, {
+            value: runManagers
+                ? { runIds: runManagers?.map((manager) => manager.runId) }
+                : undefined,
+            configurable: true,
+        });
+        return output;
+    }
     /**
      * Run the LLM on the given prompts and input, handling caching.
      */
@@ -171,14 +229,13 @@ export class BaseLLM extends BaseLanguageModel {
         }
         const { cache } = this;
         const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(prompts.map(async (prompt, index) => {
-            const result = await cache.lookup(prompt, llmStringKey);
-            if (!result) {
-                missingPromptIndices.push(index);
-            }
-            return result;
-        }));
+        const { generations, missingPromptIndices } = await this._generateCached({
+            prompts,
+            cache,
+            llmStringKey,
+            parsedOptions: callOptions,
+            handledOptions: runnableConfig,
+        });
         let llmOutput = {};
         if (missingPromptIndices.length > 0) {
             const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig);

package/dist/runnables/base.d.ts

@@ -1,9 +1,28 @@
 import { CallbackManager, CallbackManagerForChainRun, BaseCallbackConfig } from "../callbacks/manager.js";
 import { LogStreamCallbackHandlerInput, RunLogPatch } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream } from "../utils/stream.js";
+import { IterableReadableStream, type IterableReadableStreamInterface } from "../utils/stream.js";
 import { RunnableConfig } from "./config.js";
 import { Run } from "../tracers/base.js";
+/**
+ * Base interface implemented by all runnables.
+ * Used for cross-compatibility between different versions of LangChain core.
+ *
+ * Should not change on patch releases.
+ */
+export interface RunnableInterface<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> {
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+}
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: {
     config?: RunnableConfig;
 } | Record<string, any> | (Record<string, any> & {
@@ -12,7 +31,7 @@ export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: {
 export type RunnableMapLike<RunInput, RunOutput> = {
     [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]>;
 };
-export type RunnableLike<RunInput = any, RunOutput = any> = Runnable<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | RunnableMapLike<RunInput, RunOutput>;
+export type RunnableLike<RunInput = any, RunOutput = any> = RunnableInterface<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | RunnableMapLike<RunInput, RunOutput>;
 export type RunnableBatchOptions = {
     maxConcurrency?: number;
     returnExceptions?: boolean;
@@ -22,7 +41,7 @@ export type RunnableRetryFailedAttemptHandler = (error: any) => any;
  * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
  * transformed.
  */
-export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Serializable {
+export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Serializable implements RunnableInterface<RunInput, RunOutput, CallOptions> {
     protected lc_runnable: boolean;
     abstract invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
     /**

package/dist/runnables/base.js

@@ -2,7 +2,7 @@ import pRetry from "p-retry";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream } from "../utils/stream.js";
+import { IterableReadableStream, } from "../utils/stream.js";
 import { getCallbackMangerForConfig, mergeConfigs, } from "./config.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";

package/dist/utils/stream.cjs

@@ -46,6 +46,16 @@ class IterableReadableStream extends ReadableStream {
         }
         return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async throw(e) {
+        this.ensureReader();
+        if (this.locked) {
+            const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
+            this.reader.releaseLock(); // release lock first
+            await cancelPromise; // now await it
+        }
+        throw e;
+    }
     [Symbol.asyncIterator]() {
         return this;
     }

package/dist/utils/stream.d.ts

@@ -1,4 +1,6 @@
-export declare class IterableReadableStream<T> extends ReadableStream<T> {
+export interface IterableReadableStreamInterface<T> extends ReadableStream<T>, AsyncGenerator<T> {
+}
+export declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
     reader: ReadableStreamDefaultReader<T>;
     ensureReader(): void;
     next(): Promise<{
@@ -9,6 +11,7 @@ export declare class IterableReadableStream<T> extends ReadableStream<T> {
         done: boolean;
         value: T;
     }>;
+    throw(e: any): Promise<IteratorResult<T>>;
     [Symbol.asyncIterator](): this;
     static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
     static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;

package/dist/utils/stream.js

@@ -43,6 +43,16 @@ export class IterableReadableStream extends ReadableStream {
         }
         return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async throw(e) {
+        this.ensureReader();
+        if (this.locked) {
+            const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
+            this.reader.releaseLock(); // release lock first
+            await cancelPromise; // now await it
+        }
+        throw e;
+    }
     [Symbol.asyncIterator]() {
         return this;
     }

package/dist/utils/testing/index.cjs

@@ -61,7 +61,7 @@ class FakeRunnable extends base_js_2.Runnable {
 exports.FakeRunnable = FakeRunnable;
 class FakeLLM extends llms_js_1.LLM {
     constructor(fields) {
-        super({});
+        super(fields);
         Object.defineProperty(this, "response", {
             enumerable: true,
             configurable: true,
@@ -80,11 +80,13 @@ class FakeLLM extends llms_js_1.LLM {
     _llmType() {
         return "fake";
     }
-    async _call(prompt) {
+    async _call(prompt, _options, runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        return this.response ?? prompt;
+        const response = this.response ?? prompt;
+        await runManager?.handleLLMNewToken(response);
+        return response;
     }
 }
 exports.FakeLLM = FakeLLM;
@@ -110,7 +112,7 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
     _llmType() {
         return "fake";
     }
-    async _generate(messages, options) {
+    async _generate(messages, options, runManager) {
         if (options?.stop?.length) {
             return {
                 generations: [
@@ -122,6 +124,7 @@ class FakeChatModel extends chat_models_js_1.BaseChatModel {
             };
         }
         const text = messages.map((m) => m.content).join("\n");
+        await runManager?.handleLLMNewToken(text);
         return {
             generations: [
                 {

package/dist/utils/testing/index.d.ts

@@ -2,7 +2,7 @@ import { BaseCallbackConfig, CallbackManagerForLLMRun } from "../../callbacks/ma
 import { BaseChatMessageHistory, BaseListChatMessageHistory } from "../../chat_history.js";
 import { Document } from "../../documents/document.js";
 import { BaseChatModel, BaseChatModelParams } from "../../language_models/chat_models.js";
-import { LLM } from "../../language_models/llms.js";
+import { BaseLLMParams, LLM } from "../../language_models/llms.js";
 import { BaseMessage, AIMessage } from "../../messages/index.js";
 import { BaseOutputParser } from "../../output_parsers/base.js";
 import { GenerationChunk, type ChatResult, ChatGenerationChunk } from "../../outputs.js";
@@ -31,9 +31,9 @@ export declare class FakeLLM extends LLM {
     constructor(fields: {
         response?: string;
         thrownErrorString?: string;
-    });
+    } & BaseLLMParams);
     _llmType(): string;
-    _call(prompt: string): Promise<string>;
+    _call(prompt: string, _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
 }
 export declare class FakeStreamingLLM extends LLM {
     _llmType(): string;
@@ -43,7 +43,7 @@ export declare class FakeStreamingLLM extends LLM {
 export declare class FakeChatModel extends BaseChatModel {
     _combineLLMOutput(): never[];
     _llmType(): string;
-    _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"]): Promise<ChatResult>;
+    _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }
 export declare class FakeRetriever extends BaseRetriever {
     lc_namespace: string[];

package/dist/utils/testing/index.js

@@ -56,7 +56,7 @@ export class FakeRunnable extends Runnable {
 }
 export class FakeLLM extends LLM {
     constructor(fields) {
-        super({});
+        super(fields);
         Object.defineProperty(this, "response", {
             enumerable: true,
             configurable: true,
@@ -75,11 +75,13 @@ export class FakeLLM extends LLM {
     _llmType() {
         return "fake";
     }
-    async _call(prompt) {
+    async _call(prompt, _options, runManager) {
         if (this.thrownErrorString) {
             throw new Error(this.thrownErrorString);
         }
-        return this.response ?? prompt;
+        const response = this.response ?? prompt;
+        await runManager?.handleLLMNewToken(response);
+        return response;
     }
 }
 export class FakeStreamingLLM extends LLM {
@@ -103,7 +105,7 @@ export class FakeChatModel extends BaseChatModel {
     _llmType() {
         return "fake";
     }
-    async _generate(messages, options) {
+    async _generate(messages, options, runManager) {
         if (options?.stop?.length) {
             return {
                 generations: [
@@ -115,6 +117,7 @@ export class FakeChatModel extends BaseChatModel {
             };
         }
         const text = messages.map((m) => m.content).join("\n");
+        await runManager?.handleLLMNewToken(text);
         return {
             generations: [
                 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.1",
+  "version": "0.1.2-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {