@theia/ai-core 1.54.0

package/src/common/language-model.ts

@@ -0,0 +1,237 @@
+// *****************************************************************************
+// 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 { ContributionProvider, ILogger, isFunction, isObject, Event, Emitter, CancellationToken } from '@theia/core';
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+
+export type MessageActor = 'user' | 'ai' | 'system';
+
+export interface LanguageModelRequestMessage {
+    actor: MessageActor;
+    type: 'text';
+    query: string;
+}
+export const isLanguageModelRequestMessage = (obj: unknown): obj is LanguageModelRequestMessage =>
+    !!(obj && typeof obj === 'object' &&
+        'type' in obj &&
+        typeof (obj as { type: unknown }).type === 'string' &&
+        (obj as { type: unknown }).type === 'text' &&
+        'query' in obj &&
+        typeof (obj as { query: unknown }).query === 'string'
+    );
+export interface ToolRequest {
+    id: string;
+    name: string;
+    parameters?: { type?: 'object', properties: Record<string, { type: string, [key: string]: unknown }> };
+    description?: string;
+    handler: (arg_string: string) => Promise<unknown>;
+}
+export interface LanguageModelRequest {
+    messages: LanguageModelRequestMessage[],
+    tools?: ToolRequest[];
+    response_format?: { type: 'text' } | { type: 'json_object' } | ResponseFormatJsonSchema;
+    settings?: { [key: string]: unknown };
+}
+export interface ResponseFormatJsonSchema {
+    type: 'json_schema';
+    json_schema: {
+        name: string,
+        description?: string,
+        schema?: Record<string, unknown>,
+        strict?: boolean | null
+    };
+}
+
+export interface LanguageModelTextResponse {
+    text: string;
+}
+export const isLanguageModelTextResponse = (obj: unknown): obj is LanguageModelTextResponse =>
+    !!(obj && typeof obj === 'object' && 'text' in obj && typeof (obj as { text: unknown }).text === 'string');
+
+export interface LanguageModelStreamResponsePart {
+    content?: string | null;
+    tool_calls?: ToolCall[];
+}
+
+export interface ToolCall {
+    id?: string;
+    function?: {
+        arguments?: string;
+        name?: string;
+    },
+    finished?: boolean;
+    result?: string;
+}
+
+export interface LanguageModelStreamResponse {
+    stream: AsyncIterable<LanguageModelStreamResponsePart>;
+}
+export const isLanguageModelStreamResponse = (obj: unknown): obj is LanguageModelStreamResponse =>
+    !!(obj && typeof obj === 'object' && 'stream' in obj);
+
+export interface LanguageModelParsedResponse {
+    parsed: unknown;
+    content: string;
+}
+export const isLanguageModelParsedResponse = (obj: unknown): obj is LanguageModelParsedResponse =>
+    !!(obj && typeof obj === 'object' && 'parsed' in obj && 'content' in obj);
+
+export type LanguageModelResponse = LanguageModelTextResponse | LanguageModelStreamResponse | LanguageModelParsedResponse;
+
+///////////////////////////////////////////
+// Language Model Provider
+///////////////////////////////////////////
+
+export const LanguageModelProvider = Symbol('LanguageModelProvider');
+export type LanguageModelProvider = () => Promise<LanguageModel[]>;
+
+// See also VS Code `ILanguageModelChatMetadata`
+export interface LanguageModelMetaData {
+    readonly id: string;
+    readonly name?: string;
+    readonly vendor?: string;
+    readonly version?: string;
+    readonly family?: string;
+    readonly maxInputTokens?: number;
+    readonly maxOutputTokens?: number;
+}
+
+export namespace LanguageModelMetaData {
+    export function is(arg: unknown): arg is LanguageModelMetaData {
+        return isObject(arg) && 'id' in arg;
+    }
+}
+
+export interface LanguageModel extends LanguageModelMetaData {
+    request(request: LanguageModelRequest, cancellationToken?: CancellationToken): Promise<LanguageModelResponse>;
+}
+
+export namespace LanguageModel {
+    export function is(arg: unknown): arg is LanguageModel {
+        return isObject(arg) && 'id' in arg && isFunction(arg.request);
+    }
+}
+
+// See also VS Code `ILanguageModelChatSelector`
+interface VsCodeLanguageModelSelector {
+    readonly identifier?: string;
+    readonly name?: string;
+    readonly vendor?: string;
+    readonly version?: string;
+    readonly family?: string;
+    readonly tokens?: number;
+}
+
+export interface LanguageModelSelector extends VsCodeLanguageModelSelector {
+    readonly agent: string;
+    readonly purpose: string;
+}
+
+export type LanguageModelRequirement = Omit<LanguageModelSelector, 'agent'>;
+
+export const LanguageModelRegistry = Symbol('LanguageModelRegistry');
+export interface LanguageModelRegistry {
+    onChange: Event<{ models: LanguageModel[] }>;
+    addLanguageModels(models: LanguageModel[]): void;
+    getLanguageModels(): Promise<LanguageModel[]>;
+    getLanguageModel(id: string): Promise<LanguageModel | undefined>;
+    removeLanguageModels(id: string[]): void;
+    selectLanguageModel(request: LanguageModelSelector): Promise<LanguageModel | undefined>;
+    selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[]>;
+}
+
+@injectable()
+export class DefaultLanguageModelRegistryImpl implements LanguageModelRegistry {
+    @inject(ILogger)
+    protected logger: ILogger;
+    @inject(ContributionProvider) @named(LanguageModelProvider)
+    protected readonly languageModelContributions: ContributionProvider<LanguageModelProvider>;
+
+    protected languageModels: LanguageModel[] = [];
+
+    protected markInitialized: () => void;
+    protected initialized: Promise<void> = new Promise(resolve => { this.markInitialized = resolve; });
+
+    protected changeEmitter = new Emitter<{ models: LanguageModel[] }>();
+    onChange = this.changeEmitter.event;
+
+    @postConstruct()
+    protected init(): void {
+        const contributions = this.languageModelContributions.getContributions();
+        const promises = contributions.map(provider => provider());
+        Promise.allSettled(promises).then(results => {
+            for (const result of results) {
+                if (result.status === 'fulfilled') {
+                    this.languageModels.push(...result.value);
+                } else {
+                    this.logger.error('Failed to add some language models:', result.reason);
+                }
+            }
+            this.markInitialized();
+        });
+    }
+
+    addLanguageModels(models: LanguageModel[]): void {
+        models.forEach(model => {
+            if (this.languageModels.find(lm => lm.id === model.id)) {
+                console.warn(`Tried to add already existing language model with id ${model.id}. The new model will be ignored.`);
+                return;
+            }
+            this.languageModels.push(model);
+            this.changeEmitter.fire({ models: this.languageModels });
+        });
+    }
+
+    async getLanguageModels(): Promise<LanguageModel[]> {
+        await this.initialized;
+        return this.languageModels;
+    }
+
+    async getLanguageModel(id: string): Promise<LanguageModel | undefined> {
+        await this.initialized;
+        return this.languageModels.find(model => model.id === id);
+    }
+
+    removeLanguageModels(ids: string[]): void {
+        ids.forEach(id => {
+            const index = this.languageModels.findIndex(model => model.id === id);
+            if (index !== -1) {
+                this.languageModels.splice(index, 1);
+                this.changeEmitter.fire({ models: this.languageModels });
+            } else {
+                console.warn(`Language model with id ${id} was requested to be removed, however it does not exist`);
+            }
+        });
+    }
+
+    async selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[]> {
+        await this.initialized;
+        // TODO check for actor and purpose against settings
+        return this.languageModels.filter(model => isModelMatching(request, model));
+    }
+
+    async selectLanguageModel(request: LanguageModelSelector): Promise<LanguageModel | undefined> {
+        return (await this.selectLanguageModels(request))[0];
+    }
+}
+
+export function isModelMatching(request: LanguageModelSelector, model: LanguageModel): boolean {
+    return (!request.identifier || model.id === request.identifier) &&
+        (!request.name || model.name === request.name) &&
+        (!request.vendor || model.vendor === request.vendor) &&
+        (!request.version || model.version === request.version) &&
+        (!request.family || model.family === request.family);
+}

package/src/common/prompt-service-util.ts

@@ -0,0 +1,21 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+/** Should match the one from VariableResolverService. The format is `{{variableName:arg}}`. */
+export const PROMPT_VARIABLE_REGEX = /\{\{\s*(.*?)\s*\}\}/g;
+
+/** Match function/tool references in the prompt. The format is `~{functionId}`. */
+export const PROMPT_FUNCTION_REGEX = /\~\{\s*(.*?)\s*\}/g;

package/src/common/prompt-service.spec.ts

@@ -0,0 +1,98 @@
+// *****************************************************************************
+// 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 'reflect-metadata';
+
+import { expect } from 'chai';
+import { Container } from 'inversify';
+import { PromptService, PromptServiceImpl } from './prompt-service';
+import { DefaultAIVariableService, AIVariableService } from './variable-service';
+
+describe('PromptService', () => {
+    let promptService: PromptService;
+
+    beforeEach(() => {
+        const container = new Container();
+        container.bind<PromptService>(PromptService).to(PromptServiceImpl).inSingletonScope();
+
+        const variableService = new DefaultAIVariableService({ getContributions: () => [] });
+        const nameVariable = { id: 'test', name: 'name', description: 'Test name ' };
+        variableService.registerResolver(nameVariable, {
+            canResolve: () => 100,
+            resolve: async () => ({ variable: nameVariable, value: 'Jane' })
+        });
+        container.bind<AIVariableService>(AIVariableService).toConstantValue(variableService);
+
+        promptService = container.get<PromptService>(PromptService);
+        promptService.storePrompt('1', 'Hello, {{name}}!');
+        promptService.storePrompt('2', 'Goodbye, {{name}}!');
+        promptService.storePrompt('3', 'Ciao, {{invalid}}!');
+    });
+
+    it('should initialize prompts from PromptCollectionService', () => {
+        const allPrompts = promptService.getAllPrompts();
+        expect(allPrompts['1'].template).to.equal('Hello, {{name}}!');
+        expect(allPrompts['2'].template).to.equal('Goodbye, {{name}}!');
+        expect(allPrompts['3'].template).to.equal('Ciao, {{invalid}}!');
+    });
+
+    it('should retrieve raw prompt by id', () => {
+        const rawPrompt = promptService.getRawPrompt('1');
+        expect(rawPrompt?.template).to.equal('Hello, {{name}}!');
+    });
+
+    it('should format prompt with provided arguments', async () => {
+        const formattedPrompt = await promptService.getPrompt('1', { name: 'John' });
+        expect(formattedPrompt?.text).to.equal('Hello, John!');
+    });
+
+    it('should store a new prompt', () => {
+        promptService.storePrompt('3', 'Welcome, {{name}}!');
+        const newPrompt = promptService.getRawPrompt('3');
+        expect(newPrompt?.template).to.equal('Welcome, {{name}}!');
+    });
+
+    it('should replace placeholders with provided arguments', async () => {
+        const prompt = await promptService.getPrompt('1', { name: 'John' });
+        expect(prompt?.text).to.equal('Hello, John!');
+    });
+
+    it('should use variable service to resolve placeholders if argument value is not provided', async () => {
+        const prompt = await promptService.getPrompt('1');
+        expect(prompt?.text).to.equal('Hello, Jane!');
+    });
+
+    it('should return the prompt even if there are no replacements', async () => {
+        const prompt = await promptService.getPrompt('3');
+        expect(prompt?.text).to.equal('Ciao, {{invalid}}!');
+    });
+
+    it('should return undefined if the prompt id is not found', async () => {
+        const prompt = await promptService.getPrompt('4');
+        expect(prompt).to.be.undefined;
+    });
+
+    it('should ignore whitespace in variables', async () => {
+        promptService.storePrompt('4', 'Hello, {{name }}!');
+        promptService.storePrompt('5', 'Hello, {{ name}}!');
+        promptService.storePrompt('6', 'Hello, {{ name }}!');
+        promptService.storePrompt('7', 'Hello, {{       name           }}!');
+        for (let i = 4; i <= 7; i++) {
+            const prompt = await promptService.getPrompt(`${i}`, { name: 'John' });
+            expect(prompt?.text).to.equal('Hello, John!');
+        }
+    });
+});

package/src/common/prompt-service.ts

@@ -0,0 +1,213 @@
+// *****************************************************************************
+// 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 { URI, Event } from '@theia/core';
+import { inject, injectable, optional } from '@theia/core/shared/inversify';
+import { AIVariableService } from './variable-service';
+import { ToolInvocationRegistry } from './tool-invocation-registry';
+import { toolRequestToPromptText } from './language-model-util';
+import { ToolRequest } from './language-model';
+import { PROMPT_VARIABLE_REGEX, PROMPT_FUNCTION_REGEX } from './prompt-service-util';
+
+export interface PromptTemplate {
+    id: string;
+    template: string;
+}
+
+export interface PromptMap { [id: string]: PromptTemplate }
+
+export interface ResolvedPromptTemplate {
+    id: string;
+    /** The resolved prompt text with variables and function requests being replaced. */
+    text: string;
+    /** All functions referenced in the prompt template. */
+    functionDescriptions?: Map<string, ToolRequest>;
+}
+
+export const PromptService = Symbol('PromptService');
+export interface PromptService {
+    /**
+     * Retrieve the raw {@link PromptTemplate} object.
+     * @param id the id of the {@link PromptTemplate}
+     */
+    getRawPrompt(id: string): PromptTemplate | undefined;
+    /**
+     * Retrieve the default raw {@link PromptTemplate} object.
+     * @param id the id of the {@link PromptTemplate}
+     */
+    getDefaultRawPrompt(id: string): PromptTemplate | undefined;
+    /**
+     * Allows to directly replace placeholders in the prompt. The supported format is 'Hi {{name}}!'.
+     * The placeholder is then searched inside the args object and replaced.
+     * Function references are also supported via format '~{functionId}'.
+     * @param id the id of the prompt
+     * @param args the object with placeholders, mapping the placeholder key to the value
+     */
+    getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined>;
+    /**
+     * Manually add a prompt to the list of prompts.
+     * @param id the id of the prompt
+     * @param prompt the prompt template to store
+     */
+    storePrompt(id: string, prompt: string): void;
+    /**
+     * Return all known prompts as a {@link PromptMap map}.
+     */
+    getAllPrompts(): PromptMap;
+}
+
+export const PromptCustomizationService = Symbol('PromptCustomizationService');
+export interface PromptCustomizationService {
+    /**
+     * Whether there is a customization for a {@link PromptTemplate} object
+     * @param id the id of the {@link PromptTemplate} to check
+     */
+    isPromptTemplateCustomized(id: string): boolean;
+
+    /**
+     * Returns the customization of {@link PromptTemplate} object or undefined if there is none
+     * @param id the id of the {@link PromptTemplate} to check
+     */
+    getCustomizedPromptTemplate(id: string): string | undefined
+
+    /**
+     * Edit the template. If the content is specified, is will be
+     * used to customize the template. Otherwise, the behavior depends
+     * on the implementation. Implementation may for example decide to
+     * open an editor, or request more information from the user, ...
+     * @param id the template id.
+     * @param content optional content to customize the template.
+     */
+    editTemplate(id: string, content?: string): void;
+
+    /**
+     * Reset the template to its default value.
+     * @param id the template id.
+     */
+    resetTemplate(id: string): void;
+
+    /**
+     * Return the template id for a given template file.
+     * @param uri the uri of the template file
+     */
+    getTemplateIDFromURI(uri: URI): string | undefined;
+
+    /**
+     * Event which is fired when the prompt template is changed.
+     */
+    readonly onDidChangePrompt: Event<string>;
+}
+
+@injectable()
+export class PromptServiceImpl implements PromptService {
+    @inject(PromptCustomizationService) @optional()
+    protected readonly customizationService: PromptCustomizationService | undefined;
+
+    @inject(AIVariableService) @optional()
+    protected readonly variableService: AIVariableService | undefined;
+
+    @inject(ToolInvocationRegistry) @optional()
+    protected readonly toolInvocationRegistry: ToolInvocationRegistry | undefined;
+
+    protected _prompts: PromptMap = {};
+
+    getRawPrompt(id: string): PromptTemplate | undefined {
+        if (this.customizationService !== undefined && this.customizationService.isPromptTemplateCustomized(id)) {
+            const template = this.customizationService.getCustomizedPromptTemplate(id);
+            if (template !== undefined) {
+                return { id, template };
+            }
+        }
+        return this.getDefaultRawPrompt(id);
+    }
+    getDefaultRawPrompt(id: string): PromptTemplate | undefined {
+        return this._prompts[id];
+    }
+    async getPrompt(id: string, args?: { [key: string]: unknown }): Promise<ResolvedPromptTemplate | undefined> {
+        const prompt = this.getRawPrompt(id);
+        if (prompt === undefined) {
+            return undefined;
+        }
+
+        const matches = [...prompt.template.matchAll(PROMPT_VARIABLE_REGEX)];
+        const variableAndArgReplacements = await Promise.all(matches.map(async match => {
+            const completeText = match[0];
+            const variableAndArg = match[1];
+            let variableName = variableAndArg;
+            let argument: string | undefined;
+            const parts = variableAndArg.split(':', 2);
+            if (parts.length > 1) {
+                variableName = parts[0];
+                argument = parts[1];
+            }
+            return {
+                placeholder: completeText,
+                value: String(args?.[variableAndArg] ?? (await this.variableService?.resolveVariable({
+                    variable: variableName,
+                    arg: argument
+                }, {}))?.value ?? completeText)
+            };
+        }));
+
+        const functionMatches = [...prompt.template.matchAll(PROMPT_FUNCTION_REGEX)];
+        const functions = new Map<string, ToolRequest>();
+        const functionReplacements = functionMatches.map(match => {
+            const completeText = match[0];
+            const functionId = match[1];
+            const toolRequest = this.toolInvocationRegistry?.getFunction(functionId);
+            if (toolRequest) {
+                functions.set(toolRequest.id, toolRequest);
+            }
+            return {
+                placeholder: completeText,
+                value: toolRequest ? toolRequestToPromptText(toolRequest) : completeText
+            };
+        });
+
+        let resolvedTemplate = prompt.template;
+        const replacements = [...variableAndArgReplacements, ...functionReplacements];
+        replacements.forEach(replacement => resolvedTemplate = resolvedTemplate.replace(replacement.placeholder, replacement.value));
+        return {
+            id,
+            text: resolvedTemplate,
+            functionDescriptions: functions.size > 0 ? functions : undefined
+        };
+    }
+    getAllPrompts(): PromptMap {
+        if (this.customizationService !== undefined) {
+            const myCustomization = this.customizationService;
+            const result: PromptMap = {};
+            Object.keys(this._prompts).forEach(id => {
+                if (myCustomization.isPromptTemplateCustomized(id)) {
+                    const template = myCustomization.getCustomizedPromptTemplate(id);
+                    if (template !== undefined) {
+                        result[id] = { id, template };
+                    } else {
+                        result[id] = { ...this._prompts[id] };
+                    }
+                } else {
+                    result[id] = { ...this._prompts[id] };
+                }
+            });
+            return result;
+        } else {
+            return { ...this._prompts };
+        }
+    }
+    storePrompt(id: string, prompt: string): void {
+        this._prompts[id] = { id, template: prompt };
+    }
+}

package/src/common/protocol.ts

@@ -0,0 +1,23 @@
+// *****************************************************************************
+// 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 { LanguageModelMetaData } from './language-model';
+
+export const LanguageModelRegistryClient = Symbol('LanguageModelRegistryClient');
+export interface LanguageModelRegistryClient {
+    languageModelAdded(metadata: LanguageModelMetaData): void;
+    languageModelRemoved(id: string): void;
+}

package/src/common/settings-service.ts

@@ -0,0 +1,33 @@
+// *****************************************************************************
+// 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 { Event } from '@theia/core';
+import { LanguageModelRequirement } from './language-model';
+
+export const AISettingsService = Symbol('AISettingsService');
+/**
+ * Service to store and retrieve settings on a per-agent basis.
+ */
+export interface AISettingsService {
+    updateAgentSettings(agent: string, agentSettings: Partial<AgentSettings>): Promise<void>;
+    getAgentSettings(agent: string): Promise<AgentSettings | undefined>;
+    getSettings(): Promise<AISettings>;
+    onDidChange: Event<void>;
+}
+export type AISettings = Record<string, AgentSettings>;
+export interface AgentSettings {
+    languageModelRequirements?: LanguageModelRequirement[];
+    enable?: boolean;
+}