@celljs/ai-anthropic 3.4.0

package/src/common/api/event.ts

@@ -0,0 +1,376 @@
+import { Type } from 'class-transformer';
+import { ChatResponse } from './chat-response';
+import { StreamEvent } from '@celljs/ai-core';
+import { ContentBlockType } from './content-block';
+
+/**
+ * The event type of the streamed chunk.
+ */
+export enum EventType {
+    /**
+     * Message start event. Contains a Message object with empty content.
+     */
+    MESSAGE_START = 'message_start',
+
+    /**
+     * Message delta event, indicating top-level changes to the final Message object.
+     */
+    MESSAGE_DELTA = 'message_delta',
+
+    /**
+     * A final message stop event.
+     */
+    MESSAGE_STOP = 'message_stop',
+
+    /**
+     * Content block start event.
+     */
+    CONTENT_BLOCK_START = 'content_block_start',
+
+    /**
+     * Content block delta event.
+     */
+    CONTENT_BLOCK_DELTA = 'content_block_delta',
+
+    /**
+     * A final content block stop event.
+     */
+    CONTENT_BLOCK_STOP = 'content_block_stop',
+
+    /**
+     * Error event.
+     */
+    ERROR = 'error',
+
+    /**
+     * Ping event.
+     */
+    PING = 'ping',
+
+    /**
+     * Artificially created event to aggregate tool use events.
+     */
+    TOOL_USE_AGGREGATE = 'tool_use_aggregate'
+
+}
+
+/**
+ * Anthropic event.
+ */
+export class AnthropicEvent {
+    type: EventType;
+}
+
+/**
+ * Content block body.
+ */
+export class ContentBlockBody {
+    /**
+     * The type of the content block. e.g. "text", "tool_use".
+     */
+    type: string;
+}
+
+/**
+ * Text content block delta.
+ */
+export class ContentBlockText extends ContentBlockBody {
+
+    /*
+     * The text of the message. Applicable for "text" types only.
+     */
+    text: string;
+}
+
+/**
+ * Tool use content block.
+ */
+export class ContentBlockToolUse extends ContentBlockBody {
+    /*
+     * The id of the tool use. Applicable only for tool_use response.
+     */
+    id: string;
+
+    /*
+     * The name of the tool use. Applicable only for tool_use response.
+     */
+    name: string;
+
+    /*
+     * The input of the tool use. Applicable only for tool_use response.
+     */
+    input: Record<string, any>;
+
+    constructor(type: ContentBlockType, id: string, name: string, input: Record<string, any>) {
+        super();
+        this.type = type;
+        this.id = id;
+        this.name = name;
+        this.input = input;
+    }
+}
+
+export class AnthropicEventWithContentBlock extends AnthropicEvent {
+    /**
+     * The content block body.
+     */
+    @Type(() => ContentBlockBody, {
+        discriminator: {
+            property: 'type',
+            subTypes: [
+                { value: ContentBlockText, name: ContentBlockType.TEXT },
+                { value: ContentBlockToolUse, name: ContentBlockType.TOOL_USE }
+            ]
+        }
+    })
+    contentBlock: ContentBlockBody;
+}
+
+/**
+ * Special event used to aggregate multiple tool use events into a single event with
+ * list of aggregated ContentBlockToolUse.
+ */
+export class ToolUseAggregationEvent extends AnthropicEvent {
+    /*
+     * The index of the content block. Applicable only for streaming responses.
+     */
+    index?: number;
+
+    /*
+     * The id of the tool use. Applicable only for tool_use response.
+     */
+    id?: string;
+
+    /*
+     * The name of the tool use. Applicable only for tool_use response.
+     */
+    name?: string;
+
+    /*
+     * The partial JSON content.
+     */
+    partialJson: string = '';
+
+    /*
+     * The tool content blocks.
+     */
+    toolContentBlocks: ContentBlockToolUse[] = [];
+
+    isEmpty(): boolean {
+        return (this.index === undefined || !this.id || !this.name || !this.partialJson);
+    }
+
+    appendPartialJson(partialJson: string): ToolUseAggregationEvent {
+        this.partialJson = this.partialJson + partialJson;
+        return this;
+    }
+
+    squashIntoContentBlock(): void {
+        const map = (this.partialJson) ? JSON.parse(this.partialJson) : {};
+        this.toolContentBlocks.push(new ContentBlockToolUse(ContentBlockType.TOOL_USE, this.id!, this.name!, map));
+        this.index = undefined;
+        this.id = undefined;
+        this.name = undefined;
+        this.partialJson = '';
+    }
+}
+
+/**
+ * Content block delta body.
+ */
+export class ContentBlockDeltaBody {
+    /*
+     * The type of the content block. e.g. "text", "input_json".
+     */
+    type: string;
+}
+
+/**
+ * Text content block delta.
+ */
+export class ContentBlockDeltaText extends ContentBlockDeltaBody {
+    /*
+     * The text of the message. Applicable for "text" types only.
+     */
+    text: string;
+}
+
+/**
+ * JSON content block delta.
+ */
+export class ContentBlockDeltaJson extends ContentBlockDeltaBody {
+    /*
+     * The partial JSON content.
+     */
+    partialJson: string;
+}
+
+/**
+ * Content block stop event.
+ */
+export class ContentBlockStopEvent extends AnthropicEvent {
+    /*
+     * The index of the content block. Applicable only for streaming responses.
+     */
+    index: number;
+}
+
+/**
+ * Content block start event.
+ */
+export class ContentBlockStartEvent extends AnthropicEventWithContentBlock {
+
+    /*
+     * The index of the content block. Applicable only for streaming responses.
+     */
+    index: number;
+}
+
+/**
+ * Content block delta event.
+ */
+export class ContentBlockDeltaEvent extends AnthropicEvent {
+
+    /*
+     * The index of the content block. Applicable only for streaming responses.
+     */
+    index: number;
+
+    /*
+     * The content block delta body.
+     */
+    @Type(() => ContentBlockDeltaBody, {
+        discriminator: {
+            property: 'type',
+            subTypes: [
+                { value: ContentBlockDeltaText, name: ContentBlockType.TEXT_DELTA },
+                { value: ContentBlockDeltaJson, name: ContentBlockType.INPUT_JSON_DELTA }
+            ]
+        }
+    })
+    delta: ContentBlockDeltaBody;
+
+}
+
+/**
+ * Message start event.
+ */
+export class MessageStartEvent  {
+    /*
+     * The event type.
+     */
+    type: EventType;
+
+    /*
+     * The message body.
+     */
+    message: ChatResponse;
+
+    constructor(type: EventType, message: ChatResponse) {
+        this.type = type;
+        this.message = message;
+    }
+}
+
+/**
+ * Message delta event.
+ */
+export class MessageDeltaEvent extends AnthropicEvent {
+
+    /*
+     * The message delta body.
+     */
+    delta: MessageDelta;
+
+    /*
+     * The message delta usage.
+     */
+    usage: MessageDeltaUsage;
+
+}
+
+/**
+ * Message delta.
+ */
+export class MessageDelta {
+    /*
+     * The stop reason.
+     */
+    stopReason: string;
+
+    /*
+     * The stop sequence.
+     */
+    stopSequence: string;
+}
+
+/**
+ * Message delta usage.
+ */
+export class MessageDeltaUsage {
+    /*
+     * The output tokens.
+     */
+    outputTokens: number;
+}
+
+/**
+ * Message stop event.
+ */
+export class MessageStopEvent extends AnthropicEvent {
+
+}
+
+/**
+ * Error event.
+ */
+export class ErrorEvent extends AnthropicEvent {
+
+    /*
+     * The error body.
+     */
+    error: Error;
+}
+
+/**
+ * Error body.
+ */
+export class Error {
+    /*
+     * The error type.
+     */
+    type: string;
+
+    /*
+     * The error message.
+     */
+    message: string;
+}
+
+/**
+ * Ping event.
+ */
+export class PingEvent extends AnthropicEvent {
+
+}
+
+export class AnthropicStreamEvent implements StreamEvent<AnthropicEvent> {
+    event?: EventType;
+    @Type(() => AnthropicEvent, {
+        discriminator: {
+            property: 'type',
+            subTypes: [
+                { value: ContentBlockStartEvent, name: EventType.CONTENT_BLOCK_START },
+                { value: ContentBlockDeltaEvent, name: EventType.CONTENT_BLOCK_DELTA },
+                { value: ContentBlockStopEvent, name: EventType.CONTENT_BLOCK_STOP },
+                { value: PingEvent, name: EventType.PING },
+                { value: ErrorEvent, name: EventType.ERROR },
+                { value: MessageStartEvent, name: EventType.MESSAGE_START },
+                { value: MessageDeltaEvent, name: EventType.MESSAGE_DELTA },
+                { value: MessageStopEvent, name: EventType.MESSAGE_STOP }
+            ]
+        }
+    })
+    data: AnthropicEvent;
+    raw: string[];
+}

package/src/common/api/index.ts

@@ -0,0 +1,9 @@
+export * from './api-protocol';
+export * from './chat-request';
+export * from './chat-response';
+export * from './anthropic-api';
+export * from './event';
+export * from './message';
+export * from './usage';
+export * from './content-block';
+export * from './anthropic-model';

package/src/common/api/message.ts

@@ -0,0 +1,49 @@
+import { Type } from 'class-transformer';
+import { ContentBlock } from './content-block';
+
+/**
+ * The role of the message in the conversation.
+ */
+export enum Role {
+    /**
+     * User message type.
+     */
+    USER = 'user',
+    /**
+     * Assistant message type. Usually the response from the model.
+     */
+    ASSISTANT = 'assistant',
+}
+
+/**
+ * Input messages.
+ *
+ * Our models are trained to operate on alternating user and assistant conversational
+ * turns. When creating a new Message, you specify the prior conversational turns with
+ * the messages parameter, and the model then generates the next Message in the
+ * conversation. Each input message must be an object with a role and content. You can
+ * specify a single user-role message, or you can include multiple user and assistant
+ * messages. The first message must always use the user role. If the final message
+ * uses the assistant role, the response content will continue immediately from the
+ * content in that message. This can be used to constrain part of the model's
+ * response.
+ */
+export class AnthropicMessage {
+    /**
+     * The contents of the message. Can be of one of String or MultiModalContent
+     * types.
+     */
+    @Type(() => ContentBlock)
+    content: ContentBlock[];
+
+    /**
+     * The role of the messages author. Could be one of the {@link Role}
+     * types.
+     */
+    role: Role;
+
+    constructor(content: ContentBlock[], role: Role) {
+        this.content = content;
+        this.role = role;
+    }
+}

package/src/common/api/usage.ts

@@ -0,0 +1,24 @@
+import { Expose } from 'class-transformer';
+
+/**
+ * Usage statistics.
+ */
+export class Usage {
+
+    /**
+     * The number of input tokens which were used.
+     */
+    @Expose({ name: 'input_tokens' })
+    inputTokens: number;
+
+    /**
+     * The number of output tokens which were used.
+     */
+    @Expose({ name: 'output_tokens' })
+    outputTokens: number;
+
+    constructor(inputTokens: number, outputTokens: number) {
+        this.inputTokens = inputTokens;
+        this.outputTokens = outputTokens;
+    }
+}

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './model';

package/src/common/model/anthropic-chat-model.spec.ts

@@ -0,0 +1,67 @@
+import { expect } from 'chai';
+import '../index';
+import { AnthropicChatModel } from './anthropic-chat-model';
+import { AssistantMessage, PromptTemplate } from '@celljs/ai-core';
+import { createContainer } from '../test/test-container';
+import { AnthropicModel } from '../api/anthropic-model';
+import { MockAnthropicAPI } from '../test/mock-anthropic-api';
+import { AnthropicAPI } from '../api/api-protocol';
+
+const container = createContainer();
+
+describe('AnthropicChatModel', () => {
+    let anthropicChatModel: AnthropicChatModel;
+    let promptTemplate: PromptTemplate;
+
+    before(() => {
+        container.rebind(AnthropicAPI).to(MockAnthropicAPI).inSingletonScope();
+        anthropicChatModel = container.get(AnthropicChatModel);
+        promptTemplate = container.get(PromptTemplate);
+    });
+
+    describe('call', () => {
+        it('should return a ChatResponse for a given prompt', async () => {
+            const prompt = await promptTemplate.create('Hello', { chatOptions: { model: AnthropicModel.CLAUDE_3_5_SONNET } });
+            const response = await anthropicChatModel.call(prompt);
+            expect(response).to.have.property('result');
+            expect(response.result.output).to.be.instanceOf(AssistantMessage);
+        });
+
+        it('should throw an error if the model is not set', async () => {
+            const prompt = await promptTemplate.create('Hello', { chatOptions: { model: '' } });
+            try {
+                await anthropicChatModel.call(prompt);
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.equal('Model is not set!');
+            }
+        });
+    });
+
+    describe('stream', () => {
+        it('should return an Observable of ChatResponse for a given prompt', done => {
+            (async () => {
+                const prompt = await promptTemplate.create('Hello', { chatOptions: { model: AnthropicModel.CLAUDE_3_5_SONNET } });
+                const response$ = await anthropicChatModel.stream(prompt);
+                response$.subscribe({
+                    next: response => {
+                        expect(response).to.have.property('result');
+                        expect(response.result.output).to.be.instanceOf(AssistantMessage);
+                    },
+                    complete: () => done()
+                });
+            })();
+        });
+
+        it('should throw an error if the model is not set', async () => {
+            const prompt = await promptTemplate.create('Hello', { chatOptions: { model: '' } });
+            try {
+                await anthropicChatModel.stream(prompt);
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.equal('Model is not set!');
+            }
+        });
+
+    });
+});