@theia/plugin-ext 1.73.0-next.9 → 1.73.0

package/src/main/browser/debug/plugin-debug-session-factory.ts

@@ -14,53 +14,32 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable, inject, interfaces } from '@theia/core/shared/inversify';
 import { DefaultDebugSessionFactory } from '@theia/debug/lib/browser/debug-session-contribution';
-import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
-import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
-import { BreakpointManager } from '@theia/debug/lib/browser/breakpoint/breakpoint-manager';
-import { LabelProvider } from '@theia/core/lib/browser/label-provider';
-import { MessageClient } from '@theia/core/lib/common/message-service-protocol';
-import { OutputChannelManager } from '@theia/output/lib/browser/output-channel';
-import { DebugPreferences } from '@theia/debug/lib/common/debug-preferences';
-import { DebugConfigurationSessionOptions, TestRunReference } from '@theia/debug/lib/browser/debug-session-options';
-import { DebugSession } from '@theia/debug/lib/browser/debug-session';
+import { DebugConfigurationSessionOptions } from '@theia/debug/lib/browser/debug-session-options';
+import { DebugSession, DebugSessionData } from '@theia/debug/lib/browser/debug-session';
 import { DebugSessionConnection } from '@theia/debug/lib/browser/debug-session-connection';
 import { TerminalWidgetOptions, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
 import { TerminalOptionsExt } from '../../../common/plugin-api-rpc';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { DebugContribution } from '@theia/debug/lib/browser/debug-contribution';
-import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
-import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { PluginChannel } from '../../../common/connection';
-import { TestService } from '@theia/test/lib/browser/test-service';
-import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
-import { CommandService } from '@theia/core';
 
+export const PluginTerminalOptionsExt = Symbol('PluginTerminalOptionsExt');
+
+@injectable()
 export class PluginDebugSession extends DebugSession {
-    constructor(
-        override readonly id: string,
-        override readonly options: DebugConfigurationSessionOptions,
-        override readonly parentSession: DebugSession | undefined,
-        testService: TestService,
-        testRun: TestRunReference | undefined,
-        sessionManager: DebugSessionManager,
-        protected override readonly connection: DebugSessionConnection,
-        protected override readonly terminalServer: TerminalService,
-        protected override readonly editorManager: EditorManager,
-        protected override readonly breakpoints: BreakpointManager,
-        protected override readonly labelProvider: LabelProvider,
-        protected override readonly messages: MessageClient,
-        protected override readonly fileService: FileService,
-        protected readonly terminalOptionsExt: TerminalOptionsExt | undefined,
-        protected override readonly debugContributionProvider: ContributionProvider<DebugContribution>,
-        protected override readonly workspaceService: WorkspaceService,
-        debugPreferences: DebugPreferences,
-        protected override readonly commandService: CommandService) {
-        super(id, options, parentSession, testService, testRun, sessionManager, connection, terminalServer, editorManager, breakpoints,
-            labelProvider, messages, fileService, debugContributionProvider,
-            workspaceService, debugPreferences, commandService);
+
+    static override createContainer(
+        parent: interfaces.Container, data: DebugSessionData, connection: DebugSessionConnection, terminalOptionsExt?: TerminalOptionsExt
+    ): interfaces.Container {
+        const child = DebugSession.createContainer(parent, data, connection);
+        child.rebind(DebugSession).to(PluginDebugSession);
+        child.bind(PluginTerminalOptionsExt).toConstantValue(terminalOptionsExt);
+        return child;
     }
 
+    @inject(PluginTerminalOptionsExt)
+    protected readonly terminalOptionsExt: TerminalOptionsExt | undefined;
+
     protected override async doCreateTerminal(terminalWidgetOptions: TerminalWidgetOptions): Promise<TerminalWidget> {
         terminalWidgetOptions = Object.assign({}, terminalWidgetOptions, this.terminalOptionsExt);
         return super.doCreateTerminal(terminalWidgetOptions);
@@ -73,49 +52,24 @@ export class PluginDebugSession extends DebugSession {
  */
 export class PluginDebugSessionFactory extends DefaultDebugSessionFactory {
     constructor(
-        protected override readonly terminalService: TerminalService,
-        protected override readonly editorManager: EditorManager,
-        protected override readonly breakpoints: BreakpointManager,
-        protected override readonly labelProvider: LabelProvider,
-        protected override readonly messages: MessageClient,
-        protected override readonly outputChannelManager: OutputChannelManager,
-        protected override readonly debugPreferences: DebugPreferences,
         protected readonly connectionFactory: (sessionId: string) => Promise<PluginChannel>,
-        protected override readonly fileService: FileService,
         protected readonly terminalOptionsExt: TerminalOptionsExt | undefined,
-        protected override readonly debugContributionProvider: ContributionProvider<DebugContribution>,
-        protected override readonly testService: TestService,
-        protected override readonly workspaceService: WorkspaceService,
-        protected override readonly commandService: CommandService,
+        container: interfaces.Container,
     ) {
-        super();
+        super(container);
     }
 
-    override get(manager: DebugSessionManager, sessionId: string, options: DebugConfigurationSessionOptions, parentSession?: DebugSession): DebugSession {
+    override createSession(sessionId: string, options: DebugConfigurationSessionOptions, parentSession?: DebugSession): DebugSession {
         const connection = new DebugSessionConnection(
             sessionId,
             this.connectionFactory,
             this.getTraceOutputChannel());
-
-        return new PluginDebugSession(
-            sessionId,
+        const data: DebugSessionData = {
+            id: sessionId,
             options,
             parentSession,
-            this.testService,
-            options.testRun,
-            manager,
-            connection,
-            this.terminalService,
-            this.editorManager,
-            this.breakpoints,
-            this.labelProvider,
-            this.messages,
-            this.fileService,
-            this.terminalOptionsExt,
-            this.debugContributionProvider,
-            this.workspaceService,
-            this.debugPreferences,
-            this.commandService
-        );
+        };
+        const child = PluginDebugSession.createContainer(this.container, data, connection, this.terminalOptionsExt);
+        return child.get(DebugSession);
     }
 }

package/src/main/browser/languages-main.ts

@@ -39,7 +39,7 @@ import {
     IdentifiableInlineCompletions,
     HoverWithId
 } from '../../common/plugin-api-rpc';
-import { injectable, inject } from '@theia/core/shared/inversify';
+import { injectable, inject, named } from '@theia/core/shared/inversify';
 import {
     SerializedDocumentFilter, MarkerData, Range, RelatedInformation,
     MarkerSeverity, DocumentLink, WorkspaceSymbolParams, CodeAction, CompletionDto,
@@ -80,12 +80,14 @@ import {
     EvaluatableExpressionProvider,
     InlineValue,
     InlineValueContext,
-    InlineValuesProvider
+    InlineValuesProvider,
+    MultiDocumentHighlightProvider
 } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
 import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 import { CodeActionTriggerKind } from '../../plugin/types-impl';
 import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/common/upload/file-upload';
+import { ILogger } from '@theia/core';
 
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
@@ -108,6 +110,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     @inject(FileUploadService)
     protected readonly fileUploadService: FileUploadService;
 
+    @inject(ILogger) @named('plugin-ext:LanguagesMainImpl')
+    protected readonly logger: ILogger;
+
     private readonly proxy: LanguagesExt;
     private readonly services = new Map<number, Disposable>();
     private readonly toDispose = new DisposableCollection();
@@ -349,7 +354,8 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
 
     protected createHoverProvider(handle: number): monaco.languages.HoverProvider {
         return {
-            provideHover: (model, position, token) => this.provideHover(handle, model, position, token)
+            provideHover: (model, position, token, context) =>
+                this.provideHover(handle, model, position, token, context as monaco.languages.HoverContext<HoverWithId> | undefined)
         };
     }
 
@@ -445,6 +451,45 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         });
     }
 
+    $registerMultiDocumentHighlightProvider(handle: number, _pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
+        const languageSelector = this.toLanguageSelector(selector);
+        const multiDocumentHighlightProvider = this.createMultiDocumentHighlightProvider(handle, languageSelector);
+        this.register(handle,
+            StandaloneServices.get(ILanguageFeaturesService).multiDocumentHighlightProvider.register(languageSelector, multiDocumentHighlightProvider));
+    }
+
+    protected createMultiDocumentHighlightProvider(handle: number, selector: LanguageSelector): MultiDocumentHighlightProvider {
+        return {
+            selector,
+            provideMultiDocumentHighlights: (model, position, otherModels, token) =>
+                // @monaco-uplift: cast due to ITextModel enum incompatibility between internal and standalone API types
+                this.provideMultiDocumentHighlights(handle, model as unknown as monaco.editor.ITextModel, position,
+                    otherModels as unknown as monaco.editor.ITextModel[], token)
+        };
+    }
+
+    protected provideMultiDocumentHighlights(
+        handle: number, model: monaco.editor.ITextModel, position: monaco.Position,
+        otherModels: monaco.editor.ITextModel[], token: monaco.CancellationToken
+    ): monaco.languages.ProviderResult<Map<monaco.Uri, monaco.languages.DocumentHighlight[]>> {
+        const otherResources = otherModels.map(m => m.uri);
+        return this.proxy.$provideMultiDocumentHighlights(handle, model.uri, position, otherResources, token).then(result => {
+            if (!result) {
+                return undefined;
+            }
+            const map = new Map<monaco.Uri, monaco.languages.DocumentHighlight[]>();
+            for (const entry of result) {
+                const uri = monaco.Uri.revive(entry.uri);
+                const highlights: monaco.languages.DocumentHighlight[] = entry.highlights.map(item => ({
+                    ...item,
+                    kind: item.kind ?? monaco.languages.DocumentHighlightKind.Text
+                }));
+                map.set(uri, highlights);
+            }
+            return map;
+        });
+    }
+
     $registerWorkspaceSymbolProvider(handle: number, pluginInfo: PluginInfo): void {
         const workspaceSymbolProvider = this.createWorkspaceSymbolProvider(handle);
         this.register(handle, this.monacoLanguages.registerWorkspaceSymbolProvider(workspaceSymbolProvider));
@@ -958,7 +1003,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
                 dispose: () => this.proxy.$releaseCodeActions(handle, actions.map(a => a.cacheId))
             };
         } catch (e) {
-            console.error(e);
+            this.logger.error(e);
             return undefined;
         }
     }

package/src/main/browser/lm-main.ts

@@ -64,7 +64,7 @@ export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionR
         try {
             const definitions = await this.$getServerDefinitions(handle);
             for (const definition of definitions) {
-                this.mcpServerManager.removeServer(definition.label);
+                await this.mcpServerManager.removeServer(definition.label);
             }
         } catch (error) {
             console.error('Error getting server definitions for removal:', error);
@@ -107,7 +107,7 @@ export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionR
 
             for (const definition of definitions) {
                 const mcpServerDescription = this.convertToMcpServerDescription(handle, definition);
-                this.mcpServerManager.addOrUpdateServer(mcpServerDescription);
+                await this.mcpServerManager.addOrUpdateServer(mcpServerDescription);
             }
         } catch (error) {
             console.error('Error loading MCP server definitions:', error);

package/src/main/browser/lm-tool-main.spec.ts

@@ -0,0 +1,126 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { LanguageModelToolsMainImpl } from './lm-tool-main';
+import {
+    ToolResultTextPartDto,
+    ToolResultDataPartDto,
+    ToolResultPromptTsxPartDto,
+    ToolResultUnknownPartDto,
+    ToolResultPartDto,
+    uint8ArrayToBase64,
+} from '../../common/lm-tool-protocol';
+import { ToolCallContentResult } from '@theia/ai-core/lib/common/language-model';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+
+// Access private methods for testing
+interface LmToolMainInternals {
+    convertDtoToToolCallResult(part: ToolResultPartDto): ToolCallContentResult;
+    convertDataPart(base64: string, mimeType: string): ToolCallContentResult;
+}
+
+function createInstance(): LmToolMainInternals {
+    const impl = Object.create(LanguageModelToolsMainImpl.prototype) as LanguageModelToolsMainImpl;
+    return impl as unknown as LmToolMainInternals;
+}
+
+describe('LanguageModelToolsMainImpl - DTO to ToolCallContentResult conversion', () => {
+    let instance: LmToolMainInternals;
+
+    beforeEach(() => {
+        instance = createInstance();
+    });
+
+    describe('convertDtoToToolCallResult', () => {
+        it('should convert text part DTO to ToolCallTextResult', () => {
+            const part: ToolResultTextPartDto = { type: 'text', value: 'hello world' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: 'hello world' });
+        });
+
+        it('should convert prompt-tsx part DTO to ToolCallTextResult with JSON', () => {
+            const part: ToolResultPromptTsxPartDto = { type: 'prompt-tsx', value: { foo: 'bar' } };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: '{"foo":"bar"}' });
+        });
+
+        it('should convert unknown part DTO to ToolCallTextResult', () => {
+            const part: ToolResultUnknownPartDto = { type: 'unknown', json: '{"custom":"data"}' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: '{"custom":"data"}' });
+        });
+
+        it('should convert data part with image mimeType to ToolCallImageResult', () => {
+            const base64 = btoa('fake-image-data');
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'image/png' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'image', base64data: base64, mimeType: 'image/png' });
+        });
+
+        it('should convert data part with audio mimeType to ToolCallAudioResult', () => {
+            const base64 = btoa('fake-audio-data');
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'audio/mp3' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'audio', data: base64, mimeType: 'audio/mp3' });
+        });
+
+        it('should convert data part with text/plain mimeType to ToolCallTextResult', () => {
+            const base64 = btoa('plain text content');
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'text/plain' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: 'plain text content' });
+        });
+
+        it('should convert data part with application/json mimeType to ToolCallTextResult', () => {
+            const jsonString = '{"key":"value"}';
+            const base64 = btoa(jsonString);
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'application/json' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: jsonString });
+        });
+
+        it('should convert data part with text/x-json mimeType to ToolCallTextResult', () => {
+            const jsonString = '{"data":123}';
+            const base64 = btoa(jsonString);
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'text/x-json' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: jsonString });
+        });
+
+        it('should convert data part with image/jpeg mimeType to ToolCallImageResult', () => {
+            const base64 = btoa('jpeg-data');
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'image/jpeg' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'image', base64data: base64, mimeType: 'image/jpeg' });
+        });
+
+        it('should convert data part with audio/wav mimeType to ToolCallAudioResult', () => {
+            const base64 = btoa('wav-data');
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'audio/wav' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'audio', data: base64, mimeType: 'audio/wav' });
+        });
+
+        it('should correctly decode UTF-8 text from base64 data part', () => {
+            const utf8Text = 'café 日本語';
+            const base64 = uint8ArrayToBase64(BinaryBuffer.fromString(utf8Text).buffer);
+            const part: ToolResultDataPartDto = { type: 'data', base64, mimeType: 'text/plain' };
+            const result = instance.convertDtoToToolCallResult(part);
+            expect(result).to.deep.equal({ type: 'text', text: utf8Text });
+        });
+    });
+});

package/src/main/browser/lm-tool-main.ts

@@ -0,0 +1,116 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { interfaces } from '@theia/core/shared/inversify';
+import { RPCProtocol } from '../../common/rpc-protocol';
+import {
+    LanguageModelToolsMain,
+    LanguageModelToolsExt,
+    LanguageModelToolDto,
+    ToolResultPartDto,
+    isToolInvocationError,
+    base64ToUint8Array,
+} from '../../common/lm-tool-protocol';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
+import { ToolInvocationRegistry } from '@theia/ai-core/lib/common';
+import { ToolRequest, ToolRequestParameters, ToolInvocationContext, ToolCallContent, ToolCallContentResult, createToolCallError } from '@theia/ai-core/lib/common/language-model';
+
+export class LanguageModelToolsMainImpl implements LanguageModelToolsMain {
+    private readonly proxy: LanguageModelToolsExt;
+    private readonly toolInvocationRegistry: ToolInvocationRegistry | undefined;
+    private readonly toolHandleToName = new Map<number, string>();
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.LM_TOOLS_EXT);
+        try {
+            this.toolInvocationRegistry = container.get(ToolInvocationRegistry);
+        } catch {
+            this.toolInvocationRegistry = undefined;
+        }
+    }
+
+    async $registerTool(handle: number, name: string, metadata: LanguageModelToolDto, pluginId: string): Promise<void> {
+        if (!this.toolInvocationRegistry) {
+            console.warn('ToolInvocationRegistry not available - tool will not be registered');
+            return;
+        }
+        if (this.toolInvocationRegistry.getFunction(name)) {
+            throw new Error(`Tool '${name}' is already registered.`);
+        }
+        const parameters: ToolRequestParameters = ToolRequest.isToolRequestParameters(metadata.inputSchema)
+            ? metadata.inputSchema as ToolRequestParameters
+            : { type: 'object', properties: {} };
+        // Note: metadata.tags is not forwarded to ToolRequest as ToolRequest has no tags field.
+        // Tags are exposed to extensions on the Ext side via lm.tools (LanguageModelToolInformation).
+        const toolRequest: ToolRequest = {
+            id: name,
+            name: name,
+            providerName: `plugin_lm_tools_${pluginId}`,
+            description: metadata.description,
+            parameters,
+            handler: async (argString: string, ctx?: ToolInvocationContext): Promise<ToolCallContent> => {
+                const result = await this.proxy.$invokeTool(handle, argString, ctx?.cancellationToken);
+                if (isToolInvocationError(result)) {
+                    return createToolCallError(result.error);
+                }
+                const content: ToolCallContentResult[] = result.content.map(part => this.convertDtoToToolCallResult(part));
+                return { content };
+            }
+        };
+        this.toolHandleToName.set(handle, name);
+        this.toolInvocationRegistry.registerTool(toolRequest);
+    }
+
+    $unregisterTool(handle: number): void {
+        if (!this.toolInvocationRegistry) {
+            return;
+        }
+        const name = this.toolHandleToName.get(handle);
+        if (name) {
+            this.toolInvocationRegistry.unregisterTool(name);
+            this.toolHandleToName.delete(handle);
+        }
+    }
+
+    private convertDtoToToolCallResult(part: ToolResultPartDto): ToolCallContentResult {
+        switch (part.type) {
+            case 'text':
+                return { type: 'text', text: part.value };
+            case 'data':
+                return this.convertDataPart(part.base64, part.mimeType);
+            case 'prompt-tsx':
+                return { type: 'text', text: JSON.stringify(part.value) };
+            case 'unknown':
+                return { type: 'text', text: part.json };
+        }
+    }
+
+    private convertDataPart(base64: string, mimeType: string): ToolCallContentResult {
+        if (mimeType.startsWith('image/')) {
+            return { type: 'image', base64data: base64, mimeType };
+        }
+        if (mimeType.startsWith('audio/')) {
+            return { type: 'audio', data: base64, mimeType };
+        }
+        // Text-like MIME types: decode base64 to string
+        const decoded = BinaryBuffer.wrap(base64ToUint8Array(base64)).toString();
+        return { type: 'text', text: decoded };
+    }
+}

package/src/main/browser/main-context.ts

@@ -67,6 +67,7 @@ import { TestingMainImpl } from './test-main';
 import { UriMainImpl } from './uri-main';
 import { LoggerMainImpl } from './logger-main';
 import { McpServerDefinitionRegistryMainImpl } from './lm-main';
+import { LanguageModelToolsMainImpl } from './lm-tool-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const loggerMain = new LoggerMainImpl(container);
@@ -211,4 +212,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const mcpServerDefinitionRegistryMain = new McpServerDefinitionRegistryMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_MAIN, mcpServerDefinitionRegistryMain);
+
+    const languageModelToolsMain = new LanguageModelToolsMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.LM_TOOLS_MAIN, languageModelToolsMain);
 }

package/src/main/browser/main-file-system-event-service.spec.ts

@@ -17,9 +17,12 @@
 import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
 const disableJSDOM = enableJSDOM();
 
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
 import * as assert from 'assert';
+import { URI } from '@theia/core';
 import { Disposable } from '@theia/core/lib/common/disposable';
-import { WatchOptions } from '@theia/filesystem/lib/common/files';
 import { UriComponents } from '../../common/uri-components';
 import { MainFileSystemEventService } from './main-file-system-event-service';
 
@@ -27,52 +30,96 @@ disableJSDOM();
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-// A VS Code plugin (e.g. `redhat.java` hosting JDT-LS) that calls
-// `vscode.workspace.createFileSystemWatcher` with a `RelativePattern` rooted at an absolute base
-// triggers `ExtHostFileSystemEventService.ensureWatching`, which sends `$watch` to this main-side
-// service with an EMPTY `excludes` list. As a result the user's `files.watcherExclude` preference
-// was never applied to these (often sibling-of-workspace) recursive watches, so they crawled and
-// watched whole external trees, exhausting the OS file-watch budget.
+// A language server (e.g. `redhat.java` / JDT-LS) registers a watcher rooted at the PARENT of the
+// workspace folder - `RelativePattern(parentDir, folderName)` - purely to detect deletion of the
+// workspace folder itself. The pattern has no globstar, so `ensureWatching` sends it as a
+// NON-recursive `$watch` on `parentDir`. Theia's backend ignores the `recursive` flag and always
+// watches recursively, so this turns into a recursive crawl of every sibling subtree under the
+// parent - thousands of inodes the workspace does not own - which can exhaust the OS file-watch
+// budget. `files.watcherExclude` cannot bound it because the root is outside the workspace.
 //
-// This test pins the fix: the main side must merge the configured `files.watcherExclude` patterns
-// into the watch options before delegating to the `FileService`.
-describe('MainFileSystemEventService files.watcherExclude handling', () => {
+// These tests pin the fix: a non-recursive watch rooted at a strict ancestor of a workspace root is
+// not registered, while watches on/inside the workspace and explicit recursive requests are
+// untouched.
+describe('MainFileSystemEventService ancestor-of-workspace watch handling', () => {
 
     function componentsFor(path: string): UriComponents {
         return { scheme: 'file', authority: '', path, query: '', fragment: '' };
     }
 
-    it('applies files.watcherExclude to plugin-created watches that arrive with empty excludes', () => {
-        const watchCalls: WatchOptions[] = [];
-
+    function createService(rootUris: string[], watchCalls: UriComponents[]): MainFileSystemEventService {
         const fileService: any = {
             onDidFilesChange: () => Disposable.NULL,
             onDidRunUserOperation: () => Disposable.NULL,
             addFileOperationParticipant: () => Disposable.NULL,
-            watch: (_resource: any, options: WatchOptions) => {
-                watchCalls.push(options);
+            watch: (resource: UriComponents) => {
+                watchCalls.push(resource);
                 return Disposable.NULL;
             }
         };
+        const workspaceService: any = { tryGetRoots: () => rootUris.map(uri => ({ resource: new URI(uri) })) };
+        const rpc: any = { getProxy: () => ({}) };
+        return new MainFileSystemEventService(rpc, {} as any, fileService, workspaceService);
+    }
 
-        const preferences: any = {
-            get: (preferenceName: string) => preferenceName === 'files.watcherExclude'
-                ? { '**/node_modules/**': true, '**/.git/objects/**': true, '**/disabled-exclude/**': false }
-                : undefined
-        };
+    it('skips a non-recursive watch rooted at a strict ancestor of a workspace root', () => {
+        const watchCalls: UriComponents[] = [];
+        const service = createService(['file:///projects/my-app'], watchCalls);
 
-        const rpc: any = { getProxy: () => ({}) };
+        service.$watch(1, componentsFor('/projects'), { recursive: false, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 0, 'ancestor-of-workspace watch must not be registered');
+    });
+
+    it('still registers a non-recursive watch on the workspace root itself', () => {
+        const watchCalls: UriComponents[] = [];
+        const service = createService(['file:///projects/my-app'], watchCalls);
+
+        service.$watch(1, componentsFor('/projects/my-app'), { recursive: false, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 1);
+    });
+
+    it('still registers a non-recursive watch on an outer root that is itself the parent of another root', () => {
+        const watchCalls: UriComponents[] = [];
+        // Multi-root workspace where `/projects` is a root AND the parent of the `/projects/my-app` root.
+        // The outer root is explicitly opened by the user, so its watch must not be dropped as an
+        // "ancestor of the workspace".
+        const service = createService(['file:///projects', 'file:///projects/my-app'], watchCalls);
+
+        service.$watch(1, componentsFor('/projects'), { recursive: false, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 1, 'a folder that is itself a workspace root must be watched, even if it is an ancestor of another root');
+    });
+
+    it('still registers a non-recursive watch inside the workspace', () => {
+        const watchCalls: UriComponents[] = [];
+        const service = createService(['file:///projects/my-app'], watchCalls);
+
+        service.$watch(1, componentsFor('/projects/my-app/src'), { recursive: false, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 1);
+    });
+
+    it('does not skip an explicit recursive watch on an ancestor (honored as requested)', () => {
+        const watchCalls: UriComponents[] = [];
+        const service = createService(['file:///projects/my-app'], watchCalls);
+
+        service.$watch(1, componentsFor('/projects'), { recursive: true, excludes: [] });
+
+        assert.strictEqual(watchCalls.length, 1);
+    });
 
-        const service = new MainFileSystemEventService(rpc, {} as any, fileService, preferences);
+    it('frees the session for a skipped watch so $unwatch and re-watch do not throw', () => {
+        const watchCalls: UriComponents[] = [];
+        const service = createService(['file:///projects/my-app'], watchCalls);
 
-        // Mirrors what `ensureWatching` sends for an absolute RelativePattern base outside the workspace.
-        service.$watch(1, componentsFor('/outside/workspace/storage'), { recursive: true, excludes: [] });
+        service.$watch(1, componentsFor('/projects'), { recursive: false, excludes: [] });
+        service.$unwatch(1);
+        // Re-using the same session id must not throw "already a watch request".
+        service.$watch(1, componentsFor('/projects'), { recursive: false, excludes: [] });
 
-        assert.strictEqual(watchCalls.length, 1, 'FileService.watch should have been called once');
-        const excludes = watchCalls[0].excludes;
-        assert.ok(excludes.includes('**/node_modules/**'), 'enabled watcherExclude pattern should be applied');
-        assert.ok(excludes.includes('**/.git/objects/**'), 'enabled watcherExclude pattern should be applied');
-        assert.ok(!excludes.includes('**/disabled-exclude/**'), 'patterns set to `false` must not be applied');
+        assert.strictEqual(watchCalls.length, 0);
     });
 
 });