langchain 0.0.197-rc.1 → 0.0.197

package/dist/chains/openai_moderation.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIModerationChain = void 0;
-const openai_1 = require("@langchain/openai");
+const openai_1 = require("openai");
 const base_js_1 = require("./base.cjs");
 const async_caller_js_1 = require("../util/async_caller.cjs");
 const env_js_1 = require("../util/env.cjs");
@@ -109,7 +109,7 @@ class OpenAIModerationChain extends base_js_1.BaseChain {
             apiKey: this.openAIApiKey,
             organization: this.openAIOrganization,
         };
-        this.client = new openai_1.OpenAIClient(this.clientConfig);
+        this.client = new openai_1.OpenAI(this.clientConfig);
         this.caller = new async_caller_js_1.AsyncCaller(fields ?? {});
     }
     _moderate(text, results) {

package/dist/chains/openai_moderation.d.ts

@@ -1,4 +1,4 @@
-import { type ClientOptions, OpenAIClient } from "@langchain/openai";
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { BaseChain, ChainInputs } from "./base.js";
 import { ChainValues } from "../schema/index.js";
 import { AsyncCaller, AsyncCallerParams } from "../util/async_caller.js";

package/dist/chains/openai_moderation.js

@@ -1,4 +1,4 @@
-import { OpenAIClient } from "@langchain/openai";
+import { OpenAI as OpenAIClient } from "openai";
 import { BaseChain } from "./base.js";
 import { AsyncCaller } from "../util/async_caller.js";
 import { getEnvironmentVariable } from "../util/env.js";

package/dist/chat_models/anthropic.cjs

@@ -1,17 +1,353 @@
 "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 });
-__exportStar(require("@langchain/anthropic"), exports);
+exports.ChatAnthropic = exports.DEFAULT_STOP_SEQUENCES = exports.HUMAN_PROMPT = exports.AI_PROMPT = void 0;
+const sdk_1 = require("@anthropic-ai/sdk");
+Object.defineProperty(exports, "AI_PROMPT", { enumerable: true, get: function () { return sdk_1.AI_PROMPT; } });
+Object.defineProperty(exports, "HUMAN_PROMPT", { enumerable: true, get: function () { return sdk_1.HUMAN_PROMPT; } });
+const messages_1 = require("@langchain/core/messages");
+const outputs_1 = require("@langchain/core/outputs");
+const env_1 = require("@langchain/core/utils/env");
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+/**
+ * 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 !== sdk_1.AI_PROMPT &&
+        message.role !== sdk_1.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 sdk_1.AI_PROMPT;
+        case "human":
+            return sdk_1.HUMAN_PROMPT;
+        case "system":
+            return "";
+        case "generic": {
+            if (!messages_1.ChatMessage.isInstance(message))
+                throw new Error("Invalid generic chat message");
+            return extractGenericMessageCustomRole(message);
+        }
+        default:
+            throw new Error(`Unknown message type: ${type}`);
+    }
+}
+exports.DEFAULT_STOP_SEQUENCES = [sdk_1.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);
+ * ```
+ */
+class ChatAnthropic extends chat_models_1.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 ?? (0, env_1.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(exports.DEFAULT_STOP_SEQUENCES) ??
+                this.stopSequences ??
+                exports.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 outputs_1.ChatGenerationChunk({
+                message: new messages_1.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("") + sdk_1.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(sdk_1.AI_PROMPT)
+            .map((message) => ({
+            text: message,
+            message: new messages_1.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 sdk_1.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 sdk_1.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 [];
+    }
+}
+exports.ChatAnthropic = ChatAnthropic;

package/dist/chat_models/anthropic.d.ts

@@ -1 +1,157 @@
-export * from "@langchain/anthropic";
+import { Anthropic, AI_PROMPT, HUMAN_PROMPT, ClientOptions } from "@anthropic-ai/sdk";
+import type { CompletionCreateParams } from "@anthropic-ai/sdk/resources/completions";
+import type { Stream } from "@anthropic-ai/sdk/streaming";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { type BaseMessage } from "@langchain/core/messages";
+import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
+import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+export { AI_PROMPT, HUMAN_PROMPT };
+export declare const DEFAULT_STOP_SEQUENCES: string[];
+/**
+ * Input to AnthropicChat class.
+ */
+export interface AnthropicInput {
+    /** Amount of randomness injected into the response. Ranges
+     * from 0 to 1. Use temp closer to 0 for analytical /
+     * multiple choice, and temp closer to 1 for creative
+     * and generative tasks.
+     */
+    temperature?: number;
+    /** Only sample from the top K options for each subsequent
+     * token. Used to remove "long tail" low probability
+     * responses. Defaults to -1, which disables it.
+     */
+    topK?: number;
+    /** Does nucleus sampling, in which we compute the
+     * cumulative distribution over all the options for each
+     * subsequent token in decreasing probability order and
+     * cut it off once it reaches a particular probability
+     * specified by top_p. Defaults to -1, which disables it.
+     * Note that you should either alter temperature or top_p,
+     * but not both.
+     */
+    topP?: number;
+    /** A maximum number of tokens to generate before stopping. */
+    maxTokensToSample: number;
+    /** A list of strings upon which to stop generating.
+     * You probably want `["\n\nHuman:"]`, as that's the cue for
+     * the next turn in the dialog agent.
+     */
+    stopSequences?: string[];
+    /** Whether to stream the results or not */
+    streaming?: boolean;
+    /** Anthropic API key */
+    anthropicApiKey?: string;
+    /** Anthropic API URL */
+    anthropicApiUrl?: string;
+    /** Model name to use */
+    modelName: string;
+    /** Overridable Anthropic ClientOptions */
+    clientOptions: ClientOptions;
+    /** Holds any additional parameters that are valid to pass to {@link
+     * https://console.anthropic.com/docs/api/reference |
+     * `anthropic.complete`} that are not explicitly specified on this class.
+     */
+    invocationKwargs?: Kwargs;
+}
+/**
+ * A type representing additional parameters that can be passed to the
+ * Anthropic API.
+ */
+type Kwargs = Record<string, any>;
+/**
+ * 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 declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
+    static lc_name(): string;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    get lc_aliases(): Record<string, string>;
+    lc_serializable: boolean;
+    anthropicApiKey?: string;
+    apiUrl?: string;
+    temperature: number;
+    topK: number;
+    topP: number;
+    maxTokensToSample: number;
+    modelName: string;
+    invocationKwargs?: Kwargs;
+    stopSequences?: string[];
+    streaming: boolean;
+    clientOptions: ClientOptions;
+    protected batchClient: Anthropic;
+    protected streamingClient: Anthropic;
+    constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(options?: this["ParsedCallOptions"]): Omit<CompletionCreateParams, "prompt"> & Kwargs;
+    /** @ignore */
+    _identifyingParams(): {
+        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
+        stream?: boolean | undefined;
+        model: (string & {}) | "claude-2" | "claude-instant-1";
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        max_tokens_to_sample: number;
+        stop_sequences?: string[] | undefined;
+        model_name: string;
+    };
+    /**
+     * Get the identifying parameters for the model
+     */
+    identifyingParams(): {
+        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
+        stream?: boolean | undefined;
+        model: (string & {}) | "claude-2" | "claude-instant-1";
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+        top_k?: number | undefined;
+        max_tokens_to_sample: number;
+        stop_sequences?: string[] | undefined;
+        model_name: string;
+    };
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    /**
+     * Formats messages as a prompt for the model.
+     * @param messages The base messages to format as a prompt.
+     * @returns The formatted prompt.
+     */
+    protected formatMessagesAsPrompt(messages: BaseMessage[]): string;
+    /** @ignore */
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    /**
+     * Creates a streaming request with retry.
+     * @param request The parameters for creating a completion.
+     * @returns A streaming request.
+     */
+    protected createStreamWithRetry(request: CompletionCreateParams & Kwargs): Promise<Stream<Anthropic.Completions.Completion>>;
+    /** @ignore */
+    protected completionWithRetry(request: CompletionCreateParams & Kwargs, options: {
+        signal?: AbortSignal;
+    }): Promise<Anthropic.Completions.Completion>;
+    _llmType(): string;
+    /** @ignore */
+    _combineLLMOutput(): never[];
+}