@theia/ai-openai 1.46.0-next.241

package/src/browser/openai-preferences.ts

@@ -0,0 +1,84 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { PreferenceSchema } from '@theia/core/lib/browser/preferences/preference-contribution';
+import { AI_CORE_PREFERENCES_TITLE } from '@theia/ai-core/lib/browser/ai-core-preferences';
+
+export const API_KEY_PREF = 'ai-features.openAiOfficial.openAiApiKey';
+export const MODELS_PREF = 'ai-features.openAiOfficial.officialOpenAiModels';
+export const CUSTOM_ENDPOINTS_PREF = 'ai-features.openAiCustom.customOpenAiModels';
+
+export const OpenAiPreferencesSchema: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [API_KEY_PREF]: {
+            type: 'string',
+            markdownDescription: 'Enter an API Key of your official OpenAI Account. **Please note:** By using this preference the Open AI API key will be stored in clear text\
+            on the machine running Theia. Use the environment variable `OPENAI_API_KEY` to set the key securely.',
+            title: AI_CORE_PREFERENCES_TITLE,
+        },
+        [MODELS_PREF]: {
+            type: 'array',
+            description: 'Official OpenAI models to use',
+            title: AI_CORE_PREFERENCES_TITLE,
+            default: ['gpt-4o', 'gpt-4o-2024-08-06', 'gpt-4o-2024-05-13', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-4', 'gpt-3.5-turbo', 'o1-preview'],
+            items: {
+                type: 'string'
+            }
+        },
+        [CUSTOM_ENDPOINTS_PREF]: {
+            type: 'array',
+            title: AI_CORE_PREFERENCES_TITLE,
+            markdownDescription: 'Integrate custom models compatible with the OpenAI API, for example via `vllm`. The required attributes are `model` and `url`.\
+            \n\
+            Optionally, you can\
+            \n\
+            - specify a unique `id` to identify the custom model in the UI. If none is given `model` will be used as `id`.\
+            \n\
+            - provide an `apiKey` to access the API served at the given url. Use `true` to indicate the use of the global OpenAI API key.\
+            \n\
+            - specify `enableStreaming: false` to indicate that streaming shall not be used.\
+            \n\
+            Refer to [our documentation](https://theia-ide.org/docs/user_ai/#openai-compatible-models-eg-via-vllm) for more information.',
+            default: [],
+            items: {
+                type: 'object',
+                properties: {
+                    model: {
+                        type: 'string',
+                        title: 'Model ID'
+                    },
+                    url: {
+                        type: 'string',
+                        title: 'The Open AI API compatible endpoint where the model is hosted'
+                    },
+                    id: {
+                        type: 'string',
+                        title: 'A unique identifier which is used in the UI to identify the custom model',
+                    },
+                    apiKey: {
+                        type: ['string', 'boolean'],
+                        title: 'Either the key to access the API served at the given url or `true` to use the global OpenAI API key',
+                    },
+                    enableStreaming: {
+                        type: 'boolean',
+                        title: 'Indicates whether the streaming API shall be used. `true` by default.',
+                    }
+                }
+            }
+        }
+    }
+};

package/src/common/index.ts

@@ -0,0 +1,16 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+export * from './openai-language-models-manager';

package/src/common/openai-language-models-manager.ts

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+export const OPENAI_LANGUAGE_MODELS_MANAGER_PATH = '/services/open-ai/language-model-manager';
+export const OpenAiLanguageModelsManager = Symbol('OpenAiLanguageModelsManager');
+export interface OpenAiModelDescription {
+    /**
+     * The identifier of the model which will be shown in the UI.
+     */
+    id: string;
+    /**
+     * The model ID as used by the OpenAI API.
+     */
+    model: string;
+    /**
+     * The OpenAI API compatible endpoint where the model is hosted. If not provided the default OpenAI endpoint will be used.
+     */
+    url?: string;
+    /**
+     * The key for the model. If 'true' is provided the global OpenAI API key will be used.
+     */
+    apiKey: string | true | undefined;
+    /**
+     * Indicate whether the streaming API shall be used.
+     */
+    enableStreaming: boolean;
+    /**
+     * Default request settings for the OpenAI model.
+     */
+    defaultRequestSettings?: { [key: string]: unknown };
+}
+export interface OpenAiLanguageModelsManager {
+    apiKey: string | undefined;
+    setApiKey(key: string | undefined): void;
+    createOrUpdateLanguageModels(...models: OpenAiModelDescription[]): Promise<void>;
+    removeLanguageModels(...modelIds: string[]): void
+}

package/src/node/openai-backend-module.ts

@@ -0,0 +1,30 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { OPENAI_LANGUAGE_MODELS_MANAGER_PATH, OpenAiLanguageModelsManager } from '../common/openai-language-models-manager';
+import { ConnectionHandler, RpcConnectionHandler } from '@theia/core';
+import { OpenAiLanguageModelsManagerImpl } from './openai-language-models-manager-impl';
+
+export const OpenAiModelFactory = Symbol('OpenAiModelFactory');
+
+export default new ContainerModule(bind => {
+    bind(OpenAiLanguageModelsManagerImpl).toSelf().inSingletonScope();
+    bind(OpenAiLanguageModelsManager).toService(OpenAiLanguageModelsManagerImpl);
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new RpcConnectionHandler(OPENAI_LANGUAGE_MODELS_MANAGER_PATH, () => ctx.container.get(OpenAiLanguageModelsManager))
+    ).inSingletonScope();
+});

package/src/node/openai-language-model.ts

@@ -0,0 +1,234 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import {
+    LanguageModel,
+    LanguageModelParsedResponse,
+    LanguageModelRequest,
+    LanguageModelRequestMessage,
+    LanguageModelResponse,
+    LanguageModelStreamResponsePart,
+    LanguageModelTextResponse
+} from '@theia/ai-core';
+import { CancellationToken } from '@theia/core';
+import OpenAI from 'openai';
+import { ChatCompletionStream } from 'openai/lib/ChatCompletionStream';
+import { RunnableToolFunctionWithoutParse } from 'openai/lib/RunnableFunction';
+import { ChatCompletionMessageParam } from 'openai/resources';
+
+export const OpenAiModelIdentifier = Symbol('OpenAiModelIdentifier');
+
+function toOpenAIMessage(message: LanguageModelRequestMessage): ChatCompletionMessageParam {
+    return {
+        role: toOpenAiRole(message),
+        content: message.query || ''
+    };
+}
+
+function toOpenAiRole(message: LanguageModelRequestMessage): 'system' | 'user' | 'assistant' {
+    switch (message.actor) {
+        case 'system':
+            return 'system';
+        case 'ai':
+            return 'assistant';
+        default:
+            return 'user';
+    }
+}
+
+export class OpenAiModel implements LanguageModel {
+
+    /**
+     * @param id the unique id for this language model. It will be used to identify the model in the UI.
+     * @param model the model id as it is used by the OpenAI API
+     * @param enableStreaming whether the streaming API shall be used
+     * @param apiKey a function that returns the API key to use for this model, called on each request
+     * @param url the OpenAI API compatible endpoint where the model is hosted. If not provided the default OpenAI endpoint will be used.
+     * @param defaultRequestSettings optional default settings for requests made using this model.
+     */
+    constructor(
+        public readonly id: string,
+        public model: string,
+        public enableStreaming: boolean,
+        public apiKey: () => string | undefined,
+        public url: string | undefined,
+        public defaultRequestSettings?: { [key: string]: unknown }
+    ) { }
+
+    protected getSettings(request: LanguageModelRequest): Record<string, unknown> {
+        const settings = request.settings ? request.settings : this.defaultRequestSettings;
+        if (!settings) {
+            return {};
+        }
+        return settings;
+    }
+
+    async request(request: LanguageModelRequest, cancellationToken?: CancellationToken): Promise<LanguageModelResponse> {
+        const settings = this.getSettings(request);
+        const openai = this.initializeOpenAi();
+
+        if (this.isNonStreamingModel(this.model)) {
+            return this.handleNonStreamingRequest(openai, request);
+        }
+
+        if (request.response_format?.type === 'json_schema' && this.supportsStructuredOutput()) {
+            return this.handleStructuredOutputRequest(openai, request);
+        }
+
+        let runner: ChatCompletionStream;
+        const tools = this.createTools(request);
+        if (tools) {
+            runner = openai.beta.chat.completions.runTools({
+                model: this.model,
+                messages: request.messages.map(toOpenAIMessage),
+                stream: true,
+                tools: tools,
+                tool_choice: 'auto',
+                ...settings
+            });
+        } else {
+            runner = openai.beta.chat.completions.stream({
+                model: this.model,
+                messages: request.messages.map(toOpenAIMessage),
+                stream: true,
+                ...settings
+            });
+        }
+        cancellationToken?.onCancellationRequested(() => {
+            runner.abort();
+        });
+
+        let runnerEnd = false;
+
+        let resolve: (part: LanguageModelStreamResponsePart) => void;
+        runner.on('error', error => {
+            console.error('Error in OpenAI chat completion stream:', error);
+            runnerEnd = true;
+            resolve({ content: error.message });
+        });
+        // we need to also listen for the emitted errors, as otherwise any error actually thrown by the API will not be caught
+        runner.emitted('error').then(error => {
+            console.error('Error in OpenAI chat completion stream:', error);
+            runnerEnd = true;
+            resolve({ content: error.message });
+        });
+        runner.emitted('abort').then(() => {
+            // do nothing, as the abort event is only emitted when the runner is aborted by us
+        });
+        runner.on('message', message => {
+            if (message.role === 'tool') {
+                resolve({ tool_calls: [{ id: message.tool_call_id, finished: true, result: this.getCompletionContent(message) }] });
+            }
+            console.debug('Received Open AI message', JSON.stringify(message));
+        });
+        runner.once('end', () => {
+            runnerEnd = true;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(runner.finalChatCompletion as any);
+        });
+        const asyncIterator = {
+            async *[Symbol.asyncIterator](): AsyncIterator<LanguageModelStreamResponsePart> {
+                runner.on('chunk', chunk => {
+                    if (chunk.choices[0]?.delta) {
+                        resolve({ ...chunk.choices[0]?.delta });
+                    }
+                });
+                while (!runnerEnd) {
+                    const promise = new Promise<LanguageModelStreamResponsePart>((res, rej) => {
+                        resolve = res;
+                    });
+                    yield promise;
+                }
+            }
+        };
+        return { stream: asyncIterator };
+    }
+
+    protected async handleNonStreamingRequest(openai: OpenAI, request: LanguageModelRequest): Promise<LanguageModelTextResponse> {
+        const settings = this.getSettings(request);
+        const response = await openai.chat.completions.create({
+            model: this.model,
+            messages: request.messages.map(toOpenAIMessage),
+            ...settings
+        });
+
+        const message = response.choices[0].message;
+
+        return {
+            text: message.content ?? ''
+        };
+    }
+
+    protected isNonStreamingModel(_model: string): boolean {
+        return !this.enableStreaming;
+    }
+
+    protected supportsStructuredOutput(): boolean {
+        // see https://platform.openai.com/docs/models/gpt-4o
+        return [
+            'gpt-4o',
+            'gpt-4o-2024-08-06',
+            'gpt-4o-mini'
+        ].includes(this.model);
+    }
+
+    protected async handleStructuredOutputRequest(openai: OpenAI, request: LanguageModelRequest): Promise<LanguageModelParsedResponse> {
+        const settings = this.getSettings(request);
+        // TODO implement tool support for structured output (parse() seems to require different tool format)
+        const result = await openai.beta.chat.completions.parse({
+            model: this.model,
+            messages: request.messages.map(toOpenAIMessage),
+            response_format: request.response_format,
+            ...settings
+        });
+        const message = result.choices[0].message;
+        if (message.refusal || message.parsed === undefined) {
+            console.error('Error in OpenAI chat completion stream:', JSON.stringify(message));
+        }
+        return {
+            content: message.content ?? '',
+            parsed: message.parsed
+        };
+    }
+
+    private getCompletionContent(message: OpenAI.Chat.Completions.ChatCompletionToolMessageParam): string {
+        if (Array.isArray(message.content)) {
+            return message.content.join('');
+        }
+        return message.content;
+    }
+
+    protected createTools(request: LanguageModelRequest): RunnableToolFunctionWithoutParse[] | undefined {
+        return request.tools?.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+                function: (args_string: string) => tool.handler(args_string)
+            }
+        } as RunnableToolFunctionWithoutParse));
+    }
+
+    protected initializeOpenAi(): OpenAI {
+        const apiKey = this.apiKey();
+        if (!apiKey && !(this.url)) {
+            throw new Error('Please provide OPENAI_API_KEY in preferences or via environment variable');
+        }
+        // We need to hand over "some" key, even if a custom url is not key protected as otherwise the OpenAI client will throw an error
+        return new OpenAI({ apiKey: apiKey ?? 'no-key', baseURL: this.url });
+    }
+}

package/src/node/openai-language-models-manager-impl.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { LanguageModelRegistry } from '@theia/ai-core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { OpenAiModel } from './openai-language-model';
+import { OpenAiLanguageModelsManager, OpenAiModelDescription } from '../common';
+
+@injectable()
+export class OpenAiLanguageModelsManagerImpl implements OpenAiLanguageModelsManager {
+
+    protected _apiKey: string | undefined;
+
+    @inject(LanguageModelRegistry)
+    protected readonly languageModelRegistry: LanguageModelRegistry;
+
+    get apiKey(): string | undefined {
+        return this._apiKey ?? process.env.OPENAI_API_KEY;
+    }
+
+    // Triggered from frontend. In case you want to use the models on the backend
+    // without a frontend then call this yourself
+    async createOrUpdateLanguageModels(...modelDescriptions: OpenAiModelDescription[]): Promise<void> {
+        for (const modelDescription of modelDescriptions) {
+            const model = await this.languageModelRegistry.getLanguageModel(modelDescription.id);
+            const apiKeyProvider = () => {
+                if (modelDescription.apiKey === true) {
+                    return this.apiKey;
+                }
+                if (modelDescription.apiKey) {
+                    return modelDescription.apiKey;
+                }
+                return undefined;
+            };
+
+            if (model) {
+                if (!(model instanceof OpenAiModel)) {
+                    console.warn(`OpenAI: model ${modelDescription.id} is not an OpenAI model`);
+                    continue;
+                }
+                model.model = modelDescription.model;
+                model.enableStreaming = modelDescription.enableStreaming;
+                model.url = modelDescription.url;
+                model.apiKey = apiKeyProvider;
+                model.defaultRequestSettings = modelDescription.defaultRequestSettings;
+            } else {
+                this.languageModelRegistry.addLanguageModels([
+                    new OpenAiModel(
+                        modelDescription.id,
+                        modelDescription.model,
+                        modelDescription.enableStreaming,
+                        apiKeyProvider,
+                        modelDescription.url,
+                        modelDescription.defaultRequestSettings
+                    )
+                ]);
+            }
+        }
+    }
+
+    removeLanguageModels(...modelIds: string[]): void {
+        this.languageModelRegistry.removeLanguageModels(modelIds);
+    }
+
+    setApiKey(apiKey: string | undefined): void {
+        if (apiKey) {
+            this._apiKey = apiKey;
+        } else {
+            this._apiKey = undefined;
+        }
+    }
+}

package/src/package.spec.ts

@@ -0,0 +1,28 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/* note: this bogus test file is required so that
+   we are able to run mocha unit tests on this
+   package, without having any actual unit tests in it.
+   This way a coverage report will be generated,
+   showing 0% coverage, instead of no report.
+   This file can be removed once we have real unit
+   tests in place. */
+
+describe('ai-openai package', () => {
+
+    it('support code coverage statistics', () => true);
+});