@celljs/ai-openai 3.4.4

package/src/common/api/response-format.ts

@@ -0,0 +1,109 @@
+export enum ResponseFormatType {
+    TEXT = 'text',
+    JSON_OBJECT = 'json_object',
+    JSON_SCHEMA = 'json_schema'
+}
+
+export class JsonSchema {
+    name: string;
+    schema: Map<string, any>;
+    strict: boolean;
+    constructor(name: string, schema: Map<string, any>, strict: boolean) {
+        this.name = name;
+        this.schema = schema;
+        this.strict = strict;
+    }
+
+    static builder() {
+        return new JsonSchemaBuilder();
+    }
+}
+
+export class JsonSchemaBuilder {
+    private name: string;
+    private schema: Map<string, any>;
+    private strict: boolean;
+
+    withName(name: string) {
+        this.name = name;
+        return this;
+    }
+
+    withSchema(schema: Map<string, any>) {
+        this.schema = schema;
+        return this;
+    }
+
+    withStrict(strict: boolean) {
+        this.strict = strict;
+        return this;
+    }
+
+    build() {
+        return new JsonSchema(this.name, this.schema, this.strict);
+    }
+}
+
+/**
+ * An object specifying the format that the model must output.
+ *
+ * Setting the type to JSON_SCHEMA, enables Structured Outputs which ensures the model
+ * will match your supplied JSON schema. Learn more in the
+ * [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+ *
+ * References: [OpenAi API - ResponseFormat](https://platform.openai.com/docs/api-reference/chat/create#chat-create-response_format),
+ * [JSON Mode](https://platform.openai.com/docs/guides/structured-outputs#json-mode),
+ * [Structured Outputs vs JSON mode](https://platform.openai.com/docs/guides/structured-outputs#structured-outputs-vs-json-mode)
+ */
+export class ResponseFormat {
+    /**
+     * Type Must be one of 'text', 'json_object' or 'json_schema'.
+     */
+    type: ResponseFormatType;
+
+    /**
+     * JSON schema object that describes the format of the JSON object. Only applicable
+     * when type is 'json_schema'.
+     */
+    schema?: JsonSchema;
+
+    /**
+     * Whether the model must strictly adhere to the schema. Only applicable when type is
+     * 'json_schema'.
+     */
+    strict?: boolean;
+
+    constructor(type: ResponseFormatType, schema?: JsonSchema, strict?: boolean) {
+        this.type = type;
+        this.schema = schema;
+        this.strict = strict;
+    }
+
+    static builder() {
+        return new ResponseFormatBuilder();
+    }
+}
+
+export class ResponseFormatBuilder {
+    private type: ResponseFormatType;
+    private schema?: JsonSchema;
+    private strict?: boolean;
+
+    withType(type: ResponseFormatType) {
+        this.type = type;
+        return this;
+    }
+
+    withSchema(schema: JsonSchema) {
+        this.schema = schema;
+        return this;
+    }
+
+    withStrict(strict: boolean) {
+        this.strict = strict;
+        return this;
+    }
+    build() {
+        return new ResponseFormat(this.type, this.schema, this.strict);
+    }
+}

package/src/common/api/usage.ts

@@ -0,0 +1,135 @@
+import { Usage as IUsage } from '@celljs/ai-core';
+import { Expose } from 'class-transformer';
+
+/**
+ * Breakdown of tokens used in the prompt.
+ */
+export class PromptTokensDetails {
+    /**
+     * Audio input tokens present in the prompt.
+     */
+    @Expose({ name: 'audio_tokens' })
+    audioTokens?: number;
+
+    /**
+     * Cached tokens present in the prompt.
+     */
+    @Expose({ name: 'cached_tokens' })
+    cachedTokens?: number;
+
+    constructor(audioTokens?: number, cachedTokens?: number) {
+        this.audioTokens = audioTokens;
+        this.cachedTokens = cachedTokens;
+    }
+}
+
+/**
+ * Breakdown of tokens used in a completion.
+ */
+export class CompletionTokenDetails {
+    /**
+     * Number of tokens generated by the model for reasoning.
+     */
+    @Expose({ name: 'reasoning_tokens' })
+    reasoningTokens?: number;
+
+    /**
+     * Number of tokens generated by the model for accepted predictions.
+     */
+    @Expose({ name: 'accepted_prediction_tokens' })
+    acceptedPredictionTokens?: number;
+
+    /**
+     * Number of tokens generated by the model for audio.
+     */
+    @Expose({ name: 'audio_tokens' })
+    audioTokens?: number;
+
+    /**
+     * Number of tokens generated by the model for rejected predictions.
+     */
+    @Expose({ name: 'rejected_prediction_tokens' })
+    rejectedPredictionTokens?: number;
+
+    constructor(
+        reasoningTokens?: number,
+        acceptedPredictionTokens?: number,
+        audioTokens?: number,
+        rejectedPredictionTokens?: number
+    ) {
+        this.reasoningTokens = reasoningTokens;
+        this.acceptedPredictionTokens = acceptedPredictionTokens;
+        this.audioTokens = audioTokens;
+        this.rejectedPredictionTokens = rejectedPredictionTokens;
+    }
+}
+
+/**
+ * The response object returned from the /embedding endpoint.
+ */
+export class EmbeddingsResponse {
+    /**
+     * The model used for generating the embeddings.
+     */
+    model: string;
+
+    /**
+     * The list of embeddings generated from the model.
+     * Each embedding (list of doubles) corresponds to a single input text.
+     */
+    embeddings: number[][];
+
+    constructor(model: string, embeddings: number[][]) {
+        this.model = model;
+        this.embeddings = embeddings;
+    }
+}
+
+/**
+ * Usage statistics for the completion request.
+ */
+export class Usage implements IUsage {
+    /**
+     * Number of tokens in the generated completion. Only applicable for completion requests.
+     */
+    @Expose({ name: 'completion_tokens' })
+    completionTokens?: number;
+
+    /**
+     * Number of tokens in the prompt.
+     */
+    @Expose({ name: 'prompt_tokens' })
+    promptTokens?: number;
+
+    /**
+     * Total number of tokens used in the request (prompt + completion).
+     */
+    @Expose({ name: 'total_tokens' })
+    totalTokens?: number;
+
+    /**
+     * Breakdown of tokens used in the prompt.
+     */
+    @Expose({ name: 'prompt_tokens_details' })
+    promptTokensDetails?: PromptTokensDetails;
+
+    /**
+     * Breakdown of tokens used in a completion.
+     */
+    @Expose({ name: 'completion_tokens_details' })
+    completionTokenDetails?: CompletionTokenDetails;
+
+    constructor(
+        completionTokens?: number,
+        promptTokens?: number,
+        totalTokens?: number,
+        promptTokensDetails?: PromptTokensDetails,
+        completionTokenDetails?: CompletionTokenDetails
+    ) {
+        this.completionTokens = completionTokens;
+        this.promptTokens = promptTokens;
+        this.totalTokens = totalTokens;
+        this.promptTokensDetails = promptTokensDetails;
+        this.completionTokenDetails = completionTokenDetails;
+    }
+}

package/src/common/index.ts

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

package/src/common/model/index.ts

@@ -0,0 +1,4 @@
+export * from './openai-chat-model';
+export * from './openai-chat-options';
+export * from './openai-embedding-model';
+export * from './openai-embedding-options';

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

@@ -0,0 +1,85 @@
+import { expect } from 'chai';
+import '../index';
+import { OpenAIChatModel } from './openai-chat-model';
+import { AssistantMessage, ChatOptions, FunctionCallbackRegister, PromptTemplate } from '@celljs/ai-core';
+import { createContainer } from '../test/test-container';
+import { OpenAIAPI } from '../api/api-protocol';
+import { MockOpenAIAPI } from '../test/mock-openai-api';
+
+const container = createContainer();
+
+describe('OpenAIChatModel', () => {
+    let openAIChatModel: OpenAIChatModel;
+    let promptTemplate: PromptTemplate;
+
+    before(() => {
+        container.rebind(OpenAIAPI).to(MockOpenAIAPI).inSingletonScope();
+        openAIChatModel = container.get(OpenAIChatModel);
+        promptTemplate = container.get(PromptTemplate);
+        const functionCallbackRegister = container.get<FunctionCallbackRegister>(FunctionCallbackRegister);
+        functionCallbackRegister.register({
+            name: 'getWeather',
+            description: '',
+            inputTypeSchema: '{}',
+            call: async () => ''
+        });
+    });
+
+    describe('call', () => {
+        it('should return a ChatResponse for a given prompt', async () => {
+            const prompt = await promptTemplate.create('Hello', { chatOptions: { model: 'gpt-4' } });
+            const response = await openAIChatModel.call(prompt);
+            expect(response).to.have.property('results');
+            expect(response.results.length).to.be.greaterThan(0);
+            expect(response.results[0].output).to.be.instanceOf(AssistantMessage);
+        });
+
+        it('should handle tool calls correctly', async () => {
+            const prompt = await promptTemplate.create('What is the weather today?', {
+                chatOptions: {
+                    model: 'gpt-4',
+                    isProxyToolCalls: true,
+                    functions: new Set(['getWeather'])
+                } as ChatOptions
+            });
+            const response = await openAIChatModel.call(prompt);
+            expect(response).to.have.property('results');
+            expect(response.results.length).to.be.greaterThan(0);
+            expect(response.metadata).to.have.property('model');
+            expect(response.metadata).to.have.property('usage');
+        });
+    });
+
+    describe('stream', () => {
+        it('should return an Observable of ChatResponse for a given prompt', done => {
+            (async () => {
+                const prompt = await promptTemplate.create('Hello', { chatOptions: { model: 'gpt-4' } });
+                const response$ = await openAIChatModel.stream(prompt);
+                response$.subscribe({
+                    next: response => {
+                        expect(response).to.have.property('results');
+                        expect(response.results.length).to.be.greaterThan(0);
+                        expect(response.results[0].output).to.be.instanceOf(AssistantMessage);
+                    },
+                    complete: () => done()
+                });
+            })();
+        });
+
+        it('should throw an error when trying to stream with audio output', async () => {
+            const prompt = await promptTemplate.create('Hello', {
+                chatOptions: {
+                    model: 'gpt-4',
+                    outputModalities: ['audio']
+                } as ChatOptions
+            });
+            try {
+                await openAIChatModel.stream(prompt);
+                expect.fail('Should have thrown an error');
+            } catch (e) {
+                expect(e).to.be.instanceOf(Error);
+                expect(e.message).to.include('Audio output is not supported');
+            }
+        });
+    });
+});