@langchain/anthropic 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Harrison Chase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# langchain-anthropic

package/chat_models.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/chat_models.cjs');

package/chat_models.d.ts

@@ -0,0 +1 @@
+export * from './dist/chat_models.js'

package/chat_models.js

@@ -0,0 +1 @@
+export * from './dist/chat_models.js'

package/dist/chat_models.cjs

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatAnthropic = exports.DEFAULT_STOP_SEQUENCES = void 0;
+const sdk_1 = require("@anthropic-ai/sdk");
+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.d.ts

@@ -0,0 +1,157 @@
+import { Anthropic, 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 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;
+        max_tokens_to_sample: number;
+        model: "claude-2" | (string & {}) | "claude-instant-1";
+        stop_sequences?: string[] | undefined;
+        temperature?: number | undefined;
+        top_k?: number | undefined;
+        top_p?: number | undefined;
+        model_name: string;
+    };
+    /**
+     * Get the identifying parameters for the model
+     */
+    identifyingParams(): {
+        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
+        stream?: boolean | undefined;
+        max_tokens_to_sample: number;
+        model: "claude-2" | (string & {}) | "claude-instant-1";
+        stop_sequences?: string[] | undefined;
+        temperature?: number | undefined;
+        top_k?: number | undefined;
+        top_p?: number | 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[];
+}
+export {};

package/dist/chat_models.js

@@ -0,0 +1,347 @@
+import { Anthropic, AI_PROMPT, HUMAN_PROMPT, } from "@anthropic-ai/sdk";
+import { AIMessage, AIMessageChunk, ChatMessage, } from "langchain-core/messages";
+import { ChatGenerationChunk, } from "langchain-core/outputs";
+import { getEnvironmentVariable } from "langchain-core/utils/env";
+import { BaseChatModel, } from "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 !== 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 [];
+    }
+}

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/index.cjs');

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/index.js

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@langchain/anthropic",
+  "version": "0.0.0",
+  "description": "Anthropic integrations for LangChain.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:langchain-ai/langchainjs.git"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
+    "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/",
+    "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rimraf dist-cjs",
+    "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
+    "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
+    "lint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src && dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint:fix": "yarn lint --fix",
+    "clean": "rimraf dist/ && NODE_OPTIONS=--max-old-space-size=4096 node scripts/create-entrypoints.js pre",
+    "prepack": "yarn build",
+    "release": "release-it --only-version --config .release-it.json",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
+    "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
+    "format": "prettier --write \"src\"",
+    "format:check": "prettier --check \"src\""
+  },
+  "author": "LangChain",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.10.0",
+    "langchain-core": "^0.0.3"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@swc/core": "^1.3.90",
+    "@swc/jest": "^0.2.29",
+    "dpdm": "^3.12.0",
+    "eslint": "^8.33.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-no-instanceof": "^1.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.5.0",
+    "jest-environment-node": "^29.6.4",
+    "langchain-core": "workspace:*",
+    "prettier": "^2.8.3",
+    "release-it": "^15.10.1",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "fast-xml-parser": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "gpt3",
+    "chain",
+    "prompt",
+    "prompt engineering",
+    "chatgpt",
+    "machine learning",
+    "ml",
+    "openai",
+    "embeddings",
+    "vectorstores"
+  ],
+  "exports": {
+    "./chat_models": {
+      "types": "./chat_models.d.ts",
+      "import": "./chat_models.js",
+      "require": "./chat_models.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "chat_models.cjs",
+    "chat_models.js",
+    "chat_models.d.ts",
+    "index.cjs",
+    "index.js",
+    "index.d.ts"
+  ]
+}