langchain 0.0.195 → 0.0.197-rc.0

package/dist/chat_models/anthropic.js

@@ -1,346 +1 @@
-import { Anthropic, AI_PROMPT, HUMAN_PROMPT, } from "@anthropic-ai/sdk";
-import { AIMessage, AIMessageChunk, ChatGenerationChunk, ChatMessage, } from "../schema/index.js";
-import { getEnvironmentVariable } from "../util/env.js";
-import { BaseChatModel } from "./base.js";
-/**
- * Extracts the custom role of a generic chat message.
- * @param message The chat message from which to extract the custom role.
- * @returns The custom role of the chat message.
- */
-function extractGenericMessageCustomRole(message) {
-    if (message.role !== AI_PROMPT &&
-        message.role !== HUMAN_PROMPT &&
-        message.role !== "") {
-        console.warn(`Unknown message role: ${message.role}`);
-    }
-    return message.role;
-}
-/**
- * Gets the Anthropic prompt from a base message.
- * @param message The base message from which to get the Anthropic prompt.
- * @returns The Anthropic prompt from the base message.
- */
-function getAnthropicPromptFromMessage(message) {
-    const type = message._getType();
-    switch (type) {
-        case "ai":
-            return AI_PROMPT;
-        case "human":
-            return HUMAN_PROMPT;
-        case "system":
-            return "";
-        case "generic": {
-            if (!ChatMessage.isInstance(message))
-                throw new Error("Invalid generic chat message");
-            return extractGenericMessageCustomRole(message);
-        }
-        default:
-            throw new Error(`Unknown message type: ${type}`);
-    }
-}
-export const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
-/**
- * Wrapper around Anthropic large language models.
- *
- * To use you should have the `@anthropic-ai/sdk` package installed, with the
- * `ANTHROPIC_API_KEY` environment variable set.
- *
- * @remarks
- * Any parameters that are valid to be passed to {@link
- * https://console.anthropic.com/docs/api/reference |
- * `anthropic.complete`} can be passed through {@link invocationKwargs},
- * even if not explicitly available on this class.
- * @example
- * ```typescript
- * const model = new ChatAnthropic({
- *   temperature: 0.9,
- *   anthropicApiKey: 'YOUR-API-KEY',
- * });
- * const res = await model.invoke({ input: 'Hello!' });
- * console.log(res);
- * ```
- */
-export class ChatAnthropic extends BaseChatModel {
-    static lc_name() {
-        return "ChatAnthropic";
-    }
-    get lc_secrets() {
-        return {
-            anthropicApiKey: "ANTHROPIC_API_KEY",
-        };
-    }
-    get lc_aliases() {
-        return {
-            modelName: "model",
-        };
-    }
-    constructor(fields) {
-        super(fields ?? {});
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "anthropicApiKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "apiUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "temperature", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 1
-        });
-        Object.defineProperty(this, "topK", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: -1
-        });
-        Object.defineProperty(this, "topP", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: -1
-        });
-        Object.defineProperty(this, "maxTokensToSample", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 2048
-        });
-        Object.defineProperty(this, "modelName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "claude-2"
-        });
-        Object.defineProperty(this, "invocationKwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "stopSequences", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "streaming", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "clientOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // Used for non-streaming requests
-        Object.defineProperty(this, "batchClient", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // Used for streaming requests
-        Object.defineProperty(this, "streamingClient", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.anthropicApiKey =
-            fields?.anthropicApiKey ?? getEnvironmentVariable("ANTHROPIC_API_KEY");
-        if (!this.anthropicApiKey) {
-            throw new Error("Anthropic API key not found");
-        }
-        // Support overriding the default API URL (i.e., https://api.anthropic.com)
-        this.apiUrl = fields?.anthropicApiUrl;
-        this.modelName = fields?.modelName ?? this.modelName;
-        this.invocationKwargs = fields?.invocationKwargs ?? {};
-        this.temperature = fields?.temperature ?? this.temperature;
-        this.topK = fields?.topK ?? this.topK;
-        this.topP = fields?.topP ?? this.topP;
-        this.maxTokensToSample =
-            fields?.maxTokensToSample ?? this.maxTokensToSample;
-        this.stopSequences = fields?.stopSequences ?? this.stopSequences;
-        this.streaming = fields?.streaming ?? false;
-        this.clientOptions = fields?.clientOptions ?? {};
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(options) {
-        return {
-            model: this.modelName,
-            temperature: this.temperature,
-            top_k: this.topK,
-            top_p: this.topP,
-            stop_sequences: options?.stop?.concat(DEFAULT_STOP_SEQUENCES) ??
-                this.stopSequences ??
-                DEFAULT_STOP_SEQUENCES,
-            max_tokens_to_sample: this.maxTokensToSample,
-            stream: this.streaming,
-            ...this.invocationKwargs,
-        };
-    }
-    /** @ignore */
-    _identifyingParams() {
-        return {
-            model_name: this.modelName,
-            ...this.invocationParams(),
-        };
-    }
-    /**
-     * Get the identifying parameters for the model
-     */
-    identifyingParams() {
-        return {
-            model_name: this.modelName,
-            ...this.invocationParams(),
-        };
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        const params = this.invocationParams(options);
-        const stream = await this.createStreamWithRetry({
-            ...params,
-            prompt: this.formatMessagesAsPrompt(messages),
-        });
-        let modelSent = false;
-        let stopReasonSent = false;
-        for await (const data of stream) {
-            if (options.signal?.aborted) {
-                stream.controller.abort();
-                throw new Error("AbortError: User aborted the request.");
-            }
-            const additional_kwargs = {};
-            if (data.model && !modelSent) {
-                additional_kwargs.model = data.model;
-                modelSent = true;
-            }
-            else if (data.stop_reason && !stopReasonSent) {
-                additional_kwargs.stop_reason = data.stop_reason;
-                stopReasonSent = true;
-            }
-            const delta = data.completion ?? "";
-            yield new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content: delta,
-                    additional_kwargs,
-                }),
-                text: delta,
-            });
-            await runManager?.handleLLMNewToken(delta);
-            if (data.stop_reason) {
-                break;
-            }
-        }
-    }
-    /**
-     * Formats messages as a prompt for the model.
-     * @param messages The base messages to format as a prompt.
-     * @returns The formatted prompt.
-     */
-    formatMessagesAsPrompt(messages) {
-        return (messages
-            .map((message) => {
-            const messagePrompt = getAnthropicPromptFromMessage(message);
-            return `${messagePrompt} ${message.content}`;
-        })
-            .join("") + AI_PROMPT);
-    }
-    /** @ignore */
-    async _generate(messages, options, runManager) {
-        if (this.stopSequences && options.stop) {
-            throw new Error(`"stopSequence" parameter found in input and default params`);
-        }
-        const params = this.invocationParams(options);
-        let response;
-        if (params.stream) {
-            response = {
-                completion: "",
-                model: "",
-                stop_reason: "",
-            };
-            const stream = await this._streamResponseChunks(messages, options, runManager);
-            for await (const chunk of stream) {
-                response.completion += chunk.message.content;
-                response.model =
-                    chunk.message.additional_kwargs.model ?? response.model;
-                response.stop_reason =
-                    chunk.message.additional_kwargs.stop_reason ??
-                        response.stop_reason;
-            }
-        }
-        else {
-            response = await this.completionWithRetry({
-                ...params,
-                prompt: this.formatMessagesAsPrompt(messages),
-            }, { signal: options.signal });
-        }
-        const generations = (response.completion ?? "")
-            .split(AI_PROMPT)
-            .map((message) => ({
-            text: message,
-            message: new AIMessage(message),
-        }));
-        return {
-            generations,
-        };
-    }
-    /**
-     * Creates a streaming request with retry.
-     * @param request The parameters for creating a completion.
-     * @returns A streaming request.
-     */
-    async createStreamWithRetry(request) {
-        if (!this.streamingClient) {
-            const options = this.apiUrl ? { baseURL: this.apiUrl } : undefined;
-            this.streamingClient = new Anthropic({
-                ...this.clientOptions,
-                ...options,
-                apiKey: this.anthropicApiKey,
-                maxRetries: 0,
-            });
-        }
-        const makeCompletionRequest = async () => this.streamingClient.completions.create({ ...request, stream: true }, { headers: request.headers });
-        return this.caller.call(makeCompletionRequest);
-    }
-    /** @ignore */
-    async completionWithRetry(request, options) {
-        if (!this.anthropicApiKey) {
-            throw new Error("Missing Anthropic API key.");
-        }
-        if (!this.batchClient) {
-            const options = this.apiUrl ? { baseURL: this.apiUrl } : undefined;
-            this.batchClient = new Anthropic({
-                ...this.clientOptions,
-                ...options,
-                apiKey: this.anthropicApiKey,
-                maxRetries: 0,
-            });
-        }
-        const makeCompletionRequest = async () => this.batchClient.completions.create({ ...request, stream: false }, { headers: request.headers });
-        return this.caller.callWithOptions({ signal: options.signal }, makeCompletionRequest);
-    }
-    _llmType() {
-        return "anthropic";
-    }
-    /** @ignore */
-    _combineLLMOutput() {
-        return [];
-    }
-}
+export * from "@langchain/anthropic";

package/dist/chat_models/baiduwenxin.d.ts

@@ -131,8 +131,8 @@ export declare class ChatBaiduWenxin extends BaseChatModel implements BaiduWenxi
      * Get the identifying parameters for the model
      */
     identifyingParams(): {
-        system?: string | undefined;
         stream?: boolean | undefined;
+        system?: string | undefined;
         temperature?: number | undefined;
         top_p?: number | undefined;
         user_id?: string | undefined;

package/dist/chat_models/base.cjs

@@ -1,298 +1,17 @@
 "use strict";
+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]; } };
+    }
+    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 });
-exports.SimpleChatModel = exports.BaseChatModel = exports.createChatMessageChunkEncoderStream = void 0;
-const index_js_1 = require("../schema/index.cjs");
-const index_js_2 = require("../base_language/index.cjs");
-const manager_js_1 = require("../callbacks/manager.cjs");
-/**
- * Creates a transform stream for encoding chat message chunks.
- * @deprecated Use {@link BytesOutputParser} instead
- * @returns A TransformStream instance that encodes chat message chunks.
- */
-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)));
-        },
-    });
-}
-exports.createChatMessageChunkEncoderStream = createChatMessageChunkEncoderStream;
-/**
- * Base class for chat models. It extends the BaseLanguageModel class and
- * provides methods for generating chat based on input messages.
- */
-class BaseChatModel extends index_js_2.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 manager_js_1.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(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,
-        };
-        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, index_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.
-     * @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(index_js_1.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(index_js_1.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 index_js_1.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;
-    }
-}
-exports.BaseChatModel = BaseChatModel;
-/**
- * An abstract class that extends BaseChatModel and provides a simple
- * implementation of _generate.
- */
-class SimpleChatModel extends BaseChatModel {
-    async _generate(messages, options, runManager) {
-        const text = await this._call(messages, options, runManager);
-        const message = new index_js_1.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,
-                },
-            ],
-        };
-    }
-}
-exports.SimpleChatModel = SimpleChatModel;
+__exportStar(require("langchain-core/language_models/chat_models"), exports);