@celljs/ai-anthropic 3.4.0

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

@@ -0,0 +1,187 @@
+import {
+    AssistantMessage,
+    ChatGenerationMetadata,
+    ChatModel,
+    ChatResponse,
+    ChatResponseMetadata,
+    FunctionCallback,
+    Generation,
+    Media,
+    MessageType,
+    Prompt,
+    ToolCall,
+    ToolResponseMessage,
+    Usage,
+    UserMessage
+} from '@celljs/ai-core';
+import { Autowired, Component, IllegalArgumentError, Logger } from '@celljs/core';
+import { Observable } from 'rxjs';
+import { AnthropicAPI, ChatResponse as AnthriopicChatResponse, AnthropicMessage, ChatRequest, ContentBlock, ContentBlockType, Role, Source, Tool } from '../api';
+import { AnthropicChatOptions } from './anthropic-chat-options';
+import { map } from 'rxjs/operators';
+
+@Component(ChatModel)
+export class AnthropicChatModel implements ChatModel {
+    @Autowired(AnthropicChatOptions)
+    protected readonly defaultOptions: AnthropicChatOptions;
+
+    @Autowired(AnthropicAPI)
+    protected readonly chatApi: AnthropicAPI;
+
+    @Autowired(Logger)
+    protected readonly logger: Logger;
+
+    protected getContentBlockTypeByMedia(media: Media): ContentBlockType {
+        if (media.mediaType.startsWith('image')) {
+            return ContentBlockType.IMAGE;
+        } else if (media.mediaType.startsWith('pdf')) {
+            return ContentBlockType.DOCUMENT;
+        }
+        throw new IllegalArgumentError(`Unsupported media type: ${media.mediaType}. Supported types are: images (image/*) and PDF documents (application/pdf)`);
+    }
+
+    protected fromMediaData(mediaData: any): string {
+        if (mediaData instanceof Uint8Array) {
+            return btoa(String.fromCharCode(...mediaData));
+        } else if (typeof mediaData === 'string') {
+            return mediaData;
+        } else {
+            throw new IllegalArgumentError(`Unsupported media data type: ${typeof mediaData}`);
+        }
+    }
+
+    protected resolveFunctionCallbacks(functions: Set<string>): FunctionCallback[] {
+        return [];
+    }
+
+    protected getFunctionTools(functions: Set<string>): Tool[] {
+        return this.resolveFunctionCallbacks(functions).map(func => new Tool(func.name, func.description, JSON.parse(func.inputTypeSchema)));
+    }
+
+    protected createRequest(prompt: Prompt, stream: boolean): ChatRequest {
+        const userMessages = prompt.instructions
+            .filter(message => message.messageType !== MessageType.SYSTEM)
+            .map(message => {
+                if (message.messageType === MessageType.USER) {
+                    const contents = [new ContentBlock(ContentBlockType.TEXT, undefined, message.content)];
+                    if (message instanceof UserMessage) {
+                        if (message.media.length > 0) {
+                            const mediaContent = message.media.map(media => {
+                                const contentBlockType = this.getContentBlockTypeByMedia(media);
+                                const source = new Source('base64', media.mediaType, this.fromMediaData(media.data));
+                                return new ContentBlock(contentBlockType, source);
+                            });
+                            contents.push(...mediaContent);
+                        }
+                    }
+                    return new AnthropicMessage(contents, message.messageType === MessageType.USER ? Role.USER : Role.ASSISTANT);
+                } else if (message.messageType === MessageType.ASSISTANT) {
+                    const assistantMessage = message as AssistantMessage;
+                    const contentBlocks = [];
+                    if (message.content) {
+                        contentBlocks.push(new ContentBlock(ContentBlockType.TEXT, undefined, message.content));
+                    }
+                    if (assistantMessage.toolCalls.length > 0) {
+                        for (const toolCall of assistantMessage.toolCalls) {
+                            contentBlocks.push(
+                                new ContentBlock(ContentBlockType.TOOL_USE, undefined, undefined, undefined, toolCall.id, toolCall.name, JSON.parse(toolCall.arguments))
+                            );
+                        }
+                    }
+                    return new AnthropicMessage(contentBlocks, Role.ASSISTANT);
+                } else if (message.messageType === MessageType.TOOL) {
+                    const toolResponses = (message as ToolResponseMessage).responses.map(
+                        toolResponse => new ContentBlock(ContentBlockType.TOOL_RESULT, undefined, undefined, undefined, toolResponse.id, toolResponse.responseData)
+                    );
+                    return new AnthropicMessage(toolResponses, Role.USER);
+                } else {
+                    throw new IllegalArgumentError(`Unsupported message type: ${message.messageType}`);
+                }
+            });
+
+        const systemPrompt = prompt.instructions
+            .filter(m => m.messageType === MessageType.SYSTEM)
+            .map(m => m.content)
+            .join('\n');
+
+        let request = new ChatRequest(this.defaultOptions.model, userMessages, systemPrompt, this.defaultOptions.maxTokens, this.defaultOptions.temperature, stream);
+
+        if (prompt.options) {
+            request = Object.assign(request, prompt.options);
+        }
+
+        const functionsForThisRequest: Set<string> = new Set();
+
+        if (this.defaultOptions.functions.size > 0) {
+            this.defaultOptions.functions.forEach(func => functionsForThisRequest.add(func));
+        }
+
+        if (functionsForThisRequest.size > 0) {
+            const tools = this.getFunctionTools(functionsForThisRequest);
+            request.tools = tools;
+        }
+
+        return request;
+    }
+
+    protected from(response: AnthriopicChatResponse): ChatResponseMetadata {
+        return ChatResponseMetadata.builder()
+            .id(response.id)
+            .model(response.model)
+            .usage(Usage.from(response.usage.inputTokens, response.usage.outputTokens))
+            .keyValue('stop-reason', response.stopReason)
+            .keyValue('stop-sequence', response.stopSequence)
+            .keyValue('type', response.type)
+            .build();
+    }
+
+    protected toChatResponse(response?: AnthriopicChatResponse): ChatResponse {
+        if (response === undefined) {
+            this.logger.warn('Null chat completion returned');
+            return ChatResponse.from([]);
+        }
+
+        const generations = response.content
+            .filter(content => content.type !== ContentBlockType.TOOL_USE)
+            .map(content => Generation.from(new AssistantMessage(content.text), ChatGenerationMetadata.from(response.stopReason)));
+
+        const allGenerations = [...generations];
+
+       if (response.stopReason && generations.length === 0) {
+           const generation = Generation.from(new AssistantMessage(), ChatGenerationMetadata.from(response.stopReason));
+           allGenerations.push(generation);
+       }
+
+       const toolToUseList = response.content.filter(c => c.type === ContentBlockType.TOOL_USE);
+       if (toolToUseList.length > 0) {
+            const toolCalls: ToolCall[] = [];
+            for (const toolToUse of toolToUseList) {
+                toolCalls.push({
+                    id: toolToUse.id!,
+                    type: 'function',
+                    name: toolToUse.name!,
+                    arguments: JSON.stringify(toolToUse.input)
+                });
+            }
+
+            const assistantMessage = new AssistantMessage('', [], {}, toolCalls);
+            const toolCallGeneration = Generation.from(assistantMessage, ChatGenerationMetadata.from(response.stopReason));
+            allGenerations.push(toolCallGeneration);
+        }
+
+        return ChatResponse.from(allGenerations, this.from(response));
+    }
+
+    async call(prompt: Prompt): Promise<ChatResponse> {
+        const request = this.createRequest(prompt, false);
+        const chatResponse = await this.chatApi.chat(request);
+        return this.toChatResponse(chatResponse);
+    }
+
+    async stream(prompt: Prompt): Promise<Observable<ChatResponse>> {
+        const request = this.createRequest(prompt, true);
+        const chatResponse = await this.chatApi.streamingChat(request);
+        return chatResponse.pipe(map(chunk => this.toChatResponse(chunk)));
+    }
+
+}

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

@@ -0,0 +1,152 @@
+import { FunctionCallback, FunctionCallingOptions } from '@celljs/ai-core';
+import { Exclude, Expose } from 'class-transformer';
+import { Metadata } from '../api/chat-request';
+import { Constant } from '@celljs/core';
+
+/**
+ * The options to be used when sending a chat request to the Anthropic API.
+ */
+@Constant(AnthropicChatOptions, new AnthropicChatOptions())
+export class AnthropicChatOptions implements FunctionCallingOptions {
+
+    model: string;
+
+    @Expose({ name: 'max_tokens' })
+    maxTokens: number;
+
+    metadata: Metadata;
+
+    @Expose({ name: 'stop_sequences' })
+    stopSequences: string[];
+
+    @Expose({ name: 'temperature' })
+    temperature: number;
+
+    @Expose({ name: 'top_p' })
+    topP: number;
+
+    @Expose({ name: 'top_k' })
+    topK: number;
+
+    /**
+     * Tool Function Callbacks to register with the ChatModel. For Prompt
+     * Options the functionCallbacks are automatically enabled for the duration of the
+     * prompt execution. For Default Options the functionCallbacks are registered but
+     * disabled by default. Use the enableFunctions to set the functions from the registry
+     * to be used by the ChatModel chat completion requests.
+     */
+    @Exclude()
+    functionCallbacks: FunctionCallback[] = [];
+
+    /**
+     * List of functions, identified by their names, to configure for function calling in
+     * the chat completion requests. Functions with those names must exist in the
+     * functionCallbacks registry. The {@link #functionCallbacks} from the PromptOptions
+     * are automatically enabled for the duration of the prompt execution
+     *
+     * Note that function enabled with the default options are enabled for all chat
+     * completion requests. This could impact the token count and the billing. If the
+     * functions is set in a prompt options, then the enabled functions are only active
+     * for the duration of this prompt execution
+     */
+    @Exclude()
+    functions: Set<string> = new Set<string>();
+    @Exclude()
+    proxyToolCalls: boolean = false;
+
+    @Exclude()
+    toolContext: Record<string, any> = {};
+
+    static builder(): AnthropicChatOptionsBuilder {
+        return new AnthropicChatOptionsBuilder();
+    }
+
+    static fromOptions(fromOptions: AnthropicChatOptions): AnthropicChatOptions {
+        return AnthropicChatOptions.builder()
+            .model(fromOptions.model)
+            .maxTokens(fromOptions.maxTokens)
+            .metadata(fromOptions.metadata)
+            .stopSequences(fromOptions.stopSequences)
+            .temperature(fromOptions.temperature)
+            .topP(fromOptions.topP)
+            .topK(fromOptions.topK)
+            .functionCallbacks(fromOptions.functionCallbacks)
+            .functions(fromOptions.functions)
+            .proxyToolCalls(fromOptions.proxyToolCalls)
+            .toolContext(fromOptions.toolContext)
+            .build();
+    }
+}
+
+export class AnthropicChatOptionsBuilder  {
+
+    private options: AnthropicChatOptions = new AnthropicChatOptions();
+
+    model(model: string): AnthropicChatOptionsBuilder {
+        this.options.model = model;
+        return this;
+    }
+
+    maxTokens(maxTokens: number): AnthropicChatOptionsBuilder {
+        this.options.maxTokens = maxTokens;
+        return this;
+    }
+
+    metadata(metadata: Metadata): AnthropicChatOptionsBuilder {
+        this.options.metadata = metadata;
+        return this;
+    }
+
+    stopSequences(stopSequences: string[]): AnthropicChatOptionsBuilder {
+        this.options.stopSequences = stopSequences;
+        return this;
+    }
+
+    temperature(temperature: number): AnthropicChatOptionsBuilder {
+        this.options.temperature = temperature;
+        return this;
+    }
+
+    topP(topP: number): AnthropicChatOptionsBuilder {
+        this.options.topP = topP;
+        return this;
+    }
+
+    topK(topK: number): AnthropicChatOptionsBuilder {
+        this.options.topK = topK;
+        return this;
+    }
+
+    functionCallbacks(functionCallbacks: FunctionCallback[]): AnthropicChatOptionsBuilder {
+        this.options.functionCallbacks = functionCallbacks;
+        return this;
+    }
+
+    functions(functions: Set<string>): AnthropicChatOptionsBuilder {
+        this.options.functions = functions;
+        return this;
+    }
+
+    function(functionName: string): AnthropicChatOptionsBuilder {
+        this.options.functions.add(functionName);
+        return this;
+    }
+
+    proxyToolCalls(proxyToolCalls: boolean): AnthropicChatOptionsBuilder {
+        this.options.proxyToolCalls = proxyToolCalls;
+        return this;
+    }
+
+    toolContext(toolContext: Record<string, any>): AnthropicChatOptionsBuilder {
+        if (this.options.toolContext === undefined) {
+            this.options.toolContext = toolContext;
+        } else {
+            this.options.toolContext = { ...this.options.toolContext, ...toolContext };
+        }
+        return this;
+    }
+
+    build(): AnthropicChatOptions {
+        return this.options;
+    }
+}

package/src/common/model/index.ts

@@ -0,0 +1,2 @@
+export * from './anthropic-chat-model';
+export * from './anthropic-chat-options';

package/src/common/module.ts

@@ -0,0 +1,4 @@
+import { autoBind } from '@celljs/core';
+import './index';
+
+export default autoBind();

package/src/common/test/mock-anthropic-api.ts

@@ -0,0 +1,62 @@
+import { Component } from '@celljs/core';
+import { Observable, from } from 'rxjs';
+import { AnthropicAPI } from '../api/api-protocol';
+import { ChatRequest } from '../api/chat-request';
+import { ChatResponse } from '../api/chat-response';
+import { ContentBlockType } from '../api/content-block';
+import { Role } from '../api/message';
+
+@Component(AnthropicAPI)
+export class MockAnthropicAPI implements AnthropicAPI {
+    async chat(chatRequest: ChatRequest): Promise<ChatResponse> {
+        if (chatRequest.stream) {
+            throw new Error('Request must set the stream property to false.');
+        }
+
+        return new ChatResponse(
+            'msg_123',
+            'message',
+            Role.ASSISTANT,
+            [
+                {
+                    type: ContentBlockType.TEXT,
+                    text: 'How can I assist you today?'
+                }
+            ],
+            chatRequest.model,
+            'end_turn',
+            undefined,
+            {
+                inputTokens: 10,
+                outputTokens: 20
+            }
+        );
+    }
+
+    async streamingChat(chatRequest: ChatRequest): Promise<Observable<ChatResponse>> {
+        if (!chatRequest.stream) {
+            throw new Error('Request must set the stream property to true.');
+        }
+
+        const response = new ChatResponse(
+            'msg_123',
+            'message',
+            Role.ASSISTANT,
+            [
+                {
+                    type: ContentBlockType.TEXT,
+                    text: 'How can I assist you today?'
+                }
+            ],
+            chatRequest.model,
+            'end_turn',
+            undefined,
+            {
+                inputTokens: 10,
+                outputTokens: 20
+            }
+        );
+
+        return from([response]);
+    }
+}

package/src/common/test/test-container.ts

@@ -0,0 +1,12 @@
+import { coreTestModule } from '@celljs/core/lib/common/test/test-module';
+import httpModule from '@celljs/http/lib/common/module';
+import { autoBind, ContainerFactory, ContainerProvider } from '@celljs/core';
+import '../index';
+
+const ollamaTestModule = autoBind();
+
+export const createContainer = () => {
+    const container = ContainerFactory.create(coreTestModule, httpModule, ollamaTestModule);
+    ContainerProvider.set(container);
+    return container;
+};

package/src/common/utils/index.ts

@@ -0,0 +1 @@
+export * from './stream-util';

package/src/common/utils/stream-util.ts

@@ -0,0 +1,142 @@
+import { Assert } from '@celljs/core';
+import { ChatResponse, ChatResponseBuilderReference } from '../api/chat-response';
+import {
+    ContentBlockDeltaEvent,
+    ContentBlockDeltaJson,
+    ContentBlockDeltaText,
+    ContentBlockStartEvent,
+    ContentBlockText,
+    ContentBlockToolUse,
+    EventType,
+    MessageDeltaEvent,
+    MessageStartEvent,
+    ToolUseAggregationEvent,
+    AnthropicEvent
+} from '../api/event';
+import { ContentBlock, ContentBlockType } from '../api/content-block';
+
+export abstract class StreamUtil {
+    static isToolUseStart(event: AnthropicEvent): boolean {
+        if (!event || !event.type || event.type !== EventType.CONTENT_BLOCK_START) {
+            return false;
+        }
+        return (event as ContentBlockStartEvent).contentBlock.type === ContentBlockType.TOOL_USE;
+    }
+
+    static isToolUseFinish(event: AnthropicEvent): boolean {
+        if (!event || !event.type || event.type !== EventType.CONTENT_BLOCK_STOP) {
+            return false;
+        }
+        return true;
+    }
+
+    static mergeToolUseEvents(previousEvent: AnthropicEvent, event: AnthropicEvent): AnthropicEvent {
+        if (!previousEvent || !event) {
+            return event;
+        }
+
+        const eventAggregator = previousEvent as ToolUseAggregationEvent;
+
+        if (event.type === EventType.CONTENT_BLOCK_START) {
+            const contentBlockStart = event as ContentBlockStartEvent;
+
+            if (contentBlockStart.contentBlock.type === ContentBlockType.TOOL_USE) {
+                const cbToolUse = contentBlockStart.contentBlock as ContentBlockToolUse;
+
+                eventAggregator.id = cbToolUse.id;
+                eventAggregator.name = cbToolUse.name;
+                eventAggregator.index = contentBlockStart.index;
+                eventAggregator.partialJson = '';
+            }
+        } else if (event.type === EventType.CONTENT_BLOCK_DELTA) {
+            const contentBlockDelta = event as ContentBlockDeltaEvent;
+            Assert.isTrue(
+                contentBlockDelta.delta.type === ContentBlockType.INPUT_JSON_DELTA,
+                'The json content block delta should have been aggregated. Unsupported content block type: ' + contentBlockDelta.delta.type
+            );
+
+            if (contentBlockDelta.delta.type === ContentBlockType.INPUT_JSON_DELTA) {
+                return eventAggregator.appendPartialJson((contentBlockDelta.delta as ContentBlockDeltaJson).partialJson);
+            }
+        } else if (event.type === EventType.CONTENT_BLOCK_STOP) {
+            if (!eventAggregator.isEmpty()) {
+                eventAggregator.squashIntoContentBlock();
+                return eventAggregator;
+            }
+        }
+
+        return event;
+    }
+
+    static eventToChatResponse(event: AnthropicEvent): ChatResponse {
+        if (event.type === EventType.MESSAGE_START) {
+            ChatResponseBuilderReference.reset();
+            const messageStartEvent = event as MessageStartEvent;
+            ChatResponseBuilderReference.get()
+                .withType(event.type)
+                .withId(messageStartEvent.message.id)
+                .withRole(messageStartEvent.message.role)
+                .withModel(messageStartEvent.message.model)
+                .withUsage(messageStartEvent.message.usage)
+                .withContent([]);
+
+        } else if (event.type === EventType.TOOL_USE_AGGREGATE) {
+            const eventToolUseBuilder = event as ToolUseAggregationEvent;
+
+            if (eventToolUseBuilder.toolContentBlocks && eventToolUseBuilder.toolContentBlocks.length > 0) {
+                const content = eventToolUseBuilder.toolContentBlocks.map(
+                    toolToUse => new ContentBlock(ContentBlockType.TOOL_USE, undefined, undefined, undefined, toolToUse.id, toolToUse.name, toolToUse.input)
+                );
+                ChatResponseBuilderReference.get().withContent(content);
+
+            }
+        } else if (event.type === EventType.CONTENT_BLOCK_START) {
+            const contentBlockStartEvent = event as ContentBlockStartEvent;
+
+            Assert.isTrue(
+                contentBlockStartEvent.contentBlock.type === ContentBlockType.TEXT,
+                'The json content block should have been aggregated. Unsupported content block type: ' + contentBlockStartEvent.contentBlock.type
+            );
+
+            if (contentBlockStartEvent.contentBlock.type === ContentBlockType.TEXT) {
+                const contentBlockText = contentBlockStartEvent.contentBlock as ContentBlockText;
+                ChatResponseBuilderReference
+                    .get()
+                    .withType(event.type)
+                    .withContent([new ContentBlock(ContentBlockType.TEXT, undefined, contentBlockText.text, contentBlockStartEvent.index)]);
+            }
+        } else if (event.type === EventType.CONTENT_BLOCK_DELTA) {
+            const contentBlockDeltaEvent = event as ContentBlockDeltaEvent;
+
+            if (contentBlockDeltaEvent.delta.type === ContentBlockType.TEXT_DELTA) {
+                const deltaTxt = contentBlockDeltaEvent.delta as ContentBlockDeltaText;
+                ChatResponseBuilderReference
+                    .get()
+                    .withType(event.type)
+                    .withContent([new ContentBlock(ContentBlockType.TEXT_DELTA, undefined, deltaTxt.text, contentBlockDeltaEvent.index)]);
+            }
+        } else if (event.type === EventType.MESSAGE_DELTA) {
+            ChatResponseBuilderReference.get().withType(event.type);
+
+            const messageDeltaEvent = event as MessageDeltaEvent;
+
+            if (messageDeltaEvent.delta.stopReason) {
+                ChatResponseBuilderReference.get().withStopReason(messageDeltaEvent.delta.stopReason);
+            }
+
+            if (messageDeltaEvent.delta.stopSequence) {
+                ChatResponseBuilderReference.get().withStopSequence(messageDeltaEvent.delta.stopSequence);
+            }
+
+            if (messageDeltaEvent.usage) {
+                ChatResponseBuilderReference.get().withOutputTokens(messageDeltaEvent.usage.outputTokens);
+            }
+        } else if (event.type === EventType.MESSAGE_STOP) {
+            // pass through
+        } else {
+            ChatResponseBuilderReference.get().withType(event.type).withContent([]);
+        }
+
+        return ChatResponseBuilderReference.get().build();
+    }
+}

package/src/package.spec.ts

@@ -0,0 +1,4 @@
+describe('ai-authropic package', () => {
+
+    it('support ai-authropic coverage statistics', () => {});
+});