@celljs/ai-openai 3.4.4

package/src/common/api/index.ts

@@ -0,0 +1,9 @@
+export * from './api-protocol';
+export * from './chat-request';
+export * from './chat-response';
+export * from './embeddings-request';
+export * from './embeddings-response';
+export * from './openai-api';
+export * from './message';
+export * from './openai-model';
+export * from './response-format';

package/src/common/api/message.ts

@@ -0,0 +1,273 @@
+import { Expose, Type } from 'class-transformer';
+
+export enum ChatCompletionFinishReason {
+    /**
+     * The model hit a natural stop point or a provided stop sequence.
+     */
+    STOP = 'stop',
+    /**
+     * The maximum number of tokens specified in the request was reached.
+     */
+    LENGTH = 'length',
+    /**
+     * The content was omitted due to a flag from our content filters.
+     */
+    CONTENT_FILTER = 'content_filter',
+    /**
+     * The model called a tool.
+     */
+    TOOL_CALLS = 'tool_calls',
+    /**
+     * Only for compatibility with Mistral AI API
+     */
+    TOOL_CALL = 'tool_call'
+}
+
+/**
+ * The role of the author of this message.
+ */
+export enum Role {
+    /**
+     * System message.
+     */
+    SYSTEM = 'system',
+    /**
+     * User message.
+     */
+    USER = 'user',
+    /**
+     * Assistant message.
+     */
+    ASSISTANT = 'assistant',
+    /**
+     * Tool message.
+     */
+    TOOL = 'tool'
+}
+
+/**
+ * The function definition.
+ */
+export class ChatCompletionFunction {
+    /**
+     * The name of the function.
+     */
+    name: string;
+    /**
+     * The arguments that the model expects you to pass to the function.
+     */
+    arguments: string;
+}
+
+/**
+ * The relevant tool call.
+ */
+export class ToolCall {
+    /**
+     * The index of the tool call in the list of tool calls. Required in
+     * case of streaming.
+     */
+    index?: number;
+    /**
+     * The ID of the tool call. This ID must be referenced when you submit
+     * the tool outputs in using the Submit tool outputs to run endpoint.
+     */
+    id: string;
+    /**
+     * The type of tool call the output is required for. For now, this is
+     * always function.
+     */
+    type: string;
+    /**
+     * The function definition.
+     */
+    function: ChatCompletionFunction;
+}
+
+/**
+ * Audio response from the model.
+ */
+export class AudioOutput {
+    /**
+     * Unique identifier for the audio response from the model.
+     */
+    id?: string;
+    /**
+     * Audio output from the model.
+     */
+    data?: string;
+    /**
+     * When the audio content will no longer be available on the server.
+     */
+    @Expose({ name: 'expires_at' })
+    expiresAt?: number;
+    /**
+     * Transcript of the audio output from the model.
+     */
+    transcript?: string;
+
+    static create(id?: string, data?: string, expiresAt?: number, transcript?: string): AudioOutput {
+        const audio = new AudioOutput();
+        audio.id = id;
+        audio.data = data;
+        audio.expiresAt = expiresAt;
+        audio.transcript = transcript;
+        return audio;
+    }
+}
+
+/**
+ * The format of the encoded audio data. Currently supports "wav" and "mp3".
+ */
+export enum Format {
+    /**
+     * MP3 audio format.
+     */
+    MP3 = 'mp3',
+    /**
+     * WAV audio format.
+     */
+    WAV = 'wav'
+}
+
+/**
+ * Audio input data.
+ */
+export class InputAudio {
+    /**
+     * Base64 encoded audio data.
+     */
+    data: string;
+    /**
+     * The format of the encoded audio data. Currently supports "wav" and "mp3".
+     */
+    format: Format;
+}
+
+/**
+ * Image content.
+ */
+export class ImageUrl {
+    /**
+     * Either a URL of the image or the base64 encoded image data. The
+     * base64 encoded image data must have a special prefix in the following
+     * format: "data:{mimetype};base64,{base64-encoded-image-data}".
+     */
+    url: string;
+    /**
+     * Specifies the detail level of the image.
+     */
+    detail?: string;
+}
+
+/**
+ * An array of content parts with a defined type. Each MediaContent can be of
+ * either "text", "image_url", or "input_audio" type. Only one option allowed.
+ */
+export class MediaContent {
+    /**
+     * Content type, each can be of type text or image_url.
+     */
+    type: string;
+    /**
+     * The text content of the message.
+     */
+    text: string;
+    /**
+     * The image content of the message. You can pass multiple images
+     * by adding multiple image_url content parts. Image input is only supported when
+     * using the gpt-4-visual-preview model.
+     */
+    @Expose({ name: 'image_url' })
+    @Type(() => ImageUrl)
+    imageUrl: ImageUrl;
+    /**
+     * Audio content part.
+     */
+    @Expose({ name: 'input_audio' })
+    @Type(() => InputAudio)
+    inputAudio: InputAudio;
+
+    static createText(text: string): MediaContent {
+        const content = new MediaContent();
+        content.type = 'text';
+        content.text = text;
+        return content;
+    }
+
+    static createImageUrl(url: string, detail?: string): MediaContent {
+        const content = new MediaContent();
+        content.type = 'image_url';
+        content.imageUrl = new ImageUrl();
+        content.imageUrl.url = url;
+        content.imageUrl.detail = detail;
+        return content;
+    }
+
+    static createInputAudio(data: string, format: Format): MediaContent {
+        const content = new MediaContent();
+        content.type = 'input_audio';
+        content.inputAudio = new InputAudio();
+        content.inputAudio.data = data;
+        content.inputAudio.format = format;
+        return content;
+    }
+}
+
+export class ChatCompletionMessage {
+    /**
+     * The contents of the message. Can be either a {@link MediaContent}
+     * or a {@link String}. The response message content is always a {@link String}.
+     */
+    @Expose({ name: 'content' })
+    content: any;
+    /**
+     * The role of the messages author. Could be one of the {@link Role}
+     * types.
+     */
+    role: Role;
+    /**
+     * An optional name for the participant. Provides the model information to
+     * differentiate between participants of the same role. In case of Function calling,
+     * the name is the function name that the message is responding to.
+     */
+    name?: string;
+    /**
+     * Tool call that this message is responding to. Only applicable for
+     * the {@link Role#TOOL} role and null otherwise.
+     */
+    @Expose({ name: 'tool_call_id' })
+    toolCallId?: string;
+    /**
+     * The tool calls generated by the model, such as function calls.
+     * Applicable only for {@link Role#ASSISTANT} role and null otherwise.
+     */
+    @Expose({ name: 'tool_calls' })
+    toolCalls?: ToolCall[];
+    /**
+     * The refusal message by the assistant. Applicable only for
+     * {@link Role#ASSISTANT} role and null otherwise.
+     */
+    refusal?: string;
+    /**
+     * Audio response from the model.
+     */
+    @Expose({ name: 'audio' })
+    @Type(() => AudioOutput)
+    audioOutput?: AudioOutput;
+
+    /**
+     * 创建一个新的聊天消息实例。
+     *
+     * @param text - 消息内容。
+     * @param role - 消息角色，表示发送者的身份。
+     * @returns 返回一个包含指定内容和角色的 ChatCompletionMessage 实例。
+     */
+    static create(text: any, role: Role): ChatCompletionMessage {
+        const message = new ChatCompletionMessage();
+        message.content = text;
+        message.role = role;
+        return message;
+    }
+
+}

package/src/common/api/openai-api.spec.ts

@@ -0,0 +1,175 @@
+import { expect } from 'chai';
+import { RestOperations } from '@celljs/http';
+import { createContainer } from '../test/test-container';
+import { OpenAIAPI } from './api-protocol';
+import { ChatCompletionRequest } from './chat-request';
+import { EmbeddingRequest } from './embeddings-request';
+import { Role } from './message';
+import '../index';
+
+describe('OpenAIAPI', () => {
+    const container = createContainer();
+    let openaiAPI: OpenAIAPI;
+
+    // Mock response data
+    const mockResponses = {
+        chat: {
+            id: 'chatcmpl-123',
+            object: 'chat.completion',
+            created: 1677652288,
+            model: 'gpt-3.5-turbo',
+            choices: [{
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: 'Hello! How can I help you today?'
+                },
+                finish_reason: 'stop'
+            }],
+            usage: {
+                prompt_tokens: 9,
+                completion_tokens: 12,
+                total_tokens: 21
+            }
+        },
+        stream: {
+            id: 'chatcmpl-123',
+            object: 'chat.completion.chunk',
+            created: 1677652288,
+            model: 'gpt-3.5-turbo',
+            choices: [{
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    content: 'Hello'
+                }
+            }]
+        },
+        embeddings: {
+            object: 'list',
+            data: [{ object: 'embedding', embedding: [0.1, 0.2, 0.3], index: 0 }],
+            model: 'text-embedding-3-small',
+            usage: { prompt_tokens: 8, total_tokens: 8 }
+        }
+    };
+
+    beforeEach(() => {
+        // Configure mock REST operations
+        container.rebind(RestOperations).toConstantValue({
+            post: async (url: string, data: any) => {
+                if (url === '/v1/embeddings') {
+                    return { data: mockResponses.embeddings };
+                }
+                if (data.stream) {
+                    const stream = new ReadableStream({
+                        start(controller) {
+                            controller.enqueue(`data: ${JSON.stringify(mockResponses.stream)}\n\n`);
+                            controller.enqueue('data: [DONE]\n\n');
+                            controller.close();
+                        }
+                    });
+                    return { data: stream };
+                }
+                return { data: mockResponses.chat };
+            }
+        });
+        openaiAPI = container.get(OpenAIAPI);
+    });
+
+    describe('chat', () => {
+        it('should return correct response for non-streaming request', async () => {
+            const request = new ChatCompletionRequest();
+            request.model = 'gpt-3.5-turbo';
+            request.messages = [{ role: Role.USER, content: 'Hello' }];
+
+            const response = await openaiAPI.chat(request);
+
+            expect(response.body.id).to.equal('chatcmpl-123');
+            expect(response.body.choices[0].message.content).to.equal('Hello! How can I help you today?');
+            expect(response.body.usage.totalTokens).to.equal(21);
+        });
+
+        it('should throw error when stream is enabled', async () => {
+            const request = new ChatCompletionRequest();
+            request.model = 'gpt-3.5-turbo';
+            request.messages = [{ role: Role.USER, content: 'Hello' }];
+            request.stream = true;
+            try {
+                await openaiAPI.chat(request);
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.include('Request must set the stream property to false.');
+            }
+        });
+    });
+
+    describe('chat', () => {
+        it('should throw error when stream is disabled', async () => {
+            const request = new ChatCompletionRequest();
+            request.model = 'gpt-3.5-turbo';
+            request.messages = [{ role: Role.USER, content: 'Hello' }];
+            request.stream = false;
+            try {
+                await openaiAPI.chat(request);
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.include('Request must set the stream property to true.');
+            }
+        });
+    });
+
+    describe('streamingChat', () => {
+        it('should handle streaming response correctly', done => {
+            const request = new ChatCompletionRequest();
+            request.model = 'gpt-3.5-turbo';
+            request.messages = [{ role: Role.USER, content: 'Hello' }];
+            request.stream = true;
+
+            openaiAPI.streamingChat(request).then(response$ => {
+                response$.subscribe({
+                    next: chunk => {
+                        expect(chunk.body.id).to.equal('chatcmpl-123');
+                        expect(chunk.body.choices[0].delta.content).to.equal('Hello');
+                        done();
+                    }
+                });
+            });
+        });
+
+        it('should throw error when stream is disabled', async () => {
+            const request = new ChatCompletionRequest();
+            request.model = 'gpt-3.5-turbo';
+            request.messages = [{ role: Role.USER, content: 'Hello' }];
+            request.stream = false;
+
+            try {
+                await openaiAPI.streamingChat(request);
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.include('Request must set the stream property to true.');
+            }
+        });
+    });
+
+    describe('embed', () => {
+        it('should return correct embedding vectors', async () => {
+            const request = EmbeddingRequest.fromInput('Hello world');
+            const response = await openaiAPI.embed(request);
+
+            expect(response.body.object).to.equal('list');
+            expect(response.body.data[0].embedding).to.deep.equal([0.1, 0.2, 0.3]);
+            expect(response.body.model).to.equal('text-embedding-3-small');
+        });
+
+        it('should support batch inputs', async () => {
+            const request = EmbeddingRequest.fromInputAndModel(
+                ['Hello', 'World'],
+                'text-embedding-3-small'
+            );
+
+            const response = await openaiAPI.embed(request);
+            expect(response.body.data[0].embedding).to.deep.equal([0.1, 0.2, 0.3]);
+            expect(response.body.usage.totalTokens).to.equal(8);
+        });
+    });
+});

package/src/common/api/openai-api.ts

@@ -0,0 +1,111 @@
+import { Assert, Autowired, Component, Optional, PostConstruct, Value } from '@celljs/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { HttpHeaders, MediaType, ResponseEntity, RestOperations } from '@celljs/http';
+import { ChatCompletionRequest } from './chat-request';
+import { EmbeddingRequest } from './embeddings-request';
+import { EmbeddingResponse } from './embeddings-response';
+import { ChatCompletion, ChatCompletionChunk } from './chat-response';
+import { OpenAIAPI, OpenAIAPIOptions } from './api-protocol';
+import { instanceToPlain, plainToInstance } from 'class-transformer';
+import { SSEUtil } from '@celljs/ai-core';
+
+@Component(OpenAIAPI)
+export class OpenAIAPIImpl implements OpenAIAPI {
+
+    @Autowired(RestOperations)
+    protected readonly restOperations: RestOperations;
+
+    @Value('cell.ai.openai.api')
+    protected readonly apiOptions: OpenAIAPIOptions;
+
+    @Autowired(OpenAIAPIOptions)
+    @Optional()
+    protected readonly apiOptions2: OpenAIAPIOptions;
+
+    protected finalApiOptions: Required<OpenAIAPIOptions>;
+
+    @PostConstruct()
+    protected init() {
+        this.finalApiOptions = {
+            baseUrl: 'https://api.openai.com',
+            completionsPath: '/v1/chat/completions',
+            embeddingsPath: '/v1/embeddings',
+            ...this.apiOptions,
+            ...this.apiOptions2
+        };
+    }
+
+    async chat(chatRequest: ChatCompletionRequest, additionalHttpHeader?: Record<string, string>): Promise<ResponseEntity<ChatCompletion>> {
+        Assert.isTrue(!chatRequest.stream, 'Request must set the stream property to false.');
+        const { data, status, headers } = await this.restOperations
+            .post(
+                this.finalApiOptions.completionsPath,
+                instanceToPlain(chatRequest),
+                {
+                    baseURL: this.finalApiOptions.baseUrl,
+                    headers: additionalHttpHeader
+                }
+            );
+
+        return {
+            status,
+            headers,
+            body: plainToInstance(ChatCompletion, data)
+        };
+
+    }
+    async streamingChat(chatRequest: ChatCompletionRequest, additionalHttpHeader?: Record<string, string>): Promise<Observable<ResponseEntity<ChatCompletionChunk>>> {
+        Assert.isTrue(!!chatRequest.stream, 'Request must set the stream property to true.');
+        const { data, status, headers } = await this.restOperations
+        .post<ReadableStream>(
+            this.finalApiOptions.completionsPath,
+            instanceToPlain(chatRequest),
+            {
+                baseURL: this.finalApiOptions.baseUrl,
+                headers: {
+                    [HttpHeaders.ACCEPT]: MediaType.TEXT_EVENT_STREAM,
+                    ...additionalHttpHeader
+
+                },
+                responseType: 'stream'
+            }
+        );
+        return SSEUtil.toObservable(data).pipe(map(item =>
+            ({
+                status,
+                headers,
+                body: plainToInstance(ChatCompletionChunk, item.data)
+            })
+        ));
+
+    }
+
+    async embed<T>(embeddingRequest: EmbeddingRequest<T>): Promise<ResponseEntity<EmbeddingResponse>> {
+        // Input text to embed, encoded as a string or array of tokens. To embed multiple
+        // inputs in a single
+        // request, pass an array of strings or array of token arrays.
+        Assert.notNull(embeddingRequest.input, 'The input can not be null.');
+        Assert.isTrue(typeof embeddingRequest.input === 'string' || Array.isArray(embeddingRequest.input),
+                'The input must be either a String, or a List of Strings or List of List of integers.');
+
+        // The input must not exceed the max input tokens for the model (8192 tokens for
+        // text-embedding-ada-002), cannot
+        // be an empty string, and any array must be 2048 dimensions or less.
+        if (Array.isArray(embeddingRequest.input)) {
+            Assert.isTrue(embeddingRequest.input.length > 0, 'The input list can not be empty.');
+            Assert.isTrue(embeddingRequest.input.length <= 2048, 'The list must be 2048 dimensions or less');
+            Assert.isTrue(
+                typeof embeddingRequest.input[0] === 'string' || typeof embeddingRequest.input[0] === 'number' || Array.isArray(embeddingRequest.input[0]),
+                    'The input must be either a String, or a List of Strings or list of list of integers.');
+        }
+        const { data, status, headers } = await this.restOperations
+            .post<EmbeddingResponse>(this.finalApiOptions.embeddingsPath, instanceToPlain(embeddingRequest), { baseURL: this.finalApiOptions.baseUrl });
+        return {
+            status,
+            headers,
+            body: plainToInstance(EmbeddingResponse, data)
+        };
+    }
+
+}

package/src/common/api/openai-model.ts

@@ -0,0 +1,137 @@
+
+/**
+ * OpenAI Chat Completion Models:
+ *
+ * - [GPT-4o](https://platform.openai.com/docs/models/gpt-4o)
+ * - [GPT-4o mini](https://platform.openai.com/docs/models/gpt-4o-mini)
+ * - [GPT-4 and GPT-4 Turbo](https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo)
+ * - [GPT-3.5 Turbo](https://platform.openai.com/docs/models/gpt-3-5-turbo)
+ * - [DALL·E](https://platform.openai.com/docs/models/dall-e)
+ */
+export enum OpenAIModel {
+
+    /**
+     * Points to the most recent snapshot of the o1 model: o1-preview-2024-09-12
+     */
+    O1_PREVIEW = 'o1-preview',
+
+    /**
+     * Latest o1 model snapshot
+     */
+    O1_PREVIEW_2024_09_12 = 'o1-preview-2024-09-12',
+
+    /**
+     * Points to the most recent o1-mini snapshot: o1-mini-2024-09-12
+     */
+    O1_MINI = 'o1-mini',
+
+    /**
+     * Latest o1-mini model snapshot
+     */
+    O1_MINI_2024_09_12 = 'o1-mini-2024-09-12',
+
+    /**
+     * Multimodal flagship model that’s cheaper and faster than GPT-4 Turbo. Currently
+     * points to gpt-4o-2024-05-13.
+     */
+    GPT_4_O = 'gpt-4o',
+
+    /**
+     * Preview release for audio inputs in chat completions.
+     */
+    GPT_4_O_AUDIO_PREVIEW = 'gpt-4o-audio-preview',
+
+    /**
+     * Affordable and intelligent small model for fast, lightweight tasks. GPT-4o mini
+     * is cheaper and more capable than GPT-3.5 Turbo. Currently points to
+     * gpt-4o-mini-2024-07-18.
+     */
+    GPT_4_O_MINI = 'gpt-4o-mini',
+
+    /**
+     * GPT-4 Turbo with Vision The latest GPT-4 Turbo model with vision capabilities.
+     * Vision requests can now use JSON mode and function calling. Currently points to
+     * gpt-4-turbo-2024-04-09.
+     */
+    GPT_4_TURBO = 'gpt-4-turbo',
+
+    /**
+     * GPT-4 Turbo with Vision model. Vision requests can now use JSON mode and
+     * function calling.
+     */
+    GPT_4_TURBO_2024_04_09 = 'gpt-4-turbo-2024-04-09',
+
+    /**
+     * (New) GPT-4 Turbo - latest GPT-4 model intended to reduce cases of “laziness”
+     * where the model doesn’t complete a task. Returns a maximum of 4,096 output
+     * tokens. Context window: 128k tokens
+     * Currently points to gpt-4-0125-preview
+     */
+    GPT_4_0125_PREVIEW = 'gpt-4-0125-preview',
+
+    /**
+     * Currently points to gpt-4-0125-preview - model featuring improved instruction
+     * following, JSON mode, reproducible outputs, parallel function calling, and
+     * more. Returns a maximum of 4,096 output tokens Context window: 128k tokens
+     */
+    GPT_4_TURBO_PREVIEW = 'gpt-4-turbo-preview',
+
+    /**
+     * Currently points to gpt-4-0613. Snapshot of gpt-4 from June 13th 2023 with
+     * improved function calling support. Context window: 8k tokens
+     * Returns a maximum of 4,096 output tokens Context window: 8k tokens
+     */
+    GPT_4 = 'gpt-4',
+
+    /**
+     * Currently points to gpt-3.5-turbo-0125. model with higher accuracy at
+     * responding in requested formats and a fix for a bug which caused a text
+     * encoding issue for non-English language function calls. Returns a maximum of
+     * 4,096 Context window: 16k tokens
+     */
+    GPT_3_5_TURBO = 'gpt-3.5-turbo',
+
+    /**
+     * Currently points to gpt-3.5-turbo-0125. model with higher accuracy at
+     * responding in requested formats and a fix for a bug which caused a text
+     * encoding issue for non-English language function calls. Returns a maximum of
+     * 4,096 Context window: 16k tokens
+     */
+    GPT_3_5_TURBO_0125 = 'gpt-3.5-turbo-0125',
+
+    /**
+     * GPT-3.5 Turbo model with improved instruction following, JSON mode,
+     * reproducible outputs, parallel function calling, and more. Returns a maximum of
+     * 4,096 output tokens. Context window: 16k tokens.
+     */
+    GPT_3_5_TURBO_1106 = 'gpt-3.5-turbo-1106',
+
+    /**
+     * Most capable embedding model for both English and non-English tasks. DIMENSION:
+     * 3072
+     */
+    TEXT_EMBEDDING_3_LARGE = 'text-embedding-3-large',
+
+    /**
+     * Increased performance over 2nd generation ada embedding model. DIMENSION: 1536
+     */
+    TEXT_EMBEDDING_3_SMALL = 'text-embedding-3-small',
+
+    /**
+     * Most capable 2nd generation embedding model, replacing 16 first generation
+     * models. DIMENSION: 1536
+     */
+    TEXT_EMBEDDING_ADA_002 = 'text-embedding-ada-002',
+
+    /**
+     * The latest DALL·E model released in Nov 2023.
+     */
+    DALL_E_3 = 'dall-e-3',
+
+    /**
+     * The previous DALL·E model released in Nov 2022. The 2nd iteration of DALL·E
+     * with more realistic, accurate, and 4x greater resolution images than the
+     * original model.
+     */
+    DALL_E_2 = 'dall-e-2'
+}