langchain 0.0.195 → 0.0.197-rc.0

package/dist/chat_models/base.d.ts

@@ -1,122 +1 @@
-import { BaseMessage, BaseMessageChunk, BaseMessageLike, BasePromptValue, ChatGenerationChunk, ChatResult, LLMResult } from "../schema/index.js";
-import { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams } from "../base_language/index.js";
-import { CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
-import { RunnableConfig } from "../schema/runnable/config.js";
-/**
- * Represents a serialized chat model.
- */
-export type SerializedChatModel = {
-    _model: string;
-    _type: string;
-} & Record<string, any>;
-/**
- * Represents a serialized large language model.
- */
-export type SerializedLLM = {
-    _model: string;
-    _type: string;
-} & Record<string, any>;
-/**
- * Represents the parameters for a base chat model.
- */
-export type BaseChatModelParams = BaseLanguageModelParams;
-/**
- * Represents the call options for a base chat model.
- */
-export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
-/**
- * Creates a transform stream for encoding chat message chunks.
- * @deprecated Use {@link BytesOutputParser} instead
- * @returns A TransformStream instance that encodes chat message chunks.
- */
-export declare function createChatMessageChunkEncoderStream(): TransformStream<BaseMessageChunk, any>;
-/**
- * Base class for chat models. It extends the BaseLanguageModel class and
- * provides methods for generating chat based on input messages.
- */
-export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseLanguageModel<BaseMessageChunk, CallOptions> {
-    ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
-    lc_namespace: string[];
-    constructor(fields: BaseChatModelParams);
-    abstract _combineLLMOutput?(...llmOutputs: LLMResult["llmOutput"][]): LLMResult["llmOutput"];
-    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
-    /**
-     * Invokes the chat model with a single input.
-     * @param input The input for the language model.
-     * @param options The call options.
-     * @returns A Promise that resolves to a BaseMessageChunk.
-     */
-    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<BaseMessageChunk>;
-    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<BaseMessageChunk>;
-    /** @ignore */
-    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
-    /**
-     * Generates chat based on the input messages.
-     * @param messages An array of arrays of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(_options?: this["ParsedCallOptions"]): any;
-    _modelType(): string;
-    abstract _llmType(): string;
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize(): SerializedLLM;
-    /**
-     * Generates a prompt based on the input prompt values.
-     * @param promptValues An array of BasePromptValue instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    generatePrompt(promptValues: BasePromptValue[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    abstract _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    /**
-     * Makes a single call to the chat model.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    call(messages: BaseMessageLike[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Makes a single call to the chat model with a prompt value.
-     * @param promptValue The value of the prompt.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    callPrompt(promptValue: BasePromptValue, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Predicts the next message based on the input messages.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    predictMessages(messages: BaseMessage[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Predicts the next message based on a text input.
-     * @param text The text input.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a string.
-     */
-    predict(text: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
-}
-/**
- * An abstract class that extends BaseChatModel and provides a simple
- * implementation of _generate.
- */
-export declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {
-    abstract _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-}
+export * from "langchain-core/language_models/chat_models";

package/dist/chat_models/base.js

@@ -1,292 +1 @@
-import { AIMessage, HumanMessage, RUN_KEY, coerceMessageLikeToMessage, } from "../schema/index.js";
-import { BaseLanguageModel, } from "../base_language/index.js";
-import { CallbackManager, } from "../callbacks/manager.js";
-/**
- * Creates a transform stream for encoding chat message chunks.
- * @deprecated Use {@link BytesOutputParser} instead
- * @returns A TransformStream instance that encodes chat message chunks.
- */
-export function createChatMessageChunkEncoderStream() {
-    const textEncoder = new TextEncoder();
-    return new TransformStream({
-        transform(chunk, controller) {
-            controller.enqueue(textEncoder.encode(typeof chunk.content === "string"
-                ? chunk.content
-                : JSON.stringify(chunk.content)));
-        },
-    });
-}
-/**
- * Base class for chat models. It extends the BaseLanguageModel class and
- * provides methods for generating chat based on input messages.
- */
-export class BaseChatModel extends BaseLanguageModel {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "chat_models", this._llmType()]
-        });
-    }
-    _separateRunnableConfigFromCallOptions(options) {
-        const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-        if (callOptions?.timeout && !callOptions.signal) {
-            callOptions.signal = AbortSignal.timeout(callOptions.timeout);
-        }
-        return [runnableConfig, callOptions];
-    }
-    /**
-     * Invokes the chat model with a single input.
-     * @param input The input for the language model.
-     * @param options The call options.
-     * @returns A Promise that resolves to a BaseMessageChunk.
-     */
-    async invoke(input, options) {
-        const promptValue = BaseChatModel._convertInputToPromptValue(input);
-        const result = await this.generatePrompt([promptValue], options, options?.callbacks);
-        const chatGeneration = result.generations[0][0];
-        // TODO: Remove cast after figuring out inheritance
-        return chatGeneration.message;
-    }
-    // eslint-disable-next-line require-yield
-    async *_streamResponseChunks(_messages, _options, _runManager) {
-        throw new Error("Not implemented.");
-    }
-    async *_streamIterator(input, options) {
-        // Subclass check required to avoid double callbacks with default implementation
-        if (this._streamResponseChunks ===
-            BaseChatModel.prototype._streamResponseChunks) {
-            yield this.invoke(input, options);
-        }
-        else {
-            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 extra = {
-                options: callOptions,
-                invocation_params: this?.invocationParams(callOptions),
-                batch_size: 1,
-            };
-            const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), [messages], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
-            let generationChunk;
-            try {
-                for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
-                    yield chunk.message;
-                    if (!generationChunk) {
-                        generationChunk = chunk;
-                    }
-                    else {
-                        generationChunk = generationChunk.concat(chunk);
-                    }
-                }
-            }
-            catch (err) {
-                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-                throw err;
-            }
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
-                // TODO: Remove cast after figuring out inheritance
-                generations: [[generationChunk]],
-            })));
-        }
-    }
-    /** @ignore */
-    async _generateUncached(messages, 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,
-        };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
-        // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
-        // handle results
-        const generations = [];
-        const llmOutputs = [];
-        await Promise.all(results.map(async (pResult, i) => {
-            if (pResult.status === "fulfilled") {
-                const result = pResult.value;
-                generations[i] = result.generations;
-                llmOutputs[i] = result.llmOutput;
-                return runManagers?.[i]?.handleLLMEnd({
-                    generations: [result.generations],
-                    llmOutput: result.llmOutput,
-                });
-            }
-            else {
-                // status === "rejected"
-                await runManagers?.[i]?.handleLLMError(pResult.reason);
-                return Promise.reject(pResult.reason);
-            }
-        }));
-        // create combined output
-        const output = {
-            generations,
-            llmOutput: llmOutputs.length
-                ? this._combineLLMOutput?.(...llmOutputs)
-                : undefined,
-        };
-        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.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    async generate(messages, options, callbacks) {
-        // parse call options
-        let parsedOptions;
-        if (Array.isArray(options)) {
-            parsedOptions = { stop: options };
-        }
-        else {
-            parsedOptions = options;
-        }
-        const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
-        runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
-        if (!this.cache) {
-            return this._generateUncached(baseMessages, callOptions, runnableConfig);
-        }
-        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;
-        }));
-        let llmOutput = {};
-        if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => baseMessages[i]), callOptions, runnableConfig);
-            await Promise.all(results.generations.map(async (generation, index) => {
-                const promptIndex = missingPromptIndices[index];
-                generations[promptIndex] = generation;
-                // Join all content into one string for the prompt index
-                const prompt = BaseChatModel._convertInputToPromptValue(baseMessages[promptIndex]).toString();
-                return cache.update(prompt, llmStringKey, generation);
-            }));
-            llmOutput = results.llmOutput ?? {};
-        }
-        return { generations, llmOutput };
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    invocationParams(_options) {
-        return {};
-    }
-    _modelType() {
-        return "base_chat_model";
-    }
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize() {
-        return {
-            ...this.invocationParams(),
-            _type: this._llmType(),
-            _model: this._modelType(),
-        };
-    }
-    /**
-     * Generates a prompt based on the input prompt values.
-     * @param promptValues An array of BasePromptValue instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    async generatePrompt(promptValues, options, callbacks) {
-        const promptMessages = promptValues.map((promptValue) => promptValue.toChatMessages());
-        return this.generate(promptMessages, options, callbacks);
-    }
-    /**
-     * Makes a single call to the chat model.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async call(messages, options, callbacks) {
-        const result = await this.generate([messages.map(coerceMessageLikeToMessage)], options, callbacks);
-        const generations = result.generations;
-        return generations[0][0].message;
-    }
-    /**
-     * Makes a single call to the chat model with a prompt value.
-     * @param promptValue The value of the prompt.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async callPrompt(promptValue, options, callbacks) {
-        const promptMessages = promptValue.toChatMessages();
-        return this.call(promptMessages, options, callbacks);
-    }
-    /**
-     * Predicts the next message based on the input messages.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async predictMessages(messages, options, callbacks) {
-        return this.call(messages, options, callbacks);
-    }
-    /**
-     * Predicts the next message based on a text input.
-     * @param text The text input.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a string.
-     */
-    async predict(text, options, callbacks) {
-        const message = new HumanMessage(text);
-        const result = await this.call([message], options, callbacks);
-        if (typeof result.content !== "string") {
-            throw new Error("Cannot use predict when output is not a string.");
-        }
-        return result.content;
-    }
-}
-/**
- * An abstract class that extends BaseChatModel and provides a simple
- * implementation of _generate.
- */
-export class SimpleChatModel extends BaseChatModel {
-    async _generate(messages, options, runManager) {
-        const text = await this._call(messages, options, runManager);
-        const message = new AIMessage(text);
-        if (typeof message.content !== "string") {
-            throw new Error("Cannot generate with a simple chat model when output is not a string.");
-        }
-        return {
-            generations: [
-                {
-                    text: message.content,
-                    message,
-                },
-            ],
-        };
-    }
-}
+export * from "langchain-core/language_models/chat_models";

package/dist/chat_models/bedrock/web.cjs

@@ -321,11 +321,31 @@ class BedrockChat extends base_js_1.SimpleChatModel {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _readChunks(reader) {
+        function _concatChunks(a, b) {
+            const newBuffer = new Uint8Array(a.length + b.length);
+            newBuffer.set(a);
+            newBuffer.set(b, a.length);
+            return newBuffer;
+        }
+        function getMessageLength(buffer) {
+            if (buffer.byteLength === 0)
+                return 0;
+            const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            return view.getUint32(0, false);
+        }
         return {
             async *[Symbol.asyncIterator]() {
                 let readResult = await reader.read();
+                let buffer = new Uint8Array(0);
                 while (!readResult.done) {
-                    yield readResult.value;
+                    const chunk = readResult.value;
+                    buffer = _concatChunks(buffer, chunk);
+                    let messageLength = getMessageLength(buffer);
+                    while (buffer.byteLength > 0 && buffer.byteLength >= messageLength) {
+                        yield buffer.slice(0, messageLength);
+                        buffer = buffer.slice(messageLength);
+                        messageLength = getMessageLength(buffer);
+                    }
                     readResult = await reader.read();
                 }
             },

package/dist/chat_models/bedrock/web.d.ts

@@ -3,7 +3,7 @@ import { BaseBedrockInput, type CredentialType } from "../../util/bedrock.js";
 import { SimpleChatModel, BaseChatModelParams } from "../base.js";
 import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
 import { BaseMessage, ChatGenerationChunk } from "../../schema/index.js";
-import { SerializedFields } from "../../load/map_keys.js";
+import type { SerializedFields } from "../../load/map_keys.js";
 export declare function convertMessagesToPromptAnthropic(messages: BaseMessage[], humanPrompt?: string, aiPrompt?: string): string;
 /**
  * Function that converts an array of messages into a single string prompt
@@ -72,7 +72,7 @@ export declare class BedrockChat extends SimpleChatModel implements BaseBedrockI
     }): Promise<Response>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     _readChunks(reader: any): {
-        [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+        [Symbol.asyncIterator](): AsyncGenerator<Uint8Array, void, unknown>;
     };
     _combineLLMOutput(): {};
 }

package/dist/chat_models/bedrock/web.js

@@ -316,11 +316,31 @@ export class BedrockChat extends SimpleChatModel {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _readChunks(reader) {
+        function _concatChunks(a, b) {
+            const newBuffer = new Uint8Array(a.length + b.length);
+            newBuffer.set(a);
+            newBuffer.set(b, a.length);
+            return newBuffer;
+        }
+        function getMessageLength(buffer) {
+            if (buffer.byteLength === 0)
+                return 0;
+            const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            return view.getUint32(0, false);
+        }
         return {
             async *[Symbol.asyncIterator]() {
                 let readResult = await reader.read();
+                let buffer = new Uint8Array(0);
                 while (!readResult.done) {
-                    yield readResult.value;
+                    const chunk = readResult.value;
+                    buffer = _concatChunks(buffer, chunk);
+                    let messageLength = getMessageLength(buffer);
+                    while (buffer.byteLength > 0 && buffer.byteLength >= messageLength) {
+                        yield buffer.slice(0, messageLength);
+                        buffer = buffer.slice(messageLength);
+                        messageLength = getMessageLength(buffer);
+                    }
                     readResult = await reader.read();
                 }
             },

package/dist/chat_models/fireworks.d.ts

@@ -36,7 +36,7 @@ export declare class ChatFireworks extends ChatOpenAI<ChatFireworksCallOptions>
     constructor(fields?: Partial<Omit<OpenAIChatInput, "openAIApiKey" | FireworksUnsupportedArgs>> & BaseChatModelParams & {
         fireworksApiKey?: string;
     });
-    toJSON(): import("../load/serializable.js").Serialized;
+    toJSON(): import("langchain-core/load/serializable").Serialized;
     completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>>;
     completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Chat.Completions.ChatCompletion>;
 }

package/dist/document.cjs

@@ -1,27 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Document = void 0;
-/**
- * Interface for interacting with a document.
- */
-class Document {
-    constructor(fields) {
-        Object.defineProperty(this, "pageContent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.pageContent = fields.pageContent
-            ? fields.pageContent.toString()
-            : this.pageContent;
-        this.metadata = fields.metadata ?? {};
-    }
-}
-exports.Document = Document;
+var documents_1 = require("langchain-core/documents");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return documents_1.Document; } });

package/dist/document.d.ts

@@ -1,12 +1 @@
-export interface DocumentInput<Metadata extends Record<string, any> = Record<string, any>> {
-    pageContent: string;
-    metadata?: Metadata;
-}
-/**
- * Interface for interacting with a document.
- */
-export declare class Document<Metadata extends Record<string, any> = Record<string, any>> implements DocumentInput {
-    pageContent: string;
-    metadata: Metadata;
-    constructor(fields: DocumentInput<Metadata>);
-}
+export { type DocumentInput, Document } from "langchain-core/documents";

package/dist/document.js

@@ -1,23 +1 @@
-/**
- * Interface for interacting with a document.
- */
-export class Document {
-    constructor(fields) {
-        Object.defineProperty(this, "pageContent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.pageContent = fields.pageContent
-            ? fields.pageContent.toString()
-            : this.pageContent;
-        this.metadata = fields.metadata ?? {};
-    }
-}
+export { Document } from "langchain-core/documents";

package/dist/document_loaders/web/azure_blob_storage_file.d.ts

@@ -47,6 +47,6 @@ export declare class AzureBlobStorageFileLoader extends BaseDocumentLoader {
      * are returned, and the temporary directory is deleted.
      * @returns An array of documents loaded from the file in Azure Blob Storage.
      */
-    load(): Promise<import("../../document.js").Document<Record<string, any>>[]>;
+    load(): Promise<import("langchain-core/documents").Document<Record<string, any>>[]>;
 }
 export {};