@theia/ai-core 1.46.0-next.241

package/src/common/variable-service.ts

@@ -0,0 +1,177 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatVariables.ts
+
+import { ContributionProvider, Disposable, Emitter, ILogger, MaybePromise, Prioritizeable, Event } from '@theia/core';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+
+export interface AIVariable {
+    /** provider id */
+    id: string;
+    /** variable name */
+    name: string;
+    /** variable description */
+    description: string;
+    args?: AIVariableDescription[];
+}
+
+export interface AIVariableDescription {
+    name: string;
+    description: string;
+}
+
+export interface ResolvedAIVariable {
+    variable: AIVariable;
+    value: string;
+}
+
+export interface AIVariableResolutionRequest {
+    variable: AIVariable;
+    arg?: string;
+}
+
+export interface AIVariableContext {
+}
+
+export type AIVariableArg = string | { variable: string, arg?: string } | AIVariableResolutionRequest;
+
+export interface AIVariableResolver {
+    canResolve(request: AIVariableResolutionRequest, context: AIVariableContext): MaybePromise<number>,
+    resolve(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<ResolvedAIVariable | undefined>;
+}
+
+export const AIVariableService = Symbol('AIVariableService');
+export interface AIVariableService {
+    hasVariable(name: string): boolean;
+    getVariable(name: string): Readonly<AIVariable> | undefined;
+    getVariables(): Readonly<AIVariable>[];
+    unregisterVariable(name: string): void;
+    readonly onDidChangeVariables: Event<void>;
+
+    registerResolver(variable: AIVariable, resolver: AIVariableResolver): Disposable;
+    unregisterResolver(variable: AIVariable, resolver: AIVariableResolver): void;
+    getResolver(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableResolver | undefined>;
+
+    resolveVariable(variable: AIVariableArg, context: AIVariableContext): Promise<ResolvedAIVariable | undefined>;
+}
+
+export const AIVariableContribution = Symbol('AIVariableContribution');
+export interface AIVariableContribution {
+    registerVariables(service: AIVariableService): void;
+}
+
+@injectable()
+export class DefaultAIVariableService implements AIVariableService {
+    protected variables = new Map<string, AIVariable>();
+    protected resolvers = new Map<string, AIVariableResolver[]>();
+
+    protected readonly onDidChangeVariablesEmitter = new Emitter<void>();
+    readonly onDidChangeVariables: Event<void> = this.onDidChangeVariablesEmitter.event;
+
+    @inject(ILogger) protected logger: ILogger;
+
+    constructor(
+        @inject(ContributionProvider) @named(AIVariableContribution)
+        protected readonly contributionProvider: ContributionProvider<AIVariableContribution>
+    ) {
+    }
+
+    protected initContributions(): void {
+        this.contributionProvider.getContributions().forEach(contribution => contribution.registerVariables(this));
+    }
+
+    protected getKey(name: string): string {
+        return `${name.toLowerCase()}`;
+    }
+
+    async getResolver(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableResolver | undefined> {
+        const resolvers = await this.prioritize(name, arg, context);
+        return resolvers[0];
+    }
+
+    protected getResolvers(name: string): AIVariableResolver[] {
+        return this.resolvers.get(this.getKey(name)) ?? [];
+    }
+
+    protected async prioritize(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableResolver[]> {
+        const variable = this.getVariable(name);
+        if (!variable) {
+            return [];
+        }
+        const prioritized = await Prioritizeable.prioritizeAll(this.getResolvers(name), async resolver => {
+            try {
+                return await resolver.canResolve({ variable, arg }, context);
+            } catch {
+                return 0;
+            }
+        });
+        return prioritized.map(p => p.value);
+    }
+
+    hasVariable(name: string): boolean {
+        return !!this.getVariable(name);
+    }
+
+    getVariable(name: string): Readonly<AIVariable> | undefined {
+        return this.variables.get(this.getKey(name));
+    }
+
+    getVariables(): Readonly<AIVariable>[] {
+        return [...this.variables.values()];
+    }
+
+    registerResolver(variable: AIVariable, resolver: AIVariableResolver): Disposable {
+        const key = this.getKey(variable.name);
+        if (!this.variables.get(key)) {
+            this.variables.set(key, variable);
+            this.onDidChangeVariablesEmitter.fire();
+        }
+        const resolvers = this.resolvers.get(key) ?? [];
+        resolvers.push(resolver);
+        this.resolvers.set(key, resolvers);
+        return Disposable.create(() => this.unregisterResolver(variable, resolver));
+    }
+
+    unregisterResolver(variable: AIVariable, resolver: AIVariableResolver): void {
+        const key = this.getKey(variable.name);
+        const registeredResolvers = this.resolvers.get(key);
+        registeredResolvers?.splice(registeredResolvers.indexOf(resolver), 1);
+        if (registeredResolvers?.length === 0) {
+            this.unregisterVariable(variable.name);
+        }
+    }
+
+    unregisterVariable(name: string): void {
+        this.variables.delete(this.getKey(name));
+        this.resolvers.delete(this.getKey(name));
+        this.onDidChangeVariablesEmitter.fire();
+    }
+
+    async resolveVariable(request: AIVariableArg, context: AIVariableContext): Promise<ResolvedAIVariable | undefined> {
+        const variableName = typeof request === 'string' ? request : typeof request.variable === 'string' ? request.variable : request.variable.name;
+        const variable = this.getVariable(variableName);
+        if (!variable) {
+            return undefined;
+        }
+        const arg = typeof request === 'string' ? undefined : request.arg;
+        const resolver = await this.getResolver(variableName, arg, context);
+        return resolver?.resolve({ variable, arg }, context);
+    }
+}

package/src/node/ai-core-backend-module.ts

@@ -0,0 +1,83 @@
+// *****************************************************************************
+// 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 {
+    LanguageModelFrontendDelegateImpl,
+    LanguageModelRegistryFrontendDelegateImpl,
+} from './language-model-frontend-delegate';
+import {
+    ConnectionHandler,
+    RpcConnectionHandler,
+    bindContributionProvider,
+} from '@theia/core';
+import {
+    LanguageModelRegistry,
+    LanguageModelProvider,
+    PromptService,
+    PromptServiceImpl,
+    LanguageModelDelegateClient,
+    LanguageModelFrontendDelegate,
+    LanguageModelRegistryFrontendDelegate,
+    languageModelDelegatePath,
+    languageModelRegistryDelegatePath,
+    LanguageModelRegistryClient
+} from '../common';
+import { BackendLanguageModelRegistry } from './backend-language-model-registry';
+
+export default new ContainerModule(bind => {
+    bindContributionProvider(bind, LanguageModelProvider);
+    bind(BackendLanguageModelRegistry).toSelf().inSingletonScope();
+    bind(LanguageModelRegistry).toService(BackendLanguageModelRegistry);
+
+    bind(LanguageModelRegistryFrontendDelegate).to(LanguageModelRegistryFrontendDelegateImpl).inSingletonScope();
+    bind(ConnectionHandler)
+        .toDynamicValue(
+            ctx =>
+                new RpcConnectionHandler<LanguageModelRegistryClient>(
+                    languageModelRegistryDelegatePath,
+                    client => {
+                        const registryDelegate = ctx.container.get<LanguageModelRegistryFrontendDelegateImpl>(
+                            LanguageModelRegistryFrontendDelegate
+                        );
+                        registryDelegate.setClient(client);
+                        return registryDelegate;
+                    }
+                )
+        )
+        .inSingletonScope();
+
+    bind(LanguageModelFrontendDelegateImpl).toSelf().inSingletonScope();
+    bind(LanguageModelFrontendDelegate).toService(LanguageModelFrontendDelegateImpl);
+    bind(ConnectionHandler)
+        .toDynamicValue(
+            ({ container }) =>
+                new RpcConnectionHandler<LanguageModelDelegateClient>(
+                    languageModelDelegatePath,
+                    client => {
+                        const service =
+                            container.get<LanguageModelFrontendDelegateImpl>(
+                                LanguageModelFrontendDelegateImpl
+                            );
+                        service.setClient(client);
+                        return service;
+                    }
+                )
+        )
+        .inSingletonScope();
+
+    bind(PromptServiceImpl).toSelf().inSingletonScope();
+    bind(PromptService).toService(PromptServiceImpl);
+});

package/src/node/backend-language-model-registry.ts

@@ -0,0 +1,59 @@
+// *****************************************************************************
+// 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 { injectable } from '@theia/core/shared/inversify';
+import { DefaultLanguageModelRegistryImpl, LanguageModel, LanguageModelMetaData, LanguageModelRegistryClient } from '../common';
+
+/**
+ * Notifies a client whenever a model is added or removed
+ */
+@injectable()
+export class BackendLanguageModelRegistry extends DefaultLanguageModelRegistryImpl {
+
+    private client: LanguageModelRegistryClient | undefined;
+
+    setClient(client: LanguageModelRegistryClient): void {
+        this.client = client;
+    }
+
+    override addLanguageModels(models: LanguageModel[]): void {
+        const modelsLength = this.languageModels.length;
+        super.addLanguageModels(models);
+        // only notify for models which were really added
+        for (let i = modelsLength; i < this.languageModels.length; i++) {
+            this.client?.languageModelAdded(this.mapToMetaData(this.languageModels[i]));
+        }
+    }
+
+    override removeLanguageModels(ids: string[]): void {
+        super.removeLanguageModels(ids);
+        for (const id of ids) {
+            this.client?.languageModelRemoved(id);
+        }
+    }
+
+    mapToMetaData(model: LanguageModel): LanguageModelMetaData {
+        return {
+            id: model.id,
+            name: model.name,
+            vendor: model.vendor,
+            version: model.version,
+            family: model.family,
+            maxInputTokens: model.maxInputTokens,
+            maxOutputTokens: model.maxOutputTokens,
+        };
+    }
+}

package/src/node/language-model-frontend-delegate.ts

@@ -0,0 +1,116 @@
+// *****************************************************************************
+// 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { CancellationToken, CancellationTokenSource, ILogger, generateUuid } from '@theia/core';
+import {
+    LanguageModelMetaData,
+    LanguageModelRegistry,
+    LanguageModelRequest,
+    isLanguageModelStreamResponse,
+    isLanguageModelTextResponse,
+    LanguageModelStreamResponsePart,
+    LanguageModelDelegateClient,
+    LanguageModelFrontendDelegate,
+    LanguageModelRegistryFrontendDelegate,
+    LanguageModelResponseDelegate,
+    LanguageModelRegistryClient,
+    isLanguageModelParsedResponse,
+} from '../common';
+import { BackendLanguageModelRegistry } from './backend-language-model-registry';
+
+@injectable()
+export class LanguageModelRegistryFrontendDelegateImpl implements LanguageModelRegistryFrontendDelegate {
+
+    @inject(LanguageModelRegistry)
+    private registry: BackendLanguageModelRegistry;
+
+    setClient(client: LanguageModelRegistryClient): void {
+        this.registry.setClient(client);
+    }
+
+    async getLanguageModelDescriptions(): Promise<LanguageModelMetaData[]> {
+        return (await this.registry.getLanguageModels()).map(model => this.registry.mapToMetaData(model));
+    }
+}
+
+@injectable()
+export class LanguageModelFrontendDelegateImpl implements LanguageModelFrontendDelegate {
+
+    @inject(LanguageModelRegistry)
+    private registry: LanguageModelRegistry;
+
+    @inject(ILogger)
+    private logger: ILogger;
+
+    private frontendDelegateClient: LanguageModelDelegateClient;
+    private requestCancellationTokenMap: Map<string, CancellationTokenSource> = new Map();
+
+    setClient(client: LanguageModelDelegateClient): void {
+        this.frontendDelegateClient = client;
+    }
+
+    cancel(requestId: string): void {
+        this.requestCancellationTokenMap.get(requestId)?.cancel();
+    }
+
+    async request(
+        modelId: string,
+        request: LanguageModelRequest,
+        requestId: string,
+        cancellationToken?: CancellationToken
+    ): Promise<LanguageModelResponseDelegate> {
+        const model = await this.registry.getLanguageModel(modelId);
+        if (!model) {
+            throw new Error(
+                `Request was sent to non-existent language model ${modelId}`
+            );
+        }
+        request.tools?.forEach(tool => {
+            tool.handler = async args_string => this.frontendDelegateClient.toolCall(requestId, tool.id, args_string);
+        });
+        if (cancellationToken) {
+            const tokenSource = new CancellationTokenSource();
+            cancellationToken = tokenSource.token;
+            this.requestCancellationTokenMap.set(requestId, tokenSource);
+        }
+        const response = await model.request(request, cancellationToken);
+        if (isLanguageModelTextResponse(response) || isLanguageModelParsedResponse(response)) {
+            return response;
+        }
+        if (isLanguageModelStreamResponse(response)) {
+            const delegate = {
+                streamId: generateUuid(),
+            };
+            this.sendTokens(delegate.streamId, response.stream);
+            return delegate;
+        }
+        this.logger.error(
+            `Received unexpected response from language model ${modelId}. Trying to continue without touching the response.`,
+            response
+        );
+        return response;
+    }
+
+    protected sendTokens(id: string, stream: AsyncIterable<LanguageModelStreamResponsePart>): void {
+        (async () => {
+            for await (const token of stream) {
+                this.frontendDelegateClient.send(id, token);
+            }
+            this.frontendDelegateClient.send(id, undefined);
+        })();
+    }
+}