@theia/ai-core 1.63.0-next.24 → 1.63.0

package/src/browser/ai-core-preferences.ts

@@ -18,11 +18,18 @@ import { nls } from '@theia/core';
 import { PreferenceContribution, PreferenceProxy, PreferenceSchema } from '@theia/core/lib/browser';
 import { PreferenceProxyFactory } from '@theia/core/lib/browser/preferences/injectable-preference-proxy';
 import { interfaces } from '@theia/core/shared/inversify';
+import {
+    NOTIFICATION_TYPES,
+    NOTIFICATION_TYPE_OFF,
+    NotificationType
+} from '../common/notification-types';
 
 export const AI_CORE_PREFERENCES_TITLE = nls.localize('theia/ai/core/prefs/title', '✨ AI Features [Alpha]');
 export const PREFERENCE_NAME_ENABLE_AI = 'ai-features.AiEnable.enableAI';
 export const PREFERENCE_NAME_PROMPT_TEMPLATES = 'ai-features.promptTemplates.promptTemplatesFolder';
 export const PREFERENCE_NAME_REQUEST_SETTINGS = 'ai-features.modelSettings.requestSettings';
+export const PREFERENCE_NAME_MAX_RETRIES = 'ai-features.modelSettings.maxRetries';
+export const PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE = 'ai-features.notifications.default';
 
 export const aiCorePreferenceSchema: PreferenceSchema = {
     type: 'object',
@@ -121,13 +128,36 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
                 additionalProperties: false
             },
             default: [],
+        },
+        [PREFERENCE_NAME_MAX_RETRIES]: {
+            title: nls.localize('theia/ai/core/maxRetries/title', 'Maximum Retries'),
+            markdownDescription: nls.localize('theia/ai/core/maxRetries/mdDescription',
+                'The maximum number of retry attempts when a request to an AI provider fails. A value of 0 means no retries.'),
+            type: 'number',
+            minimum: 0,
+            default: 3
+        },
+        [PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE]: {
+            title: nls.localize('theia/ai/core/defaultNotification/title', 'Default Notification Type'),
+            markdownDescription: nls.localize('theia/ai/core/defaultNotification/mdDescription',
+                'The default notification method used when an AI agent completes a task. Individual agents can override this setting.\n\
+                - `os-notification`: Show OS/system notifications\n\
+                - `message`: Show notifications in the status bar/message area\n\
+                - `blink`: Blink or highlight the UI\n\
+                - `off`: Disable all notifications'),
+            type: 'string',
+            enum: [...NOTIFICATION_TYPES],
+            default: NOTIFICATION_TYPE_OFF
         }
     }
 };
+
 export interface AICoreConfiguration {
     [PREFERENCE_NAME_ENABLE_AI]: boolean | undefined;
     [PREFERENCE_NAME_PROMPT_TEMPLATES]: string | undefined;
     [PREFERENCE_NAME_REQUEST_SETTINGS]: Array<RequestSetting> | undefined;
+    [PREFERENCE_NAME_MAX_RETRIES]: number | undefined;
+    [PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE]: NotificationType | undefined;
 }
 
 export interface RequestSetting {

package/src/browser/frontend-language-model-registry.spec.ts

@@ -0,0 +1,298 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import {
+    LanguageModelRequest,
+    ToolRequest
+} from '../common';
+
+disableJSDOM();
+
+interface ErrorObject {
+    error: boolean;
+    message: string;
+}
+
+function isErrorObject(obj: unknown): obj is ErrorObject {
+    return !!obj && typeof obj === 'object' && 'error' in obj && 'message' in obj;
+}
+
+// This class provides a minimal implementation focused solely on testing the toolCall method.
+// We cannot extend FrontendLanguageModelRegistryImpl directly due to issues in the test environment:
+//   - FrontendLanguageModelRegistryImpl imports dependencies that transitively depend on 'p-queue'
+//   - p-queue is an ESM-only module that cannot be loaded in the current test environment
+class TestableLanguageModelRegistry {
+    private requests = new Map<string, LanguageModelRequest>();
+
+    async toolCall(id: string, toolId: string, arg_string: string): Promise<unknown> {
+        if (!this.requests.has(id)) {
+            return { error: true, message: `No request found for ID '${id}'. The request may have been cancelled or completed.` };
+        }
+        const request = this.requests.get(id)!;
+        const tool = request.tools?.find(t => t.id === toolId);
+        if (tool) {
+            try {
+                return await tool.handler(arg_string);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return { error: true, message: `Error executing tool '${toolId}': ${errorMessage}` };
+            };
+        }
+        return { error: true, message: `Tool '${toolId}' not found in the available tools for this request.` };
+    }
+
+    // Test helper method
+    setRequest(id: string, request: LanguageModelRequest): void {
+        this.requests.set(id, request);
+    }
+}
+
+describe('FrontendLanguageModelRegistryImpl toolCall functionality', () => {
+    let registry: TestableLanguageModelRegistry;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        registry = new TestableLanguageModelRegistry();
+    });
+
+    describe('toolCall', () => {
+        it('should return error object when request ID does not exist', async () => {
+            const result = await registry.toolCall('nonexistent-id', 'test-tool', '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include('No request found for ID \'nonexistent-id\'');
+                expect(result.message).to.include('The request may have been cancelled or completed');
+            }
+        });
+
+        it('should return error object when tool is not found', async () => {
+            // Set up a request without the requested tool
+            const requestId = 'test-request-id';
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: [
+                    {
+                        id: 'different-tool',
+                        name: 'Different Tool',
+                        description: 'A different tool',
+                        parameters: {
+                            type: 'object',
+                            properties: {}
+                        },
+                        handler: () => Promise.resolve('success')
+                    }
+                ]
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, 'nonexistent-tool', '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include('Tool \'nonexistent-tool\' not found in the available tools for this request');
+            }
+        });
+
+        it('should call tool handler successfully when tool exists', async () => {
+            const requestId = 'test-request-id';
+            const toolId = 'test-tool';
+            const expectedResult = 'tool execution result';
+
+            const mockTool: ToolRequest = {
+                id: toolId,
+                name: 'Test Tool',
+                description: 'A test tool',
+                parameters: {
+                    type: 'object',
+                    properties: {}
+                },
+                handler: (args: string) => Promise.resolve(expectedResult)
+            };
+
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: [mockTool]
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, toolId, '{}');
+
+            expect(result).to.equal(expectedResult);
+        });
+
+        it('should handle synchronous tool handler errors gracefully', async () => {
+            const requestId = 'test-request-id';
+            const toolId = 'error-tool';
+            const errorMessage = 'Tool execution failed';
+
+            const mockTool: ToolRequest = {
+                id: toolId,
+                name: 'Error Tool',
+                description: 'A tool that throws an error',
+                parameters: {
+                    type: 'object',
+                    properties: {}
+                },
+                handler: () => {
+                    throw new Error(errorMessage);
+                }
+            };
+
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: [mockTool]
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, toolId, '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include(`Error executing tool '${toolId}': ${errorMessage}`);
+            }
+        });
+
+        it('should handle non-Error exceptions gracefully', async () => {
+            const requestId = 'test-request-id';
+            const toolId = 'string-error-tool';
+            const errorMessage = 'String error';
+
+            const mockTool: ToolRequest = {
+                id: toolId,
+                name: 'String Error Tool',
+                description: 'A tool that throws a string',
+                parameters: {
+                    type: 'object',
+                    properties: {}
+                },
+                handler: () => {
+                    // eslint-disable-next-line no-throw-literal
+                    throw errorMessage;
+                }
+            };
+
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: [mockTool]
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, toolId, '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include(`Error executing tool '${toolId}': ${errorMessage}`);
+            }
+        });
+
+        it('should handle asynchronous tool handler errors gracefully', async () => {
+            const requestId = 'test-request-id';
+            const toolId = 'async-error-tool';
+            const errorMessage = 'Async tool execution failed';
+
+            const mockTool: ToolRequest = {
+                id: toolId,
+                name: 'Async Error Tool',
+                description: 'A tool that returns a rejected promise',
+                parameters: {
+                    type: 'object',
+                    properties: {}
+                },
+                handler: () => Promise.reject(new Error(errorMessage))
+            };
+
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: [mockTool]
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, toolId, '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include(`Error executing tool '${toolId}': ${errorMessage}`);
+            }
+        });
+
+        it('should handle tool handler with no tools array', async () => {
+            const requestId = 'test-request-id';
+            const mockRequest: LanguageModelRequest = {
+                messages: []
+                // No tools property
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, 'any-tool', '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include('Tool \'any-tool\' not found in the available tools for this request');
+            }
+        });
+
+        it('should handle tool handler with empty tools array', async () => {
+            const requestId = 'test-request-id';
+            const mockRequest: LanguageModelRequest = {
+                messages: [],
+                tools: []
+            };
+
+            registry.setRequest(requestId, mockRequest);
+
+            const result = await registry.toolCall(requestId, 'any-tool', '{}');
+
+            expect(result).to.be.an('object');
+            expect(isErrorObject(result)).to.be.true;
+            if (isErrorObject(result)) {
+                expect(result.error).to.be.true;
+                expect(result.message).to.include('Tool \'any-tool\' not found in the available tools for this request');
+            }
+        });
+    });
+});

package/src/browser/frontend-language-model-registry.ts

@@ -1,5 +1,5 @@
 // *****************************************************************************
-// Copyright (C) 2024 EclipseSource GmbH.
+// Copyright (C) 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
@@ -43,6 +43,7 @@ import {
     LanguageModelResponse,
     LanguageModelSelector,
     LanguageModelStreamResponsePart,
+    ToolCallResult,
 } from '../common';
 
 @injectable()
@@ -58,7 +59,7 @@ export class LanguageModelDelegateClientImpl
         this.receiver.send(id, token);
     }
 
-    toolCall(requestId: string, toolId: string, args_string: string): Promise<unknown> {
+    toolCall(requestId: string, toolId: string, args_string: string): Promise<ToolCallResult> {
         return this.receiver.toolCall(requestId, toolId, args_string);
     }
 
@@ -236,8 +237,8 @@ export class FrontendLanguageModelRegistryImpl
         };
     }
 
-    private streams = new Map<string, StreamState>();
-    private requests = new Map<string, LanguageModelRequest>();
+    protected streams = new Map<string, StreamState>();
+    protected requests = new Map<string, LanguageModelRequest>();
 
     async *getIterable(
         state: StreamState
@@ -281,16 +282,21 @@ export class FrontendLanguageModelRegistryImpl
     }
 
     // called by backend once tool is invoked
-    toolCall(id: string, toolId: string, arg_string: string): Promise<unknown> {
+    async toolCall(id: string, toolId: string, arg_string: string): Promise<ToolCallResult> {
         if (!this.requests.has(id)) {
-            throw new Error('Somehow we got a callback for a non existing request!');
+            return { error: true, message: `No request found for ID '${id}'. The request may have been cancelled or completed.` };
         }
         const request = this.requests.get(id)!;
         const tool = request.tools?.find(t => t.id === toolId);
         if (tool) {
-            return tool.handler(arg_string);
+            try {
+                return await tool.handler(arg_string);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return { error: true, message: `Error executing tool '${toolId}': ${errorMessage}` };
+            };
         }
-        throw new Error(`Could not find a tool for ${toolId}!`);
+        return { error: true, message: `Tool '${toolId}' not found in the available tools for this request.` };
     }
 
     // called by backend via the "delegate client" with the error to use for rejection

package/src/browser/frontend-variable-service.ts

@@ -37,6 +37,13 @@ export interface AIVariableDropResult {
     text?: string
 };
 
+export type AIVariablePasteHandler = (event: ClipboardEvent, context: AIVariableContext) => Promise<AIVariablePasteResult | undefined>;
+
+export interface AIVariablePasteResult {
+    variables: AIVariableResolutionRequest[],
+    text?: string
+};
+
 export interface AIVariableCompletionContext {
     /** Portion of user input to be used for filtering completion candidates. */
     userInput: string;
@@ -79,6 +86,10 @@ export interface FrontendVariableService extends AIVariableService {
     unregisterDropHandler(handler: AIVariableDropHandler): void;
     getDropResult(event: DragEvent, context: AIVariableContext): Promise<AIVariableDropResult>;
 
+    registerPasteHandler(handler: AIVariablePasteHandler): Disposable;
+    unregisterPasteHandler(handler: AIVariablePasteHandler): void;
+    getPasteResult(event: ClipboardEvent, context: AIVariableContext): Promise<AIVariablePasteResult>;
+
     registerOpener(variable: AIVariable, opener: AIVariableOpener): Disposable;
     unregisterOpener(variable: AIVariable, opener: AIVariableOpener): void;
     getOpener(name: string, arg: string | undefined, context: AIVariableContext): Promise<AIVariableOpener | undefined>;
@@ -92,6 +103,7 @@ export interface FrontendVariableContribution {
 @injectable()
 export class DefaultFrontendVariableService extends DefaultAIVariableService implements FrontendApplicationContribution, FrontendVariableService {
     protected dropHandlers = new Set<AIVariableDropHandler>();
+    protected pasteHandlers = new Set<AIVariablePasteHandler>();
 
     @inject(MessageService) protected readonly messageService: MessageService;
     @inject(AIVariableResourceResolver) protected readonly aiResourceResolver: AIVariableResourceResolver;
@@ -125,6 +137,30 @@ export class DefaultFrontendVariableService extends DefaultAIVariableService imp
         return { variables, text };
     }
 
+    registerPasteHandler(handler: AIVariablePasteHandler): Disposable {
+        this.pasteHandlers.add(handler);
+        return Disposable.create(() => this.unregisterPasteHandler(handler));
+    }
+
+    unregisterPasteHandler(handler: AIVariablePasteHandler): void {
+        this.pasteHandlers.delete(handler);
+    }
+
+    async getPasteResult(event: ClipboardEvent, context: AIVariableContext): Promise<AIVariablePasteResult> {
+        let text: string | undefined = undefined;
+        const variables: AIVariableResolutionRequest[] = [];
+        for (const handler of this.pasteHandlers) {
+            const result = await handler(event, context);
+            if (result) {
+                variables.push(...result.variables);
+                if (text === undefined) {
+                    text = result.text;
+                }
+            }
+        }
+        return { variables, text };
+    }
+
     registerOpener(variable: AIVariable, opener: AIVariableOpener): Disposable {
         const key = this.getKey(variable.name);
         if (!this.variables.get(key)) {

package/src/browser/index.ts

@@ -14,7 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+export * from './agent-completion-notification-service';
+export * from './os-notification-service';
+export * from './window-blink-service';
 export * from './ai-activation-service';
+export * from './ai-command-handler-factory';
 export * from './ai-core-frontend-application-contribution';
 export * from './ai-core-frontend-module';
 export * from './ai-core-preferences';
@@ -24,6 +28,7 @@ export * from './frontend-language-model-registry';
 export * from './frontend-variable-service';
 export * from './prompttemplate-contribution';
 export * from './theia-variable-contribution';
+export * from './open-editors-variable-contribution';
 export * from './frontend-variable-service';
 export * from './ai-core-command-contribution';
 export * from '../common/language-model-service';

package/src/browser/open-editors-variable-contribution.ts

@@ -0,0 +1,88 @@
+// *****************************************************************************
+// Copyright (C) 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 { MaybePromise, nls } from '@theia/core';
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { EditorManager } from '@theia/editor/lib/browser';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import URI from '@theia/core/lib/common/uri';
+import { AIVariable, ResolvedAIVariable, AIVariableContribution, AIVariableResolver, AIVariableService, AIVariableResolutionRequest, AIVariableContext } from '../common';
+
+export const OPEN_EDITORS_VARIABLE: AIVariable = {
+    id: 'openEditors',
+    description: nls.localize('theia/ai/core/openEditorsVariable/description', 'A comma-separated list of all currently open files, relative to the workspace root.'),
+    name: 'openEditors',
+};
+
+export const OPEN_EDITORS_SHORT_VARIABLE: AIVariable = {
+    id: 'openEditorsShort',
+    description: nls.localize('theia/ai/core/openEditorsShortVariable/description', 'Short reference to all currently open files (relative paths, comma-separated)'),
+    name: '_ff',
+};
+
+@injectable()
+export class OpenEditorsVariableContribution implements AIVariableContribution, AIVariableResolver {
+
+    @inject(EditorManager)
+    protected readonly editorManager: EditorManager;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    registerVariables(service: AIVariableService): void {
+        service.registerResolver(OPEN_EDITORS_VARIABLE, this);
+        service.registerResolver(OPEN_EDITORS_SHORT_VARIABLE, this);
+    }
+
+    canResolve(request: AIVariableResolutionRequest, _context: AIVariableContext): MaybePromise<number> {
+        return (request.variable.name === OPEN_EDITORS_VARIABLE.name || request.variable.name === OPEN_EDITORS_SHORT_VARIABLE.name) ? 50 : 0;
+    }
+
+    async resolve(request: AIVariableResolutionRequest, _context: AIVariableContext): Promise<ResolvedAIVariable | undefined> {
+        if (request.variable.name !== OPEN_EDITORS_VARIABLE.name && request.variable.name !== OPEN_EDITORS_SHORT_VARIABLE.name) {
+            return undefined;
+        }
+
+        const openFiles = this.getAllOpenFilesRelative();
+        return {
+            variable: request.variable,
+            value: openFiles
+        };
+    }
+
+    protected getAllOpenFilesRelative(): string {
+        const openFiles: string[] = [];
+
+        // Get all open editors from the editor manager
+        for (const editor of this.editorManager.all) {
+            const uri = editor.getResourceUri();
+            if (uri) {
+                const relativePath = this.getWorkspaceRelativePath(uri);
+                if (relativePath) {
+                    openFiles.push(`'${relativePath}'`);
+                }
+            }
+        }
+
+        return openFiles.join(', ');
+    }
+
+    protected getWorkspaceRelativePath(uri: URI): string | undefined {
+        const workspaceRootUri = this.workspaceService.getWorkspaceRootUri(uri);
+        const path = workspaceRootUri && workspaceRootUri.path.relative(uri.path);
+        return path && path.toString();
+    }
+}