@theia/ai-core 1.64.0-next.28 → 1.64.0

package/src/browser/index.ts

@@ -25,6 +25,7 @@ export * from './ai-core-preferences';
 export * from './ai-settings-service';
 export * from './ai-view-contribution';
 export * from './frontend-language-model-registry';
+export * from './frontend-language-model-alias-registry';
 export * from './frontend-variable-service';
 export * from './prompttemplate-contribution';
 export * from './theia-variable-contribution';

package/src/common/index.ts

@@ -20,6 +20,7 @@ export * from './tool-invocation-registry';
 export * from './language-model-delegate';
 export * from './language-model-util';
 export * from './language-model';
+export * from './language-model-alias';
 export * from './prompt-service';
 export * from './prompt-service-util';
 export * from './prompt-text';

package/src/common/language-model-alias.ts

@@ -0,0 +1,76 @@
+// *****************************************************************************
+// Copyright (C) 2024-2025 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';
+
+/**
+ * Represents an alias for a language model, allowing fallback and selection.
+ */
+export interface LanguageModelAlias {
+    /**
+     * The unique identifier for the alias.
+     */
+    id: string;
+    /**
+     * The list of default model IDs to use if no selectedModelId is set.
+     * Ordered by priority. The first entry also serves as fallback.
+     */
+    defaultModelIds: string[];
+    /**
+     * A human-readable description of the alias.
+     */
+    description?: string;
+    /**
+     * The currently selected model ID, if any.
+     */
+    selectedModelId?: string;
+}
+
+export const LanguageModelAliasRegistry = Symbol('LanguageModelAliasRegistry');
+/**
+ * Registry for managing language model aliases.
+ */
+export interface LanguageModelAliasRegistry {
+    /**
+     * Promise that resolves when the registry is ready for use (preferences loaded).
+     */
+    ready: Promise<void>;
+
+    /**
+     * Event that is fired when the alias list changes.
+     */
+    onDidChange: Event<void>;
+    /**
+     * Add a new alias or update an existing one.
+     */
+    addAlias(alias: LanguageModelAlias): void;
+    /**
+     * Remove an alias by its id.
+     */
+    removeAlias(id: string): void;
+    /**
+     * Get all aliases.
+     */
+    getAliases(): LanguageModelAlias[];
+    /**
+     * Resolve an alias or model id to a prioritized list of model ids.
+     * If the id is not an alias, returns [id].
+     * If the alias exists and has a selectedModelId, returns [selectedModelId].
+     * If the alias exists and has no selectedModelId, returns defaultModelIds.
+     * If the alias does not exist, returns undefined.
+     */
+    resolveAlias(id: string): string[] | undefined;
+}

package/src/common/language-model.ts

@@ -295,6 +295,7 @@ export interface LanguageModelMetaData {
     readonly family?: string;
     readonly maxInputTokens?: number;
     readonly maxOutputTokens?: number;
+    readonly status: LanguageModelStatus;
 }
 
 export namespace LanguageModelMetaData {
@@ -303,6 +304,11 @@ export namespace LanguageModelMetaData {
     }
 }
 
+export interface LanguageModelStatus {
+    status: 'ready' | 'unavailable';
+    message?: string;
+}
+
 export interface LanguageModel extends LanguageModelMetaData {
     request(request: UserRequest, cancellationToken?: CancellationToken): Promise<LanguageModelResponse>;
 }
@@ -331,6 +337,10 @@ export interface LanguageModelSelector extends VsCodeLanguageModelSelector {
 export type LanguageModelRequirement = Omit<LanguageModelSelector, 'agent'>;
 
 export const LanguageModelRegistry = Symbol('LanguageModelRegistry');
+
+/**
+ * Base interface for language model registries (frontend and backend).
+ */
 export interface LanguageModelRegistry {
     onChange: Event<{ models: LanguageModel[] }>;
     addLanguageModels(models: LanguageModel[]): void;
@@ -338,7 +348,22 @@ export interface LanguageModelRegistry {
     getLanguageModel(id: string): Promise<LanguageModel | undefined>;
     removeLanguageModels(id: string[]): void;
     selectLanguageModel(request: LanguageModelSelector): Promise<LanguageModel | undefined>;
-    selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[]>;
+    selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[] | undefined>;
+    patchLanguageModel<T extends LanguageModel = LanguageModel>(id: string, patch: Partial<T>): Promise<void>;
+}
+
+export const FrontendLanguageModelRegistry = Symbol('FrontendLanguageModelRegistry');
+
+/**
+ * Frontend-specific language model registry interface (supports alias resolution).
+ */
+export interface FrontendLanguageModelRegistry extends LanguageModelRegistry {
+    /**
+     * If an id of a language model is provded, returns the LanguageModel if it is `ready`.
+     * If an alias is provided, finds the highest-priority ready model from that alias.
+     * If none are ready returns undefined.
+     */
+    getReadyLanguageModel(idOrAlias: string): Promise<LanguageModel | undefined>;
 }
 
 @injectable()
@@ -405,15 +430,28 @@ export class DefaultLanguageModelRegistryImpl implements LanguageModelRegistry {
         });
     }
 
-    async selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[]> {
+    async selectLanguageModels(request: LanguageModelSelector): Promise<LanguageModel[] | undefined> {
         await this.initialized;
         // TODO check for actor and purpose against settings
-        return this.languageModels.filter(model => isModelMatching(request, model));
+        return this.languageModels.filter(model => model.status.status === 'ready' && isModelMatching(request, model));
     }
 
     async selectLanguageModel(request: LanguageModelSelector): Promise<LanguageModel | undefined> {
-        return (await this.selectLanguageModels(request))[0];
+        const models = await this.selectLanguageModels(request);
+        return models ? models[0] : undefined;
+    }
+
+    async patchLanguageModel<T extends LanguageModel = LanguageModel>(id: string, patch: Partial<T>): Promise<void> {
+        await this.initialized;
+        const model = this.languageModels.find(m => m.id === id);
+        if (!model) {
+            this.logger.warn(`Language model with id ${id} not found for patch.`);
+            return;
+        }
+        Object.assign(model, patch);
+        this.changeEmitter.fire({ models: this.languageModels });
     }
+
 }
 
 export function isModelMatching(request: LanguageModelSelector, model: LanguageModel): boolean {

package/src/common/prompt-service.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Event, Emitter, URI, ILogger } from '@theia/core';
+import { Event, Emitter, URI, ILogger, DisposableCollection } from '@theia/core';
 import { inject, injectable, optional, postConstruct } from '@theia/core/shared/inversify';
 import { AIVariableArg, AIVariableContext, AIVariableService, createAIResolveVariableCache, ResolvedAIVariable } from './variable-service';
 import { ToolInvocationRegistry } from './tool-invocation-registry';
@@ -283,7 +283,7 @@ export interface PromptService {
     /**
      * Event fired when the selected variant for a prompt variant set changes
      */
-    readonly onSelectedVariantChange: Event<{ promptVariantSetId: string, variantId: string }>;
+    readonly onSelectedVariantChange: Event<{ promptVariantSetId: string, variantId: string | undefined }>;
 
     /**
      * Gets the raw prompt fragment with comments
@@ -368,7 +368,7 @@ export interface PromptService {
      * @param promptVariantSetId The prompt variant set id
      * @returns The selected variant ID from settings, or undefined if none is selected
      */
-    getSelectedVariantId(promptVariantSetId: string): Promise<string | undefined>;
+    getSelectedVariantId(promptVariantSetId: string): string | undefined;
 
     /**
      * Gets the effective variant ID that is guaranteed to be valid if one exists.
@@ -376,7 +376,7 @@ export interface PromptService {
      * @param promptVariantSetId The prompt variant set id
      * @returns A valid variant ID if one exists, or undefined if no valid variant can be found
      */
-    getEffectiveVariantId(promptVariantSetId: string): Promise<string | undefined>;
+    getEffectiveVariantId(promptVariantSetId: string): string | undefined;
 
     /**
      * Gets the default variant ID of the given set
@@ -419,12 +419,16 @@ export interface PromptService {
 export class PromptServiceImpl implements PromptService {
     @inject(ILogger)
     protected readonly logger: ILogger;
+
     @inject(AISettingsService) @optional()
     protected readonly settingsService: AISettingsService | undefined;
 
     @inject(PromptFragmentCustomizationService) @optional()
     protected readonly customizationService: PromptFragmentCustomizationService | undefined;
 
+    // Map to store selected variant for each prompt variant set (key: promptVariantSetId, value: variantId)
+    protected _selectedVariantsMap = new Map<string, string>();
+
     @inject(AIVariableService) @optional()
     protected readonly variableService: AIVariableService | undefined;
 
@@ -445,21 +449,80 @@ export class PromptServiceImpl implements PromptService {
     readonly onPromptsChange = this._onPromptsChangeEmitter.event;
 
     // Event emitter for selected variant changes
-    protected _onSelectedVariantChangeEmitter = new Emitter<{ promptVariantSetId: string, variantId: string }>();
+    protected _onSelectedVariantChangeEmitter = new Emitter<{ promptVariantSetId: string, variantId: string | undefined }>();
     readonly onSelectedVariantChange = this._onSelectedVariantChangeEmitter.event;
 
+    protected promptChangeDebounceTimer?: NodeJS.Timeout;
+
+    protected toDispose = new DisposableCollection();
+
+    protected fireOnPromptsChangeDebounced(): void {
+        if (this.promptChangeDebounceTimer) {
+            clearTimeout(this.promptChangeDebounceTimer);
+        }
+        this.promptChangeDebounceTimer = setTimeout(() => {
+            this._onPromptsChangeEmitter.fire();
+        }, 300);
+    }
+
     @postConstruct()
     protected init(): void {
         if (this.customizationService) {
-            this.customizationService.onDidChangePromptFragmentCustomization(() => {
-                this._onPromptsChangeEmitter.fire();
-            });
-            this.customizationService.onDidChangeCustomAgents(() => {
-                this._onPromptsChangeEmitter.fire();
-            });
+            this.toDispose.pushAll([
+                this.customizationService.onDidChangePromptFragmentCustomization(() => {
+                    this.fireOnPromptsChangeDebounced();
+                }),
+                this.customizationService.onDidChangeCustomAgents(() => {
+                    this.fireOnPromptsChangeDebounced();
+                })
+            ]);
+        }
+        if (this.settingsService) {
+            this.recalculateSelectedVariantsMap();
+            this.toDispose.push(
+                this.settingsService!.onDidChange(async () => {
+                    await this.recalculateSelectedVariantsMap();
+                })
+            );
         }
     }
 
+    /**
+     * Recalculates the selected variants map for all variant sets and fires the onSelectedVariantChangeEmitter
+     * if the selectedVariants field has changed.
+     */
+    protected async recalculateSelectedVariantsMap(): Promise<void> {
+        if (!this.settingsService) {
+            return;
+        }
+        const agentSettingsMap = await this.settingsService.getSettings();
+        const newSelectedVariants = new Map<string, string>();
+        for (const agentSettings of Object.values(agentSettingsMap)) {
+            if (agentSettings.selectedVariants) {
+                for (const [variantSetId, variantId] of Object.entries(agentSettings.selectedVariants)) {
+                    if (!newSelectedVariants.has(variantSetId)) {
+                        newSelectedVariants.set(variantSetId, variantId);
+                    }
+                }
+            }
+        }
+        // Compare with the old map and fire events for changes and removed variant sets
+        for (const [variantSetId, newVariantId] of newSelectedVariants.entries()) {
+            const oldVariantId = this._selectedVariantsMap.get(variantSetId);
+            if (oldVariantId !== newVariantId) {
+                this._onSelectedVariantChangeEmitter.fire({ promptVariantSetId: variantSetId, variantId: newVariantId });
+            }
+        }
+        for (const oldVariantSetId of this._selectedVariantsMap.keys()) {
+            if (!newSelectedVariants.has(oldVariantSetId)) {
+                this._onSelectedVariantChangeEmitter.fire({ promptVariantSetId: oldVariantSetId, variantId: undefined });
+            }
+        }
+        this._selectedVariantsMap = newSelectedVariants;
+        // Also fire a full prompts change, because other fields (like effectiveVariantId) might have changed
+        this.fireOnPromptsChangeDebounced();
+    }
+
     // ===== Fragment Retrieval Methods =====
 
     /**
@@ -506,54 +569,45 @@ export class PromptServiceImpl implements PromptService {
         return commentRegex.test(templateText) ? templateText.replace(commentRegex, '').trimStart() : templateText;
     }
 
-    async getSelectedVariantId(fragmentId: string): Promise<string | undefined> {
-        if (this.settingsService) {
-            const agentSettingsMap = await this.settingsService.getSettings();
-
-            for (const agentSettings of Object.values(agentSettingsMap)) {
-                if (agentSettings.selectedVariants && agentSettings.selectedVariants[fragmentId]) {
-                    return agentSettings.selectedVariants[fragmentId];
-                }
-            }
-        }
-        return undefined;
+    getSelectedVariantId(variantSetId: string): string | undefined {
+        return this._selectedVariantsMap.get(variantSetId);
     }
 
-    async getEffectiveVariantId(fragmentId: string): Promise<string | undefined> {
-        const selectedVariantId = await this.getSelectedVariantId(fragmentId);
+    getEffectiveVariantId(variantSetId: string): string | undefined {
+        const selectedVariantId = this.getSelectedVariantId(variantSetId);
 
         // Check if the selected variant actually exists
         if (selectedVariantId) {
-            const variantIds = this.getVariantIds(fragmentId);
+            const variantIds = this.getVariantIds(variantSetId);
             if (!variantIds.includes(selectedVariantId)) {
-                this.logger.warn(`Selected variant '${selectedVariantId}' for prompt set '${fragmentId}' does not exist. Falling back to default variant.`);
+                this.logger.warn(`Selected variant '${selectedVariantId}' for prompt set '${variantSetId}' does not exist. Falling back to default variant.`);
             } else {
                 return selectedVariantId;
             }
         }
 
         // Fall back to default variant
-        const defaultVariantId = this.getDefaultVariantId(fragmentId);
+        const defaultVariantId = this.getDefaultVariantId(variantSetId);
         if (defaultVariantId) {
-            const variantIds = this.getVariantIds(fragmentId);
+            const variantIds = this.getVariantIds(variantSetId);
             if (!variantIds.includes(defaultVariantId)) {
-                this.logger.error(`Default variant '${defaultVariantId}' for prompt set '${fragmentId}' does not exist.`);
+                this.logger.error(`Default variant '${defaultVariantId}' for prompt set '${variantSetId}' does not exist.`);
                 return undefined;
             }
             return defaultVariantId;
         }
 
         // No valid selected or default variant
-        if (this.getVariantIds(fragmentId).length > 0) {
-            this.logger.error(`No valid selected or default variant found for prompt set '${fragmentId}'.`);
+        if (this.getVariantIds(variantSetId).length > 0) {
+            this.logger.error(`No valid selected or default variant found for prompt set '${variantSetId}'.`);
         }
         return undefined;
     }
 
-    protected async resolvePotentialSystemPrompt(promptFragmentId: string): Promise<PromptFragment | undefined> {
+    protected resolvePotentialSystemPrompt(promptFragmentId: string): PromptFragment | undefined {
         if (this._promptVariantSetsMap.has(promptFragmentId)) {
             // This is a systemPrompt find the effective variant
-            const effectiveVariantId = await this.getEffectiveVariantId(promptFragmentId);
+            const effectiveVariantId = this.getEffectiveVariantId(promptFragmentId);
             if (effectiveVariantId === undefined) {
                 return undefined;
             }
@@ -565,7 +619,7 @@ export class PromptServiceImpl implements PromptService {
     // ===== Fragment Resolution Methods =====
 
     async getResolvedPromptFragment(systemOrFragmentId: string, args?: { [key: string]: unknown }, context?: AIVariableContext): Promise<ResolvedPromptFragment | undefined> {
-        const promptFragment = await this.resolvePotentialSystemPrompt(systemOrFragmentId);
+        const promptFragment = this.resolvePotentialSystemPrompt(systemOrFragmentId);
         if (promptFragment === undefined) {
             return undefined;
         }
@@ -609,7 +663,7 @@ export class PromptServiceImpl implements PromptService {
         context?: AIVariableContext,
         resolveVariable?: (variable: AIVariableArg) => Promise<ResolvedAIVariable | undefined>
     ): Promise<Omit<ResolvedPromptFragment, 'functionDescriptions'> | undefined> {
-        const promptFragment = await this.resolvePotentialSystemPrompt(systemOrFragmentId);
+        const promptFragment = this.resolvePotentialSystemPrompt(systemOrFragmentId);
         if (promptFragment === undefined) {
             return undefined;
         }
@@ -764,7 +818,7 @@ export class PromptServiceImpl implements PromptService {
             }
         }
 
-        this._onPromptsChangeEmitter.fire();
+        this.fireOnPromptsChangeDebounced();
     }
 
     getVariantIds(variantSetId: string): string[] {
@@ -839,7 +893,7 @@ export class PromptServiceImpl implements PromptService {
             this.addFragmentVariant(promptVariantSetId, promptFragment.id, isDefault);
         }
 
-        this._onPromptsChangeEmitter.fire();
+        this.fireOnPromptsChangeDebounced();
     }
 
     // ===== Variant Management Methods =====

package/src/common/protocol.ts

@@ -22,6 +22,10 @@ export const LanguageModelRegistryClient = Symbol('LanguageModelRegistryClient')
 export interface LanguageModelRegistryClient {
     languageModelAdded(metadata: LanguageModelMetaData): void;
     languageModelRemoved(id: string): void;
+    /**
+     * Notify the client that a language model was updated.
+     */
+    onLanguageModelUpdated(id: string): void;
 }
 
 export const TOKEN_USAGE_SERVICE_PATH = '/services/token-usage';

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

@@ -41,14 +41,14 @@ import {
     TokenUsageServiceClient,
     TOKEN_USAGE_SERVICE_PATH
 } from '../common';
-import { BackendLanguageModelRegistry } from './backend-language-model-registry';
+import { BackendLanguageModelRegistryImpl } from './backend-language-model-registry';
 import { TokenUsageServiceImpl } from './token-usage-service-impl';
 
 // We use a connection module to handle AI services separately for each frontend.
 const aiCoreConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService, bindFrontendService }) => {
     bindContributionProvider(bind, LanguageModelProvider);
-    bind(BackendLanguageModelRegistry).toSelf().inSingletonScope();
-    bind(LanguageModelRegistry).toService(BackendLanguageModelRegistry);
+    bind(BackendLanguageModelRegistryImpl).toSelf().inSingletonScope();
+    bind(LanguageModelRegistry).toService(BackendLanguageModelRegistryImpl);
 
     bind(TokenUsageService).to(TokenUsageServiceImpl).inSingletonScope();
 

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

@@ -21,7 +21,7 @@ import { DefaultLanguageModelRegistryImpl, LanguageModel, LanguageModelMetaData,
  * Notifies a client whenever a model is added or removed
  */
 @injectable()
-export class BackendLanguageModelRegistry extends DefaultLanguageModelRegistryImpl {
+export class BackendLanguageModelRegistryImpl extends DefaultLanguageModelRegistryImpl {
 
     private client: LanguageModelRegistryClient | undefined;
 
@@ -45,10 +45,18 @@ export class BackendLanguageModelRegistry extends DefaultLanguageModelRegistryIm
         }
     }
 
+    override async patchLanguageModel<T extends LanguageModel = LanguageModel>(id: string, patch: Partial<T>): Promise<void> {
+        await super.patchLanguageModel(id, patch);
+        if (this.client) {
+            this.client.onLanguageModelUpdated(id);
+        }
+    }
+
     mapToMetaData(model: LanguageModel): LanguageModelMetaData {
         return {
             id: model.id,
             name: model.name,
+            status: model.status,
             vendor: model.vendor,
             version: model.version,
             family: model.family,

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

@@ -30,13 +30,13 @@ import {
     isLanguageModelParsedResponse,
     UserRequest,
 } from '../common';
-import { BackendLanguageModelRegistry } from './backend-language-model-registry';
+import { BackendLanguageModelRegistryImpl } from './backend-language-model-registry';
 
 @injectable()
 export class LanguageModelRegistryFrontendDelegateImpl implements LanguageModelRegistryFrontendDelegate {
 
     @inject(LanguageModelRegistry)
-    private registry: BackendLanguageModelRegistry;
+    private registry: BackendLanguageModelRegistryImpl;
 
     setClient(client: LanguageModelRegistryClient): void {
         this.registry.setClient(client);