langchain 0.0.195 → 0.0.196

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/chat_model";

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

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 document_1 = require("langchain-core/schema/document");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return document_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/schema/document";

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/schema/document";

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/schema/document").Document<Record<string, any>>[]>;
 }
 export {};

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

@@ -70,5 +70,5 @@ export declare class S3Loader extends BaseDocumentLoader {
      * and then uses the UnstructuredLoader to load the file as a document.
      * @returns An array of Document objects representing the loaded documents.
      */
-    load(): Promise<import("../../document.js").Document<Record<string, any>>[]>;
+    load(): Promise<import("langchain-core/schema/document").Document<Record<string, any>>[]>;
 }

package/dist/embeddings/base.cjs

@@ -1,24 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Embeddings = void 0;
-const async_caller_js_1 = require("../util/async_caller.cjs");
-/**
- * An abstract class that provides methods for embedding documents and
- * queries using LangChain.
- */
-class Embeddings {
-    constructor(params) {
-        /**
-         * The async caller should be used by subclasses to make any async calls,
-         * which will thus benefit from the concurrency and retry logic.
-         */
-        Object.defineProperty(this, "caller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.caller = new async_caller_js_1.AsyncCaller(params ?? {});
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-}
-exports.Embeddings = Embeddings;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("langchain-core/schema/embeddings"), exports);

package/dist/embeddings/base.d.ts

@@ -1,33 +1 @@
-import { AsyncCaller, AsyncCallerParams } from "../util/async_caller.js";
-/**
- * The parameters required to initialize an instance of the Embeddings
- * class.
- */
-export type EmbeddingsParams = AsyncCallerParams;
-/**
- * An abstract class that provides methods for embedding documents and
- * queries using LangChain.
- */
-export declare abstract class Embeddings {
-    /**
-     * The async caller should be used by subclasses to make any async calls,
-     * which will thus benefit from the concurrency and retry logic.
-     */
-    caller: AsyncCaller;
-    constructor(params: EmbeddingsParams);
-    /**
-     * An abstract method that takes an array of documents as input and
-     * returns a promise that resolves to an array of vectors for each
-     * document.
-     * @param documents An array of documents to be embedded.
-     * @returns A promise that resolves to an array of vectors for each document.
-     */
-    abstract embedDocuments(documents: string[]): Promise<number[][]>;
-    /**
-     * An abstract method that takes a single document as input and returns a
-     * promise that resolves to a vector for the query document.
-     * @param document A single document to be embedded.
-     * @returns A promise that resolves to a vector for the query document.
-     */
-    abstract embedQuery(document: string): Promise<number[]>;
-}
+export * from "langchain-core/schema/embeddings";

package/dist/embeddings/base.js

@@ -1,20 +1 @@
-import { AsyncCaller } from "../util/async_caller.js";
-/**
- * An abstract class that provides methods for embedding documents and
- * queries using LangChain.
- */
-export class Embeddings {
-    constructor(params) {
-        /**
-         * The async caller should be used by subclasses to make any async calls,
-         * which will thus benefit from the concurrency and retry logic.
-         */
-        Object.defineProperty(this, "caller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.caller = new AsyncCaller(params ?? {});
-    }
-}
+export * from "langchain-core/schema/embeddings";

package/dist/embeddings/cache_backed.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheBackedEmbeddings = void 0;
-const hash_js_1 = require("../util/js-sha1/hash.cjs");
+const hash_1 = require("langchain-core/util/hash");
 const encoder_backed_js_1 = require("../storage/encoder_backed.cjs");
 const base_js_1 = require("./base.cjs");
 /**
@@ -130,7 +130,7 @@ class CacheBackedEmbeddings extends base_js_1.Embeddings {
         const decoder = new TextDecoder();
         const encoderBackedStore = new encoder_backed_js_1.EncoderBackedStore({
             store: documentEmbeddingStore,
-            keyEncoder: (key) => (options?.namespace ?? "") + (0, hash_js_1.insecureHash)(key),
+            keyEncoder: (key) => (options?.namespace ?? "") + (0, hash_1.insecureHash)(key),
             valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
             valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue)),
         });

package/dist/embeddings/cache_backed.js

@@ -1,4 +1,4 @@
-import { insecureHash } from "../util/js-sha1/hash.js";
+import { insecureHash } from "langchain-core/util/hash";
 import { EncoderBackedStore } from "../storage/encoder_backed.js";
 import { Embeddings } from "./base.js";
 /**

package/dist/evaluation/agents/trajectory.d.ts

@@ -27,7 +27,7 @@ export declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
     requiresInput: boolean;
     requiresReference: boolean;
     outputParser: TrajectoryOutputParser;
-    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredTool[]): import("../../prompts/chat.js").ChatPromptTemplate<any, any> | BasePromptTemplate<any, import("../../schema/index.js").BasePromptValue, any>;
+    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredTool[]): BasePromptTemplate<any, import("../../schema/index.js").BasePromptValue, any> | import("../../prompts/index.js").ChatPromptTemplate<any, any>;
     /**
      * Get the description of the agent tools.
      *

package/dist/evaluation/criteria/prompt.d.ts

@@ -1,12 +1,12 @@
 import { PromptTemplate } from "../../prompts/index.js";
 export declare const CRITERIA_PROMPT: PromptTemplate<{
-    output: any;
     input: any;
+    output: any;
     criteria: any;
 }, any>;
 export declare const PROMPT_WITH_REFERENCES: PromptTemplate<{
-    output: any;
     input: any;
+    output: any;
     criteria: any;
     reference: any;
 }, any>;

package/dist/evaluation/qa/prompt.d.ts

@@ -1,11 +1,11 @@
 import { PromptTemplate } from "../../prompts/prompt.js";
 export declare const QA_PROMPT: PromptTemplate<{
-    query: any;
     answer: any;
+    query: any;
     result: any;
 }, any>;
 export declare const SQL_PROMPT: PromptTemplate<{
-    query: any;
     answer: any;
+    query: any;
     result: any;
 }, any>;

package/dist/experimental/hubs/makersuite/googlemakersuitehub.d.ts

@@ -118,7 +118,7 @@ export declare class MakerSuitePrompt {
      * will have the parameters (model name, temperature, etc) from those in
      * MakerSuite.
      */
-    toChain(): import("../../../schema/runnable/base.js").RunnableSequence<any, any>;
+    toChain(): import("../../../schema/runnable/index.js").RunnableSequence<any, any>;
 }
 interface DriveFileReadParams extends GoogleVertexAIConnectionParams<GoogleAuthOptions> {
     fileId: string;

package/dist/experimental/plan_and_execute/prompt.d.ts

@@ -10,4 +10,4 @@ export declare const DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE = "Previo
  * @param tools the tools available to the `planner`
  * @returns
  */
-export declare const getPlannerChatPrompt: (tools: Tool[] | DynamicStructuredTool[]) => Promise<ChatPromptTemplate<import("../../schema/index.js").InputValues<string>, any>>;
+export declare const getPlannerChatPrompt: (tools: Tool[] | DynamicStructuredTool[]) => Promise<ChatPromptTemplate<import("langchain-core/schema").InputValues<string>, any>>;