@celljs/ai-openai 3.4.4

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

@@ -0,0 +1,326 @@
+import { FunctionCallback, FunctionCallingOptions } from '@celljs/ai-core';
+import { Expose, Exclude } from 'class-transformer';
+import { OpenAIModel } from '../api/openai-model';
+import { Constant } from '@celljs/core';
+import { AudioParameters, FunctionTool, ResponseFormat, StreamOptions } from '../api';
+
+/**
+ * Options for the OpenAI Chat API.
+ */
+@Constant(OpenAIChatOptions, new OpenAIChatOptions())
+export class OpenAIChatOptions implements FunctionCallingOptions {
+    static readonly DEFAULT_MODEL = OpenAIModel.GPT_3_5_TURBO;
+
+    /**
+     * ID of the model to use.
+     */
+    model?: string;
+
+    /**
+     * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output
+     * more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend
+     * altering this or top_p but not both.
+     */
+    temperature?: number;
+
+    /**
+     * The maximum number of tokens to generate in the chat completion. The total length of input
+     * tokens and generated tokens is limited by the model's context length.
+     */
+    @Expose({ name: 'max_tokens' })
+    maxTokens?: number;
+
+    /**
+     * An alternative to sampling with temperature, called nucleus sampling, where the model considers the
+     * results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10%
+     * probability mass are considered. We generally recommend altering this or temperature but not both.
+     */
+    @Expose({ name: 'top_p' })
+    topP?: number;
+
+    /**
+     * Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they
+     * appear in the text so far, increasing the model's likelihood to talk about new topics.
+     */
+    @Expose({ name: 'presence_penalty' })
+    presencePenalty?: number;
+
+    /**
+     * Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing
+     * frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
+     */
+    @Expose({ name: 'frequency_penalty' })
+    frequencyPenalty?: number;
+
+    /**
+     * How many chat completion choices to generate for each input message. Note that you will be charged based
+     * on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
+     */
+    n?: number;
+
+    /**
+     * Output types that you would like the model to generate for this request.
+     * Most models are capable of generating text, which is the default.
+     */
+    @Expose({ name: 'modalities' })
+    outputModalities?: string[];
+
+    /**
+     * Audio parameters for the audio generation. Required when audio output is requested with
+     * modalities: ["audio"]
+     */
+    @Expose({ name: 'audio' })
+    outputAudio?: AudioParameters;
+
+    /**
+     * Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object
+     * that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100.
+     */
+    @Expose({ name: 'logit_bias' })
+    logitBias?: Record<string, number>;
+
+    /**
+     * Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities
+     * of each output token returned in the 'content' of 'message'.
+     */
+    logprobs?: boolean;
+
+    /**
+     * An integer between 0 and 5 specifying the number of most likely tokens to return at each token position,
+     * each with an associated log probability. 'logprobs' must be set to 'true' if this parameter is used.
+     */
+    @Expose({ name: 'top_logprobs' })
+    topLogprobs?: number;
+
+    /**
+     * An object specifying the format that the model must output. Setting to { "type":
+     * "json_object" } enables JSON mode, which guarantees the message the model generates is valid JSON.
+     */
+    @Expose({ name: 'response_format' })
+    responseFormat?: ResponseFormat;
+
+    /**
+     * Options for streaming response. Included in the API only if streaming-mode completion is requested.
+     */
+    @Expose({ name: 'stream_options' })
+    streamOptions?: StreamOptions;
+
+    /**
+     * This feature is in Beta. If specified, our system will make a best effort to sample
+     * deterministically, such that repeated requests with the same seed and parameters should return the same result.
+     */
+    seed?: number;
+
+    /**
+     * Up to 4 sequences where the API will stop generating further tokens.
+     */
+    stop?: string[];
+
+    /**
+     * A list of tools the model may call. Currently, only functions are supported as a tool. Use this to
+     * provide a list of functions the model may generate JSON inputs for.
+     */
+    tools?: FunctionTool[];
+
+    /**
+     * Controls which (if any) function is called by the model.
+     */
+    @Expose({ name: 'tool_choice' })
+    toolChoice?: any;
+
+    /**
+     * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
+     */
+    user?: string;
+
+    /**
+     * Whether to enable parallel function calling during tool use.
+     */
+    @Expose({ name: 'parallel_tool_calls' })
+    parallelToolCalls?: boolean;
+
+    /**
+     * Tool Function Callbacks to register with the ChatModel.
+     */
+    @Exclude()
+    functionCallbacks: FunctionCallback[] = [];
+
+    /**
+     * List of functions, identified by their names, to configure for function calling in
+     * the chat completion requests.
+     */
+    @Exclude()
+    functions: Set<string> = new Set<string>();
+
+    /**
+     * If true, the AI will not handle the function calls internally, but will proxy them to the client.
+     */
+    @Exclude()
+    proxyToolCalls?: boolean;
+
+    /**
+     * Optional HTTP headers to be added to the chat completion request.
+     */
+    @Exclude()
+    httpHeaders: Record<string, string> = {};
+
+    /**
+     * Tool context data.
+     */
+    @Exclude()
+    toolContext?: Record<string, any>;
+
+    copy(): OpenAIChatOptions {
+        return OpenAIChatOptions.options(this);
+    }
+
+    static options(fromOptions: OpenAIChatOptions): OpenAIChatOptions {
+        const options = new OpenAIChatOptions();
+        Object.assign(options, fromOptions);
+        options.functionCallbacks = [...(fromOptions.functionCallbacks || [])];
+        options.functions = new Set(fromOptions.functions);
+        options.httpHeaders = { ...fromOptions.httpHeaders };
+        return options;
+    }
+
+    static builder(): OpenAIOptionsBuilder {
+        return new OpenAIOptionsBuilder();
+    }
+}
+
+export class OpenAIOptionsBuilder {
+    private options = new OpenAIChatOptions();
+
+    withModel(model: string): OpenAIOptionsBuilder {
+        this.options.model = model;
+        return this;
+    }
+
+    withTemperature(temperature: number): OpenAIOptionsBuilder {
+        this.options.temperature = temperature;
+        return this;
+    }
+
+    withMaxTokens(maxTokens: number): OpenAIOptionsBuilder {
+        this.options.maxTokens = maxTokens;
+        return this;
+    }
+
+    withTopP(topP: number): OpenAIOptionsBuilder {
+        this.options.topP = topP;
+        return this;
+    }
+
+    withPresencePenalty(presencePenalty: number): OpenAIOptionsBuilder {
+        this.options.presencePenalty = presencePenalty;
+        return this;
+    }
+
+    withFrequencyPenalty(frequencyPenalty: number): OpenAIOptionsBuilder {
+        this.options.frequencyPenalty = frequencyPenalty;
+        return this;
+    }
+
+    withN(n: number): OpenAIOptionsBuilder {
+        this.options.n = n;
+        return this;
+    }
+
+    withOutputModalities(modalities: string[]): OpenAIOptionsBuilder {
+        this.options.outputModalities = modalities;
+        return this;
+    }
+
+    withOutputAudio(audio: AudioParameters): OpenAIOptionsBuilder {
+        this.options.outputAudio = audio;
+        return this;
+    }
+
+    withLogitBias(bias: Record<string, number>): OpenAIOptionsBuilder {
+        this.options.logitBias = bias;
+        return this;
+    }
+
+    withLogprobs(logprobs: boolean): OpenAIOptionsBuilder {
+        this.options.logprobs = logprobs;
+        return this;
+    }
+
+    withTopLogprobs(topLogprobs: number): OpenAIOptionsBuilder {
+        this.options.topLogprobs = topLogprobs;
+        return this;
+    }
+
+    withResponseFormat(format: ResponseFormat): OpenAIOptionsBuilder {
+        this.options.responseFormat = format;
+        return this;
+    }
+
+    withStreamOptions(options: StreamOptions): OpenAIOptionsBuilder {
+        this.options.streamOptions = options;
+        return this;
+    }
+
+    withSeed(seed: number): OpenAIOptionsBuilder {
+        this.options.seed = seed;
+        return this;
+    }
+
+    withStop(stop: string[]): OpenAIOptionsBuilder {
+        this.options.stop = stop;
+        return this;
+    }
+
+    withTools(tools: FunctionTool[]): OpenAIOptionsBuilder {
+        this.options.tools = tools;
+        return this;
+    }
+
+    withToolChoice(choice: any): OpenAIOptionsBuilder {
+        this.options.toolChoice = choice;
+        return this;
+    }
+
+    withUser(user: string): OpenAIOptionsBuilder {
+        this.options.user = user;
+        return this;
+    }
+
+    withParallelToolCalls(parallel: boolean): OpenAIOptionsBuilder {
+        this.options.parallelToolCalls = parallel;
+        return this;
+    }
+
+    withFunctionCallbacks(callbacks: FunctionCallback[]): OpenAIOptionsBuilder {
+        this.options.functionCallbacks = callbacks;
+        return this;
+    }
+
+    withFunctions(functions: Set<string>): OpenAIOptionsBuilder {
+        this.options.functions = functions;
+        return this;
+    }
+
+    withProxyToolCalls(proxy: boolean): OpenAIOptionsBuilder {
+        this.options.proxyToolCalls = proxy;
+        return this;
+    }
+
+    withHttpHeaders(headers: Record<string, string>): OpenAIOptionsBuilder {
+        this.options.httpHeaders = headers;
+        return this;
+    }
+
+    withToolContext(context: Record<string, any>): OpenAIOptionsBuilder {
+        if (!this.options.toolContext) {
+            this.options.toolContext = context;
+        } else {
+            Object.assign(this.options.toolContext, context);
+        }
+        return this;
+    }
+
+    build(): OpenAIChatOptions {
+        return OpenAIChatOptions.options(this.options);
+    }
+}

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

@@ -0,0 +1,112 @@
+import { expect } from 'chai';
+import '../index';
+import { OpenAIEmbeddingModel } from './openai-embedding-model';
+import { EmbeddingOptions, EmbeddingRequest } from '@celljs/ai-core';
+import { createContainer } from '../test/test-container';
+import { OpenAIAPI } from '../api/api-protocol';
+import { MockOpenAIAPI } from '../test/mock-openai-api';
+import { OpenAIEmbeddingOptions } from './openai-embedding-options';
+
+const container = createContainer();
+
+describe('OpenAIEmbeddingModel', () => {
+    let openAIEmbeddingModel: OpenAIEmbeddingModel;
+    let defaultOptions: OpenAIEmbeddingOptions;
+
+    before(() => {
+        container.rebind(OpenAIAPI).to(MockOpenAIAPI).inSingletonScope();
+        openAIEmbeddingModel = container.get(OpenAIEmbeddingModel);
+        defaultOptions = container.get(OpenAIEmbeddingOptions);
+    });
+
+    describe('call', () => {
+        it('should return embedding response for given text', async () => {
+            const request: EmbeddingRequest = {
+                instructions: ['Hello world', 'Another text sample'],
+                inputs: ['Hello world', 'Another text sample'],
+                options: {
+                    model: 'text-embedding-ada-002'
+                }
+            };
+
+            const response = await openAIEmbeddingModel.call(request);
+
+            expect(response).to.have.property('embeddings');
+            expect(response.embeddings).to.be.an('array');
+            expect(response.embeddings.length).to.equal(1);
+            expect(response.embeddings[0].embedding).to.be.an('array');
+            expect(response.metadata).to.have.property('model');
+            expect(response.metadata).to.have.property('usage');
+        });
+
+        it('should throw error when no text is provided', async () => {
+            const request: EmbeddingRequest = {
+                instructions: [],
+                inputs: [],
+                options: {
+                    model: 'text-embedding-ada-002'
+                }
+            };
+
+            try {
+                await openAIEmbeddingModel.call(request);
+                expect.fail('Should throw error for empty instructions');
+            } catch (error) {
+                expect(error.message).to.include('At least one text is required');
+            }
+        });
+
+        it('should throw error when model is not set', async () => {
+            const request: EmbeddingRequest = {
+                instructions: ['Test text'],
+                inputs: ['Test text'],
+                options: {
+                    model: ''
+                }
+            };
+
+            try {
+                await openAIEmbeddingModel.call(request);
+                expect.fail('Should throw error for missing model');
+            } catch (error) {
+                expect(error.message).to.include('Model is not set');
+            }
+        });
+
+        it('should use default model when not specified in request', async () => {
+            // Temporarily set default model for this test
+            const originalModel = defaultOptions.model;
+            defaultOptions.model = 'text-embedding-ada-002';
+
+            const request: EmbeddingRequest = {
+                instructions: ['Test text'],
+                inputs: ['Test text'],
+                options: {}
+            };
+
+            const response = await openAIEmbeddingModel.call(request);
+            expect(response.metadata.model).to.equal('text-embedding-ada-002');
+
+            // Restore original default model
+            defaultOptions.model = originalModel;
+        });
+
+        it('should pass embedding options correctly', async () => {
+            const request: EmbeddingRequest = {
+                instructions: ['Test text'],
+                inputs: ['Test text'],
+                options: {
+                    model: 'text-embedding-ada-002',
+                    dimensions: 512,
+                    encodingFormat: 'float',
+                    user: 'test-user'
+                } as EmbeddingOptions
+            };
+
+            const response = await openAIEmbeddingModel.call(request);
+            expect(response).to.have.property('embeddings');
+            expect(response.embeddings[0]).to.have.property('embedding');
+            expect(response.result).to.equal(response.embeddings[0]);
+        });
+    });
+});

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

@@ -0,0 +1,83 @@
+import {
+    Embedding,
+    EmbeddingModel,
+    EmbeddingOptions,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    EmbeddingResponseMetadata,
+    EmbeddingResultMetadata
+} from '@celljs/ai-core';
+import {
+    EmbeddingRequest as OpenAIEmbeddingsRequest,
+    OpenAIAPI,
+} from '../api';
+import { Assert, Autowired, Component, IllegalArgumentError, Logger } from '@celljs/core';
+import { OpenAIEmbeddingOptions } from './openai-embedding-options';
+
+@Component(EmbeddingModel)
+export class OpenAIEmbeddingModel implements EmbeddingModel {
+
+    @Autowired(OpenAIEmbeddingOptions)
+    protected readonly defaultOptions: OpenAIEmbeddingOptions;
+
+    /**
+     * Low-level access to the OpenAI API.
+     */
+    @Autowired(OpenAIAPI)
+    protected readonly chatApi: OpenAIAPI;
+
+    @Autowired(Logger)
+    protected readonly logger: Logger;
+
+    public async call(request: EmbeddingRequest): Promise<EmbeddingResponse> {
+        Assert.notEmpty(request.instructions, 'At least one text is required!');
+        const openAIRequet = this.createOpenAIEmbeddingsRequest(request.instructions, request.options);
+        const openAIResponse = (await this.chatApi.embed(openAIRequet)).body;
+        Assert.notNull(openAIResponse, 'No embedding data available.');
+
+        const embeddings: Embedding[] = openAIResponse.data.map(embedding => ({
+            embedding: embedding.embedding,
+            index: embedding.index,
+            metadata: EmbeddingResultMetadata.EMPTY,
+            output: embedding.embedding
+        }));
+
+        const embeddingResponseMetadata = <EmbeddingResponseMetadata>{
+            model: openAIResponse.model,
+            usage: openAIResponse.usage,
+            extra: {}
+        };
+        Assert.notEmpty(embeddings, 'No embedding data available.');
+        return {
+            embeddings,
+            result: embeddings[0],
+            results: embeddings,
+            metadata: embeddingResponseMetadata
+        };
+
+    }
+
+    protected createOpenAIEmbeddingsRequest(inputContent: string[], options?: EmbeddingOptions): OpenAIEmbeddingsRequest<string[]> {
+        let runtimeOptions: OpenAIEmbeddingOptions = OpenAIEmbeddingOptions.builder().build();
+        if (options) {
+            runtimeOptions = Object.assign(runtimeOptions, options);
+        }
+
+        runtimeOptions = Object.assign(this.defaultOptions, runtimeOptions);
+
+        // Override the model.
+        if (!runtimeOptions.model) {
+            throw new IllegalArgumentError('Model is not set!');
+        }
+        const model = runtimeOptions.model;
+
+        return new OpenAIEmbeddingsRequest<string[]>(
+            inputContent,
+            model,
+            runtimeOptions.encodingFormat,
+            runtimeOptions.dimensions,
+            runtimeOptions.user
+        );
+    }
+
+}

package/src/common/model/openai-embedding-options.ts

@@ -0,0 +1,72 @@
+import { EmbeddingOptions } from '@celljs/ai-core';
+import { Expose } from 'class-transformer';
+import { Constant } from '@celljs/core';
+
+/**
+ * OpenAI Embedding Options.
+ */
+@Constant(OpenAIEmbeddingOptions, new OpenAIEmbeddingOptions())
+export class OpenAIEmbeddingOptions implements EmbeddingOptions {
+    /**
+     * ID of the model to use.
+     */
+    model?: string;
+
+    /**
+     * The format to return the embeddings in. Can be either float or base64.
+     */
+    @Expose({ name: 'encoding_format' })
+    encodingFormat?: string;
+
+    /**
+     * The number of dimensions the resulting output embeddings should have.
+     * Only supported in text-embedding-3 and later models.
+     */
+    dimensions?: number;
+
+    /**
+     * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
+     */
+    user?: string;
+
+    copy(): OpenAIEmbeddingOptions {
+        return OpenAIEmbeddingOptions.options(this);
+    }
+
+    static options(fromOptions: OpenAIEmbeddingOptions): OpenAIEmbeddingOptions {
+        const options = new OpenAIEmbeddingOptions();
+        return Object.assign(options, fromOptions);
+    }
+
+    static builder(): OpenAIEmbeddingOptionsBuilder {
+        return new OpenAIEmbeddingOptionsBuilder();
+    }
+}
+
+export class OpenAIEmbeddingOptionsBuilder {
+    private options = new OpenAIEmbeddingOptions();
+
+    withModel(model: string): OpenAIEmbeddingOptionsBuilder {
+        this.options.model = model;
+        return this;
+    }
+
+    withEncodingFormat(encodingFormat: string): OpenAIEmbeddingOptionsBuilder {
+        this.options.encodingFormat = encodingFormat;
+        return this;
+    }
+
+    withDimensions(dimensions: number): OpenAIEmbeddingOptionsBuilder {
+        this.options.dimensions = dimensions;
+        return this;
+    }
+
+    withUser(user: string): OpenAIEmbeddingOptionsBuilder {
+        this.options.user = user;
+        return this;
+    }
+
+    build(): OpenAIEmbeddingOptions {
+        return OpenAIEmbeddingOptions.options(this.options);
+    }
+}

package/src/common/module.ts

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

package/src/common/support/index.ts

@@ -0,0 +1,2 @@
+export * from './openai-api-response-headers';
+export * from './openai-response-header-extractor';

package/src/common/support/openai-api-response-headers.ts

@@ -0,0 +1,46 @@
+/**
+ * Enumeration of {@literal OpenAI} API response headers.
+ */
+export enum OpenAIApiResponseHeaders {
+    /**
+     * Total number of requests allowed within timeframe.
+     */
+    REQUESTS_LIMIT_HEADER = 'x-ratelimit-limit-requests',
+
+    /**
+     * Remaining number of requests available in timeframe.
+     */
+    REQUESTS_REMAINING_HEADER = 'x-ratelimit-remaining-requests',
+
+    /**
+     * Duration of time until the number of requests reset.
+     */
+    REQUESTS_RESET_HEADER = 'x-ratelimit-reset-requests',
+
+    /**
+     * Total number of tokens allowed within timeframe.
+     */
+    TOKENS_RESET_HEADER = 'x-ratelimit-reset-tokens',
+
+    /**
+     * Remaining number of tokens available in timeframe.
+     */
+    TOKENS_LIMIT_HEADER = 'x-ratelimit-limit-tokens',
+
+    /**
+     * Duration of time until the number of tokens reset.
+     */
+    TOKENS_REMAINING_HEADER = 'x-ratelimit-remaining-tokens'
+}
+
+/**
+ * Metadata description for OpenAI API response headers.
+ */
+export const OpenAIApiResponseHeadersDescription: Record<OpenAIApiResponseHeaders, string> = {
+    [OpenAIApiResponseHeaders.REQUESTS_LIMIT_HEADER]: 'Total number of requests allowed within timeframe.',
+    [OpenAIApiResponseHeaders.REQUESTS_REMAINING_HEADER]: 'Remaining number of requests available in timeframe.',
+    [OpenAIApiResponseHeaders.REQUESTS_RESET_HEADER]: 'Duration of time until the number of requests reset.',
+    [OpenAIApiResponseHeaders.TOKENS_RESET_HEADER]: 'Total number of tokens allowed within timeframe.',
+    [OpenAIApiResponseHeaders.TOKENS_LIMIT_HEADER]: 'Remaining number of tokens available in timeframe.',
+    [OpenAIApiResponseHeaders.TOKENS_REMAINING_HEADER]: 'Duration of time until the number of tokens reset.'
+};