@langchain/anthropic 0.0.5 → 0.0.7

package/README.md

@@ -21,14 +21,14 @@ You can do so by adding appropriate fields to your project's `package.json` like
     "langchain": "0.0.207"
   },
   "resolutions": {
-    "@langchain/core": "0.1.1"
+    "@langchain/core": "0.1.2"
   },
   "overrides": {
-    "@langchain/core": "0.1.1"
+    "@langchain/core": "0.1.2"
   },
   "pnpm": {
     "overrides": {
-      "@langchain/core": "0.1.1"
+      "@langchain/core": "0.1.2"
     }
   }
 }
@@ -49,7 +49,7 @@ export ANTHROPIC_API_KEY=your-api-key
 Then initialize
 
 ```typescript
-import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatAnthropicMessages } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
   anthropicApiKey: process.env.ANTHROPIC_API_KEY,
@@ -60,11 +60,11 @@ const response = await model.invoke(new HumanMessage("Hello world!"));
 ### Streaming
 
 ```typescript
-import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatAnthropicMessages } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
   anthropicApiKey: process.env.ANTHROPIC_API_KEY,
-  modelName: "claude-2",
+  modelName: "claude-2.1",
 });
 const response = await model.stream(new HumanMessage("Hello world!"));
 ```

package/dist/chat_models.cjs

@@ -1,50 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatAnthropic = exports.DEFAULT_STOP_SEQUENCES = exports.HUMAN_PROMPT = exports.AI_PROMPT = void 0;
+exports.ChatAnthropic = exports.ChatAnthropicMessages = 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.
  *
@@ -54,7 +15,7 @@ exports.DEFAULT_STOP_SEQUENCES = [sdk_1.HUMAN_PROMPT];
  * @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},
+ * `anthropic.beta.messages`} can be passed through {@link invocationKwargs},
  * even if not explicitly available on this class.
  * @example
  * ```typescript
@@ -66,7 +27,7 @@ exports.DEFAULT_STOP_SEQUENCES = [sdk_1.HUMAN_PROMPT];
  * console.log(res);
  * ```
  */
-class ChatAnthropic extends chat_models_1.BaseChatModel {
+class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     static lc_name() {
         return "ChatAnthropic";
     }
@@ -118,7 +79,7 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
             writable: true,
             value: -1
         });
-        Object.defineProperty(this, "maxTokensToSample", {
+        Object.defineProperty(this, "maxTokens", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -128,7 +89,7 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "claude-2"
+            value: "claude-2.1"
         });
         Object.defineProperty(this, "invocationKwargs", {
             enumerable: true,
@@ -180,8 +141,8 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
         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.maxTokens =
+            fields?.maxTokensToSample ?? fields?.maxTokens ?? this.maxTokens;
         this.stopSequences = fields?.stopSequences ?? this.stopSequences;
         this.streaming = fields?.streaming ?? false;
         this.clientOptions = fields?.clientOptions ?? {};
@@ -195,11 +156,9 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
             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,
+            stop_sequences: options?.stop ?? this.stopSequences,
             stream: this.streaming,
+            max_tokens: this.maxTokens,
             ...this.invocationKwargs,
         };
     }
@@ -223,35 +182,53 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
         const params = this.invocationParams(options);
         const stream = await this.createStreamWithRetry({
             ...params,
-            prompt: this.formatMessagesAsPrompt(messages),
+            ...this.formatMessagesForAnthropic(messages),
+            stream: true,
         });
-        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;
+            if (data.type === "message_start") {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { content, ...additionalKwargs } = data.message;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const filteredAdditionalKwargs = {};
+                for (const [key, value] of Object.entries(additionalKwargs)) {
+                    if (value !== undefined && value !== null) {
+                        filteredAdditionalKwargs[key] = value;
+                    }
+                }
+                yield new outputs_1.ChatGenerationChunk({
+                    message: new messages_1.AIMessageChunk({
+                        content: "",
+                        additional_kwargs: filteredAdditionalKwargs,
+                    }),
+                    text: "",
+                });
             }
-            else if (data.stop_reason && !stopReasonSent) {
-                additional_kwargs.stop_reason = data.stop_reason;
-                stopReasonSent = true;
+            else if (data.type === "message_delta") {
+                yield new outputs_1.ChatGenerationChunk({
+                    message: new messages_1.AIMessageChunk({
+                        content: "",
+                        additional_kwargs: { ...data.delta },
+                    }),
+                    text: "",
+                });
             }
-            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;
+            else if (data.type === "content_block_delta") {
+                const content = data.delta?.text;
+                if (content !== undefined) {
+                    yield new outputs_1.ChatGenerationChunk({
+                        message: new messages_1.AIMessageChunk({
+                            content,
+                            additional_kwargs: {},
+                        }),
+                        text: content,
+                    });
+                    await runManager?.handleLLMNewToken(content);
+                }
             }
         }
     }
@@ -260,13 +237,41 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
      * @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);
+    formatMessagesForAnthropic(messages) {
+        let system;
+        if (messages.length > 0 && messages[0]._getType() === "system") {
+            if (typeof messages[0].content !== "string") {
+                throw new Error("Currently only string content messages are supported.");
+            }
+            system = messages[0].content;
+        }
+        const conversationMessages = system !== undefined ? messages.slice(1) : messages;
+        const formattedMessages = conversationMessages.map((message) => {
+            let role;
+            if (typeof message.content !== "string") {
+                throw new Error("Currently only string content messages are supported.");
+            }
+            if (message._getType() === "human") {
+                role = "user";
+            }
+            else if (message._getType() === "ai") {
+                role = "assistant";
+            }
+            else if (message._getType() === "system") {
+                throw new Error("System messages are only permitted as the first passed message.");
+            }
+            else {
+                throw new Error(`Message type "${message._getType()}" is not supported.`);
+            }
+            return {
+                role,
+                content: message.content,
+            };
+        });
+        return {
+            messages: formattedMessages,
+            system,
+        };
     }
     /** @ignore */
     async _generate(messages, options, runManager) {
@@ -274,38 +279,52 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
             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: "",
-            };
+            let finalChunk;
             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;
+                if (finalChunk === undefined) {
+                    finalChunk = chunk;
+                }
+                else {
+                    finalChunk = finalChunk.concat(chunk);
+                }
+            }
+            if (finalChunk === undefined) {
+                throw new Error("No chunks returned from Anthropic API.");
             }
+            return {
+                generations: [
+                    {
+                        text: finalChunk.text,
+                        message: finalChunk.message,
+                    },
+                ],
+            };
         }
         else {
-            response = await this.completionWithRetry({
+            const response = await this.completionWithRetry({
                 ...params,
-                prompt: this.formatMessagesAsPrompt(messages),
+                stream: false,
+                ...this.formatMessagesForAnthropic(messages),
             }, { signal: options.signal });
+            const { content, ...additionalKwargs } = response;
+            if (!Array.isArray(content) || content.length !== 1) {
+                console.log(content);
+                throw new Error("Received multiple content parts in Anthropic response. Only single part messages are currently supported.");
+            }
+            return {
+                generations: [
+                    {
+                        text: content[0].text,
+                        message: new messages_1.AIMessage({
+                            content: content[0].text,
+                            additional_kwargs: additionalKwargs,
+                        }),
+                    },
+                ],
+            };
         }
-        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.
@@ -319,10 +338,17 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                // Prefer LangChain built-in retries
                 maxRetries: 0,
             });
         }
-        const makeCompletionRequest = async () => this.streamingClient.completions.create({ ...request, stream: true }, { headers: request.headers });
+        const makeCompletionRequest = async () => this.streamingClient.beta.messages.create(
+        // TODO: Fix typing once underlying SDK is fixed to not require unnecessary "anthropic-beta" param
+        {
+            ...request,
+            ...this.invocationKwargs,
+            stream: true,
+        });
         return this.caller.call(makeCompletionRequest);
     }
     /** @ignore */
@@ -339,7 +365,12 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
                 maxRetries: 0,
             });
         }
-        const makeCompletionRequest = async () => this.batchClient.completions.create({ ...request, stream: false }, { headers: request.headers });
+        const makeCompletionRequest = async () => this.batchClient.beta.messages.create(
+        // TODO: Fix typing once underlying SDK is fixed to not require unnecessary "anthropic-beta" param
+        {
+            ...request,
+            ...this.invocationKwargs,
+        });
         return this.caller.callWithOptions({ signal: options.signal }, makeCompletionRequest);
     }
     _llmType() {
@@ -350,4 +381,7 @@ class ChatAnthropic extends chat_models_1.BaseChatModel {
         return [];
     }
 }
+exports.ChatAnthropicMessages = ChatAnthropicMessages;
+class ChatAnthropic extends ChatAnthropicMessages {
+}
 exports.ChatAnthropic = ChatAnthropic;

package/dist/chat_models.d.ts

@@ -1,13 +1,14 @@
-import { Anthropic, AI_PROMPT, HUMAN_PROMPT, ClientOptions } from "@anthropic-ai/sdk";
-import type { CompletionCreateParams } from "@anthropic-ai/sdk/resources/completions";
+import { Anthropic, type ClientOptions } from "@anthropic-ai/sdk";
 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[];
+type AnthropicMessage = Anthropic.Beta.MessageParam;
+type AnthropicMessageCreateParams = Omit<Anthropic.Beta.MessageCreateParamsNonStreaming, "anthropic-beta">;
+type AnthropicStreamingMessageCreateParams = Omit<Anthropic.Beta.MessageCreateParamsStreaming, "anthropic-beta">;
+type AnthropicMessageStreamEvent = Anthropic.Beta.MessageStreamEvent;
 /**
  * Input to AnthropicChat class.
  */
@@ -33,7 +34,12 @@ export interface AnthropicInput {
      */
     topP?: number;
     /** A maximum number of tokens to generate before stopping. */
-    maxTokensToSample: number;
+    maxTokens?: number;
+    /**
+     * A maximum number of tokens to generate before stopping.
+     * @deprecated Use "maxTokens" instead.
+     */
+    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.
@@ -69,7 +75,7 @@ type Kwargs = Record<string, any>;
  * @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},
+ * `anthropic.beta.messages`} can be passed through {@link invocationKwargs},
  * even if not explicitly available on this class.
  * @example
  * ```typescript
@@ -81,7 +87,7 @@ type Kwargs = Record<string, any>;
  * console.log(res);
  * ```
  */
-export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
+export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
     static lc_name(): string;
     get lc_secrets(): {
         [key: string]: string;
@@ -93,7 +99,7 @@ export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOpti
     temperature: number;
     topK: number;
     topP: number;
-    maxTokensToSample: number;
+    maxTokens: number;
     modelName: string;
     invocationKwargs?: Kwargs;
     stopSequences?: string[];
@@ -105,31 +111,35 @@ export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOpti
     /**
      * Get the parameters used to invoke the model
      */
-    invocationParams(options?: this["ParsedCallOptions"]): Omit<CompletionCreateParams, "prompt"> & Kwargs;
+    invocationParams(options?: this["ParsedCallOptions"]): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, "messages" | "anthropic-beta"> & Kwargs;
     /** @ignore */
     _identifyingParams(): {
-        metadata?: Anthropic.Completions.CompletionCreateParams.Metadata | undefined;
         stream?: boolean | undefined;
-        max_tokens_to_sample: number;
-        model: "claude-2" | (string & {}) | "claude-instant-1";
+        max_tokens: number;
+        model: string;
+        metadata?: Anthropic.Beta.Messages.MessageCreateParams.Metadata | undefined;
         stop_sequences?: string[] | undefined;
+        system?: string | undefined;
         temperature?: number | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
+        'x-api-key'?: string | 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";
+        max_tokens: number;
+        model: string;
+        metadata?: Anthropic.Beta.Messages.MessageCreateParams.Metadata | undefined;
         stop_sequences?: string[] | undefined;
+        system?: string | undefined;
         temperature?: number | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
+        'x-api-key'?: string | undefined;
         model_name: string;
     };
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
@@ -138,7 +148,10 @@ export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOpti
      * @param messages The base messages to format as a prompt.
      * @returns The formatted prompt.
      */
-    protected formatMessagesAsPrompt(messages: BaseMessage[]): string;
+    protected formatMessagesForAnthropic(messages: BaseMessage[]): {
+        system?: string;
+        messages: AnthropicMessage[];
+    };
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     /**
@@ -146,12 +159,15 @@ export declare class ChatAnthropic<CallOptions extends BaseLanguageModelCallOpti
      * @param request The parameters for creating a completion.
      * @returns A streaming request.
      */
-    protected createStreamWithRetry(request: CompletionCreateParams & Kwargs): Promise<Stream<Anthropic.Completions.Completion>>;
+    protected createStreamWithRetry(request: AnthropicStreamingMessageCreateParams & Kwargs): Promise<Stream<AnthropicMessageStreamEvent>>;
     /** @ignore */
-    protected completionWithRetry(request: CompletionCreateParams & Kwargs, options: {
+    protected completionWithRetry(request: AnthropicMessageCreateParams & Kwargs, options: {
         signal?: AbortSignal;
-    }): Promise<Anthropic.Completions.Completion>;
+    }): Promise<Anthropic.Beta.Message>;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(): never[];
 }
+export declare class ChatAnthropic extends ChatAnthropicMessages {
+}
+export {};

package/dist/chat_models.js

@@ -1,46 +1,8 @@
-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 { Anthropic } from "@anthropic-ai/sdk";
+import { AIMessage, AIMessageChunk, } 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";
-export { AI_PROMPT, HUMAN_PROMPT };
-/**
- * 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.
  *
@@ -50,7 +12,7 @@ export const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
  * @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},
+ * `anthropic.beta.messages`} can be passed through {@link invocationKwargs},
  * even if not explicitly available on this class.
  * @example
  * ```typescript
@@ -62,7 +24,7 @@ export const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
  * console.log(res);
  * ```
  */
-export class ChatAnthropic extends BaseChatModel {
+export class ChatAnthropicMessages extends BaseChatModel {
     static lc_name() {
         return "ChatAnthropic";
     }
@@ -114,7 +76,7 @@ export class ChatAnthropic extends BaseChatModel {
             writable: true,
             value: -1
         });
-        Object.defineProperty(this, "maxTokensToSample", {
+        Object.defineProperty(this, "maxTokens", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -124,7 +86,7 @@ export class ChatAnthropic extends BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "claude-2"
+            value: "claude-2.1"
         });
         Object.defineProperty(this, "invocationKwargs", {
             enumerable: true,
@@ -176,8 +138,8 @@ export class ChatAnthropic extends BaseChatModel {
         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.maxTokens =
+            fields?.maxTokensToSample ?? fields?.maxTokens ?? this.maxTokens;
         this.stopSequences = fields?.stopSequences ?? this.stopSequences;
         this.streaming = fields?.streaming ?? false;
         this.clientOptions = fields?.clientOptions ?? {};
@@ -191,11 +153,9 @@ export class ChatAnthropic extends BaseChatModel {
             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,
+            stop_sequences: options?.stop ?? this.stopSequences,
             stream: this.streaming,
+            max_tokens: this.maxTokens,
             ...this.invocationKwargs,
         };
     }
@@ -219,35 +179,53 @@ export class ChatAnthropic extends BaseChatModel {
         const params = this.invocationParams(options);
         const stream = await this.createStreamWithRetry({
             ...params,
-            prompt: this.formatMessagesAsPrompt(messages),
+            ...this.formatMessagesForAnthropic(messages),
+            stream: true,
         });
-        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;
+            if (data.type === "message_start") {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { content, ...additionalKwargs } = data.message;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const filteredAdditionalKwargs = {};
+                for (const [key, value] of Object.entries(additionalKwargs)) {
+                    if (value !== undefined && value !== null) {
+                        filteredAdditionalKwargs[key] = value;
+                    }
+                }
+                yield new ChatGenerationChunk({
+                    message: new AIMessageChunk({
+                        content: "",
+                        additional_kwargs: filteredAdditionalKwargs,
+                    }),
+                    text: "",
+                });
             }
-            else if (data.stop_reason && !stopReasonSent) {
-                additional_kwargs.stop_reason = data.stop_reason;
-                stopReasonSent = true;
+            else if (data.type === "message_delta") {
+                yield new ChatGenerationChunk({
+                    message: new AIMessageChunk({
+                        content: "",
+                        additional_kwargs: { ...data.delta },
+                    }),
+                    text: "",
+                });
             }
-            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;
+            else if (data.type === "content_block_delta") {
+                const content = data.delta?.text;
+                if (content !== undefined) {
+                    yield new ChatGenerationChunk({
+                        message: new AIMessageChunk({
+                            content,
+                            additional_kwargs: {},
+                        }),
+                        text: content,
+                    });
+                    await runManager?.handleLLMNewToken(content);
+                }
             }
         }
     }
@@ -256,13 +234,41 @@ export class ChatAnthropic extends BaseChatModel {
      * @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);
+    formatMessagesForAnthropic(messages) {
+        let system;
+        if (messages.length > 0 && messages[0]._getType() === "system") {
+            if (typeof messages[0].content !== "string") {
+                throw new Error("Currently only string content messages are supported.");
+            }
+            system = messages[0].content;
+        }
+        const conversationMessages = system !== undefined ? messages.slice(1) : messages;
+        const formattedMessages = conversationMessages.map((message) => {
+            let role;
+            if (typeof message.content !== "string") {
+                throw new Error("Currently only string content messages are supported.");
+            }
+            if (message._getType() === "human") {
+                role = "user";
+            }
+            else if (message._getType() === "ai") {
+                role = "assistant";
+            }
+            else if (message._getType() === "system") {
+                throw new Error("System messages are only permitted as the first passed message.");
+            }
+            else {
+                throw new Error(`Message type "${message._getType()}" is not supported.`);
+            }
+            return {
+                role,
+                content: message.content,
+            };
+        });
+        return {
+            messages: formattedMessages,
+            system,
+        };
     }
     /** @ignore */
     async _generate(messages, options, runManager) {
@@ -270,38 +276,52 @@ export class ChatAnthropic extends BaseChatModel {
             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: "",
-            };
+            let finalChunk;
             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;
+                if (finalChunk === undefined) {
+                    finalChunk = chunk;
+                }
+                else {
+                    finalChunk = finalChunk.concat(chunk);
+                }
+            }
+            if (finalChunk === undefined) {
+                throw new Error("No chunks returned from Anthropic API.");
             }
+            return {
+                generations: [
+                    {
+                        text: finalChunk.text,
+                        message: finalChunk.message,
+                    },
+                ],
+            };
         }
         else {
-            response = await this.completionWithRetry({
+            const response = await this.completionWithRetry({
                 ...params,
-                prompt: this.formatMessagesAsPrompt(messages),
+                stream: false,
+                ...this.formatMessagesForAnthropic(messages),
             }, { signal: options.signal });
+            const { content, ...additionalKwargs } = response;
+            if (!Array.isArray(content) || content.length !== 1) {
+                console.log(content);
+                throw new Error("Received multiple content parts in Anthropic response. Only single part messages are currently supported.");
+            }
+            return {
+                generations: [
+                    {
+                        text: content[0].text,
+                        message: new AIMessage({
+                            content: content[0].text,
+                            additional_kwargs: additionalKwargs,
+                        }),
+                    },
+                ],
+            };
         }
-        const generations = (response.completion ?? "")
-            .split(AI_PROMPT)
-            .map((message) => ({
-            text: message,
-            message: new AIMessage(message),
-        }));
-        return {
-            generations,
-        };
     }
     /**
      * Creates a streaming request with retry.
@@ -315,10 +335,17 @@ export class ChatAnthropic extends BaseChatModel {
                 ...this.clientOptions,
                 ...options,
                 apiKey: this.anthropicApiKey,
+                // Prefer LangChain built-in retries
                 maxRetries: 0,
             });
         }
-        const makeCompletionRequest = async () => this.streamingClient.completions.create({ ...request, stream: true }, { headers: request.headers });
+        const makeCompletionRequest = async () => this.streamingClient.beta.messages.create(
+        // TODO: Fix typing once underlying SDK is fixed to not require unnecessary "anthropic-beta" param
+        {
+            ...request,
+            ...this.invocationKwargs,
+            stream: true,
+        });
         return this.caller.call(makeCompletionRequest);
     }
     /** @ignore */
@@ -335,7 +362,12 @@ export class ChatAnthropic extends BaseChatModel {
                 maxRetries: 0,
             });
         }
-        const makeCompletionRequest = async () => this.batchClient.completions.create({ ...request, stream: false }, { headers: request.headers });
+        const makeCompletionRequest = async () => this.batchClient.beta.messages.create(
+        // TODO: Fix typing once underlying SDK is fixed to not require unnecessary "anthropic-beta" param
+        {
+            ...request,
+            ...this.invocationKwargs,
+        });
         return this.caller.callWithOptions({ signal: options.signal }, makeCompletionRequest);
     }
     _llmType() {
@@ -346,3 +378,5 @@ export class ChatAnthropic extends BaseChatModel {
         return [];
     }
 }
+export class ChatAnthropic extends ChatAnthropicMessages {
+}

package/dist/tests/chat_models.int.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/chat_models.int.test.js

@@ -0,0 +1,272 @@
+/* eslint-disable no-process-env */
+import { expect, test } from "@jest/globals";
+import { HumanMessage } from "@langchain/core/messages";
+import { ChatPromptValue } from "@langchain/core/prompt_values";
+import { PromptTemplate, ChatPromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, } from "@langchain/core/prompts";
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { ChatAnthropicMessages } from "../chat_models.js";
+test("Test ChatAnthropicMessages", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.call([message]);
+    console.log({ res });
+});
+test("Test ChatAnthropicMessages Generate", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.generate([[message], [message]]);
+    expect(res.generations.length).toBe(2);
+    for (const generation of res.generations) {
+        expect(generation.length).toBe(1);
+        for (const message of generation) {
+            console.log(message.text);
+        }
+    }
+    console.log({ res });
+});
+test("Test ChatAnthropicMessages Generate w/ ClientOptions", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        clientOptions: {
+            defaultHeaders: {
+                "Helicone-Auth": "HELICONE_API_KEY",
+            },
+        },
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.generate([[message], [message]]);
+    expect(res.generations.length).toBe(2);
+    for (const generation of res.generations) {
+        expect(generation.length).toBe(1);
+        for (const message of generation) {
+            console.log(message.text);
+        }
+    }
+    console.log({ res });
+});
+test("Test ChatAnthropicMessages Generate with a signal in call options", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+    });
+    const controller = new AbortController();
+    const message = new HumanMessage("How is your day going? Be extremely verbose!");
+    await expect(() => {
+        const res = chat.generate([[message], [message]], {
+            signal: controller.signal,
+        });
+        setTimeout(() => {
+            controller.abort();
+        }, 1000);
+        return res;
+    }).rejects.toThrow();
+}, 10000);
+test("Test ChatAnthropicMessages tokenUsage with a batch", async () => {
+    const model = new ChatAnthropicMessages({
+        temperature: 0,
+        maxRetries: 0,
+        modelName: "claude-instant-1.2",
+    });
+    const res = await model.generate([
+        [new HumanMessage(`Hello!`)],
+        [new HumanMessage(`Hi!`)],
+    ]);
+    console.log({ res });
+});
+test("Test ChatAnthropicMessages in streaming mode", async () => {
+    let nrNewTokens = 0;
+    let streamedCompletion = "";
+    const model = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        streaming: true,
+        callbacks: CallbackManager.fromHandlers({
+            async handleLLMNewToken(token) {
+                nrNewTokens += 1;
+                streamedCompletion += token;
+            },
+        }),
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await model.call([message]);
+    console.log({ res });
+    expect(nrNewTokens > 0).toBe(true);
+    expect(res.content).toBe(streamedCompletion);
+});
+test("Test ChatAnthropicMessages in streaming mode with a signal", async () => {
+    let nrNewTokens = 0;
+    let streamedCompletion = "";
+    const model = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        streaming: true,
+        callbacks: CallbackManager.fromHandlers({
+            async handleLLMNewToken(token) {
+                nrNewTokens += 1;
+                streamedCompletion += token;
+            },
+        }),
+    });
+    const controller = new AbortController();
+    const message = new HumanMessage("Hello! Give me an extremely verbose response");
+    await expect(() => {
+        const res = model.call([message], {
+            signal: controller.signal,
+        });
+        setTimeout(() => {
+            controller.abort();
+        }, 500);
+        return res;
+    }).rejects.toThrow();
+    console.log({ nrNewTokens, streamedCompletion });
+}, 5000);
+test("Test ChatAnthropicMessages prompt value", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.generatePrompt([new ChatPromptValue([message])]);
+    expect(res.generations.length).toBe(1);
+    for (const generation of res.generations) {
+        for (const g of generation) {
+            console.log(g.text);
+        }
+    }
+    console.log({ res });
+});
+test("ChatAnthropicMessages, docs, prompt templates", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        temperature: 0,
+    });
+    const systemPrompt = PromptTemplate.fromTemplate("You are a helpful assistant that translates {input_language} to {output_language}.");
+    const chatPrompt = ChatPromptTemplate.fromMessages([
+        new SystemMessagePromptTemplate(systemPrompt),
+        HumanMessagePromptTemplate.fromTemplate("{text}"),
+    ]);
+    const responseA = await chat.generatePrompt([
+        await chatPrompt.formatPromptValue({
+            input_language: "English",
+            output_language: "French",
+            text: "I love programming.",
+        }),
+    ]);
+    console.log(responseA.generations);
+});
+test("ChatAnthropicMessages, longer chain of messages", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-1.3",
+        maxRetries: 0,
+        temperature: 0,
+    });
+    const chatPrompt = ChatPromptTemplate.fromMessages([
+        HumanMessagePromptTemplate.fromTemplate(`Hi, my name is Joe!`),
+        AIMessagePromptTemplate.fromTemplate(`Nice to meet you, Joe!`),
+        HumanMessagePromptTemplate.fromTemplate("{text}"),
+    ]);
+    const responseA = await chat.generatePrompt([
+        await chatPrompt.formatPromptValue({
+            text: "What did I just say my name was?",
+        }),
+    ]);
+    console.log(responseA.generations);
+});
+test("ChatAnthropicMessages, Anthropic apiUrl set manually via constructor", async () => {
+    // Pass the default URL through (should use this, and work as normal)
+    const anthropicApiUrl = "https://api.anthropic.com";
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        anthropicApiUrl,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.call([message]);
+    console.log({ res });
+});
+test("ChatAnthropicMessages, Claude V2", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-2.1",
+        maxRetries: 0,
+        temperature: 0,
+    });
+    const chatPrompt = ChatPromptTemplate.fromMessages([
+        HumanMessagePromptTemplate.fromTemplate(`Hi, my name is Joe!`),
+        AIMessagePromptTemplate.fromTemplate(`Nice to meet you, Joe!`),
+        HumanMessagePromptTemplate.fromTemplate("{text}"),
+    ]);
+    const responseA = await chat.generatePrompt([
+        await chatPrompt.formatPromptValue({
+            text: "What did I just say my name was?",
+        }),
+    ]);
+    console.log(responseA.generations);
+});
+test("Test ChatAnthropicMessages stream method", async () => {
+    const model = new ChatAnthropicMessages({
+        maxTokens: 50,
+        maxRetries: 0,
+        modelName: "claude-instant-1.2",
+    });
+    const stream = await model.stream("Print hello world.");
+    const chunks = [];
+    for await (const chunk of stream) {
+        console.log(chunk);
+        chunks.push(chunk);
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+});
+test("Test ChatAnthropicMessages stream method with abort", async () => {
+    await expect(async () => {
+        const model = new ChatAnthropicMessages({
+            maxTokens: 500,
+            maxRetries: 0,
+            modelName: "claude-instant-1.2",
+        });
+        const stream = await model.stream("How is your day going? Be extremely verbose.", {
+            signal: AbortSignal.timeout(1000),
+        });
+        for await (const chunk of stream) {
+            console.log(chunk);
+        }
+    }).rejects.toThrow();
+});
+test("Test ChatAnthropicMessages stream method with early break", async () => {
+    const model = new ChatAnthropicMessages({
+        maxTokens: 50,
+        maxRetries: 0,
+        modelName: "claude-instant-1.2",
+    });
+    const stream = await model.stream("How is your day going? Be extremely verbose.");
+    let i = 0;
+    for await (const chunk of stream) {
+        console.log(chunk);
+        i += 1;
+        if (i > 10) {
+            break;
+        }
+    }
+});
+test("Test ChatAnthropicMessages headers passed through", async () => {
+    const chat = new ChatAnthropicMessages({
+        modelName: "claude-instant-1.2",
+        maxRetries: 0,
+        anthropicApiKey: "NOT_REAL",
+        clientOptions: {
+            defaultHeaders: {
+                "X-Api-Key": process.env.ANTHROPIC_API_KEY,
+            },
+        },
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.call([message]);
+    console.log({ res });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -35,8 +35,8 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.10.0",
-    "@langchain/core": "~0.1.2"
+    "@anthropic-ai/sdk": "^0.11.0",
+    "@langchain/core": "~0.1.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",