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

package/src/plugin/lm-tool-ext.spec.ts

@@ -0,0 +1,152 @@
+// *****************************************************************************
+// 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 { LanguageModelToolsExtImpl } from './lm-tool-ext';
+import { ToolResultPartDto, uint8ArrayToBase64 } from '../common/lm-tool-protocol';
+
+// Access private methods for testing
+interface LmToolExtInternals {
+    convertPartToDto(part: unknown): ToolResultPartDto;
+    isTextPart(part: unknown): boolean;
+    isDataPart(part: unknown): boolean;
+    isPromptTsxPart(part: unknown): boolean;
+}
+
+function createInstance(): LmToolExtInternals {
+    const impl = Object.create(LanguageModelToolsExtImpl.prototype) as LanguageModelToolsExtImpl;
+    return impl as unknown as LmToolExtInternals;
+}
+
+describe('LanguageModelToolsExtImpl - Part to DTO conversion', () => {
+    let instance: LmToolExtInternals;
+
+    beforeEach(() => {
+        instance = createInstance();
+    });
+
+    describe('isTextPart', () => {
+        it('should return true for a text part with string value', () => {
+            expect(instance.isTextPart({ value: 'hello' })).to.be.true;
+        });
+
+        it('should return false for a data part (has data and mimeType)', () => {
+            expect(instance.isTextPart({ data: new Uint8Array([1, 2]), mimeType: 'text/plain' })).to.be.false;
+        });
+
+        it('should return false for a non-string value', () => {
+            expect(instance.isTextPart({ value: { foo: 'bar' } })).to.be.false;
+        });
+
+        it('should return false for undefined', () => {
+            expect(instance.isTextPart(undefined)).to.be.false;
+        });
+    });
+
+    describe('isDataPart', () => {
+        it('should return true for a data part', () => {
+            expect(instance.isDataPart({ data: new Uint8Array([1, 2]), mimeType: 'image/png' })).to.be.true;
+        });
+
+        it('should return false for a text part', () => {
+            expect(instance.isDataPart({ value: 'hello' })).to.be.false;
+        });
+
+        it('should return false for undefined', () => {
+            expect(instance.isDataPart(undefined)).to.be.false;
+        });
+    });
+
+    describe('isPromptTsxPart', () => {
+        it('should return true for a prompt-tsx part with non-string value', () => {
+            expect(instance.isPromptTsxPart({ value: { component: 'div' } })).to.be.true;
+        });
+
+        it('should return false for a text part with string value', () => {
+            expect(instance.isPromptTsxPart({ value: 'hello' })).to.be.false;
+        });
+
+        it('should return false for a data part', () => {
+            expect(instance.isPromptTsxPart({ data: new Uint8Array(), mimeType: 'text/plain' })).to.be.false;
+        });
+    });
+
+    describe('uint8ArrayToBase64', () => {
+        it('should encode an empty array', () => {
+            const result = uint8ArrayToBase64(new Uint8Array([]));
+            expect(result).to.equal('');
+        });
+
+        it('should encode a simple string as Uint8Array', () => {
+            const data = new Uint8Array(Buffer.from('hello'));
+            const result = uint8ArrayToBase64(data);
+            expect(result).to.equal(Buffer.from('hello').toString('base64'));
+        });
+
+        it('should encode binary data', () => {
+            const data = new Uint8Array([0, 1, 2, 255]);
+            const result = uint8ArrayToBase64(data);
+            expect(result).to.equal(Buffer.from([0, 1, 2, 255]).toString('base64'));
+        });
+    });
+
+    describe('convertPartToDto', () => {
+        it('should convert a LanguageModelTextPart to text DTO', () => {
+            const part = { value: 'some text' };
+            const result = instance.convertPartToDto(part);
+            expect(result).to.deep.equal({ type: 'text', value: 'some text' });
+        });
+
+        it('should convert a LanguageModelDataPart to data DTO', () => {
+            const data = new Uint8Array(Buffer.from('binary content'));
+            const part = { data, mimeType: 'application/octet-stream' };
+            const result = instance.convertPartToDto(part);
+            expect(result.type).to.equal('data');
+            expect((result as { base64: string }).base64).to.equal(Buffer.from('binary content').toString('base64'));
+            expect((result as { mimeType: string }).mimeType).to.equal('application/octet-stream');
+        });
+
+        it('should convert a LanguageModelPromptTsxPart to prompt-tsx DTO', () => {
+            const part = { value: { component: 'SomeComponent', props: { x: 1 } } };
+            const result = instance.convertPartToDto(part);
+            expect(result).to.deep.equal({ type: 'prompt-tsx', value: { component: 'SomeComponent', props: { x: 1 } } });
+        });
+
+        it('should convert an unknown part to unknown DTO', () => {
+            const part = { someUnknownField: 42 };
+            const result = instance.convertPartToDto(part);
+            expect(result).to.deep.equal({ type: 'unknown', json: '{"someUnknownField":42}' });
+        });
+
+        it('should convert a LanguageModelDataPart with image mime type to data DTO', () => {
+            const imageData = new Uint8Array([137, 80, 78, 71]); // PNG header bytes
+            const part = { data: imageData, mimeType: 'image/png' };
+            const result = instance.convertPartToDto(part);
+            expect(result.type).to.equal('data');
+            expect((result as { base64: string }).base64).to.equal(Buffer.from(imageData).toString('base64'));
+            expect((result as { mimeType: string }).mimeType).to.equal('image/png');
+        });
+
+        it('should convert a LanguageModelDataPart with text/x-json to data DTO', () => {
+            const jsonStr = '{"key":"value"}';
+            const data = new Uint8Array(Buffer.from(jsonStr));
+            const part = { data, mimeType: 'text/x-json' };
+            const result = instance.convertPartToDto(part);
+            expect(result.type).to.equal('data');
+            expect((result as { base64: string }).base64).to.equal(Buffer.from(jsonStr).toString('base64'));
+        });
+    });
+});

package/src/plugin/lm-tool-ext.ts

@@ -0,0 +1,197 @@
+// *****************************************************************************
+// 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 type * as theia from '@theia/plugin';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+
+import { RPCProtocol } from '../common/rpc-protocol';
+import {
+    LanguageModelToolsExt,
+    LanguageModelToolsMain,
+    LanguageModelToolDto,
+    ToolInvocationResult,
+    ToolResultPartDto,
+    isToolInvocationError,
+    uint8ArrayToBase64,
+    base64ToUint8Array,
+} from '../common/lm-tool-protocol';
+import { PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
+import { PluginPackageLanguageModelToolContribution } from '../common';
+import { PluginLogger } from './logger';
+import { Disposable, LanguageModelTextPart, LanguageModelPromptTsxPart, LanguageModelDataPart, LanguageModelToolResult } from './types-impl';
+
+export class LanguageModelToolsExtImpl implements LanguageModelToolsExt {
+
+    private proxy: LanguageModelToolsMain;
+    private logger: PluginLogger;
+    private handleCounter = 0;
+    private readonly tools = new Map<number, theia.LanguageModelTool<unknown>>();
+    private readonly toolNameToHandle = new Map<string, number>();
+    private readonly toolContributions = new Map<string, PluginPackageLanguageModelToolContribution>();
+    private readonly registeredToolMetadata = new Map<number, LanguageModelToolDto>();
+
+    constructor(protected readonly rpc: RPCProtocol) {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.LM_TOOLS_MAIN);
+        this.logger = new PluginLogger(this.rpc, 'lm-tools');
+    }
+
+    registerToolContributions(contributions: PluginPackageLanguageModelToolContribution[]): void {
+        for (const contribution of contributions) {
+            this.toolContributions.set(contribution.name, contribution);
+        }
+    }
+
+    registerTool<T>(name: string, tool: theia.LanguageModelTool<T>, pluginId: string): Disposable {
+        const contribution = this.toolContributions.get(name);
+        if (!contribution) {
+            this.logger.warn(`Tool '${name}' is not declared in package.json contributes.languageModelTools.`);
+        }
+        if (this.toolNameToHandle.has(name)) {
+            this.logger.warn(`Tool '${name}' is already registered. Ignoring duplicate registration.`);
+            return Disposable.NULL;
+        }
+        const handle = this.handleCounter++;
+        const metadata: LanguageModelToolDto = {
+            name,
+            description: contribution?.modelDescription,
+            inputSchema: contribution?.inputSchema,
+            tags: contribution?.tags,
+        };
+        this.tools.set(handle, tool);
+        this.toolNameToHandle.set(name, handle);
+        this.registeredToolMetadata.set(handle, metadata);
+        this.proxy.$registerTool(handle, name, metadata, pluginId).catch(err => {
+            this.logger.error(`Failed to register tool '${name}': ${err.message || err}`);
+            this.tools.delete(handle);
+            this.toolNameToHandle.delete(name);
+            this.registeredToolMetadata.delete(handle);
+        });
+
+        return new Disposable(() => {
+            this.tools.delete(handle);
+            this.toolNameToHandle.delete(name);
+            this.registeredToolMetadata.delete(handle);
+            this.proxy.$unregisterTool(handle);
+        });
+    }
+
+    async invokeTool(name: string, options: theia.LanguageModelToolInvocationOptions<object>, token?: CancellationToken): Promise<theia.LanguageModelToolResult> {
+        const handle = this.toolNameToHandle.get(name);
+        if (handle === undefined) {
+            throw new Error(`Tool '${name}' is not registered.`);
+        }
+        const result = await this.$invokeTool(handle, JSON.stringify(options.input), token);
+        if (isToolInvocationError(result)) {
+            throw new Error(result.error);
+        }
+        return new LanguageModelToolResult(result.content.map(part => this.convertDtoToApiPart(part)));
+    }
+
+    getTools(): theia.LanguageModelToolInformation[] {
+        const result = new Map<string, theia.LanguageModelToolInformation>();
+        // Add declared tool contributions from package.json
+        for (const c of this.toolContributions.values()) {
+            result.set(c.name, {
+                name: c.name,
+                description: c.modelDescription ?? '',
+                inputSchema: c.inputSchema,
+                tags: c.tags ?? [],
+            });
+        }
+        // Add dynamically registered tools not already covered by declarations
+        for (const [name, handle] of this.toolNameToHandle.entries()) {
+            if (!result.has(name)) {
+                const metadata = this.registeredToolMetadata.get(handle);
+                if (metadata) {
+                    result.set(name, {
+                        name: metadata.name,
+                        description: metadata.description ?? '',
+                        inputSchema: metadata.inputSchema,
+                        tags: metadata.tags ?? [],
+                    });
+                }
+            }
+        }
+        return [...result.values()];
+    }
+
+    async $invokeTool(handle: number, argsString: string, token?: CancellationToken): Promise<ToolInvocationResult> {
+        const tool = this.tools.get(handle);
+        if (!tool) {
+            return { error: `Tool with handle ${handle} not found` };
+        }
+        try {
+            const input = argsString ? JSON.parse(argsString) : {};
+            const cancellationToken = token ?? CancellationToken.None;
+            const result = await tool.invoke(
+                { input, toolInvocationToken: undefined },
+                cancellationToken
+            );
+            if (!result) {
+                return { content: [] };
+            }
+            return { content: result.content.map(part => this.convertPartToDto(part)) };
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return { error: errorMessage };
+        }
+    }
+
+    private convertPartToDto(part: unknown): ToolResultPartDto {
+        if (this.isTextPart(part)) {
+            return { type: 'text', value: part.value };
+        }
+        if (this.isDataPart(part)) {
+            const base64 = uint8ArrayToBase64(part.data);
+            return { type: 'data', base64, mimeType: part.mimeType };
+        }
+        if (this.isPromptTsxPart(part)) {
+            return { type: 'prompt-tsx', value: part.value };
+        }
+        return { type: 'unknown', json: JSON.stringify(part) };
+    }
+
+    private isTextPart(part: unknown): part is { value: string } {
+        return typeof part === 'object' && part !== undefined
+            && 'value' in (part as object) && typeof (part as { value: unknown }).value === 'string'
+            && !('data' in (part as object)) && !('mimeType' in (part as object));
+    }
+
+    private isDataPart(part: unknown): part is { data: Uint8Array; mimeType: string } {
+        return typeof part === 'object' && part !== undefined
+            && 'data' in (part as object) && 'mimeType' in (part as object)
+            && typeof (part as { mimeType: unknown }).mimeType === 'string';
+    }
+
+    private isPromptTsxPart(part: unknown): part is { value: unknown } {
+        return typeof part === 'object' && part !== undefined
+            && 'value' in (part as object) && typeof (part as { value: unknown }).value !== 'string'
+            && !('data' in (part as object)) && !('mimeType' in (part as object));
+    }
+
+    private convertDtoToApiPart(part: ToolResultPartDto): theia.LanguageModelTextPart | theia.LanguageModelPromptTsxPart | theia.LanguageModelDataPart {
+        switch (part.type) {
+            case 'text':
+                return new LanguageModelTextPart(part.value);
+            case 'data':
+                return new LanguageModelDataPart(base64ToUint8Array(part.base64), part.mimeType);
+            case 'prompt-tsx':
+                return new LanguageModelPromptTsxPart(part.value);
+            case 'unknown':
+                return new LanguageModelTextPart(part.json);
+        }
+    }
+}

package/src/plugin/plugin-context.ts

@@ -297,6 +297,7 @@ import { TestingExtImpl } from './tests';
 import { UriExtImpl } from './uri-ext';
 import { PluginLogger } from './logger';
 import { LmExtImpl } from './lm-ext';
+import { LanguageModelToolsExtImpl } from './lm-tool-ext';
 
 export function createAPIObject<T extends Object>(rawObject: T): T {
     return new Proxy(rawObject, {
@@ -362,6 +363,7 @@ export function createAPIFactory(
     const testingExt = rpc.set(MAIN_RPC_CONTEXT.TESTING_EXT, new TestingExtImpl(rpc, commandRegistry));
     const uriExt = rpc.set(MAIN_RPC_CONTEXT.URI_EXT, new UriExtImpl(rpc));
     const lmExt = rpc.set(MAIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_EXT, new LmExtImpl(rpc));
+    const lmToolExt = rpc.set(MAIN_RPC_CONTEXT.LM_TOOLS_EXT, new LanguageModelToolsExtImpl(rpc));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     const commandLogger = new PluginLogger(rpc, 'commands-plugin');
@@ -1061,12 +1063,8 @@ export function createAPIFactory(
             registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider): theia.Disposable {
                 return languagesExt.registerDocumentHighlightProvider(selector, provider, pluginToPluginInfo(plugin));
             },
-            /**
-             * @stubbed
-             * @monaco-uplift: wait until API is available in Monaco (1.85.0+)
-             */
             registerMultiDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.MultiDocumentHighlightProvider): theia.Disposable {
-                return Disposable.NULL;
+                return languagesExt.registerMultiDocumentHighlightProvider(selector, provider, pluginToPluginInfo(plugin));
             },
             registerWorkspaceSymbolProvider(provider: theia.WorkspaceSymbolProvider): theia.Disposable {
                 return languagesExt.registerWorkspaceSymbolProvider(provider, pluginToPluginInfo(plugin));
@@ -1374,6 +1372,9 @@ export function createAPIFactory(
         const mcpContributions = plugin.rawModel.contributes && plugin.rawModel.contributes.mcpServerDefinitionProviders || [];
         lmExt.registerMcpContributions(mcpContributions);
 
+        const toolContributions = plugin.rawModel.contributes && plugin.rawModel.contributes.languageModelTools || [];
+        lmToolExt.registerToolContributions(toolContributions);
+
         const lm: typeof theia.lm = {
             /** @stubbed LanguageModelChat */
             selectChatModels(selector?: theia.LanguageModelChatSelector): Thenable<theia.LanguageModelChat[]> {
@@ -1381,16 +1382,15 @@ export function createAPIFactory(
             },
             /** @stubbed LanguageModelChat */
             onDidChangeChatModels: (listener, thisArgs?, disposables?) => Event.None(listener, thisArgs, disposables),
-            /** @stubbed LanguageModelTool */
             invokeTool(name: string, options: theia.LanguageModelToolInvocationOptions<object>, token?: CancellationToken): Thenable<theia.LanguageModelToolResult> {
-                return Promise.resolve({ content: [] });
+                return lmToolExt.invokeTool(name, options, token);
             },
-            /** @stubbed LanguageModelTool */
             registerTool<T>(name: string, tool: theia.LanguageModelTool<T>): Disposable {
-                return Disposable.NULL;
+                return lmToolExt.registerTool(name, tool, plugin.model.id);
+            },
+            get tools(): readonly theia.LanguageModelToolInformation[] {
+                return lmToolExt.getTools();
             },
-            /** @stubbed LanguageModelTool */
-            tools: [],
             registerMcpServerDefinitionProvider(id: string, provider: any): theia.Disposable {
                 return lmExt.registerMcpServerDefinitionProvider(id, provider);
             },

package/src/plugin/types-impl.ts

@@ -4126,7 +4126,11 @@ export class LanguageModelToolCallPart {
     name: string;
     input: object;
 
-    constructor(callId: string, name: string, input: object) { }
+    constructor(callId: string, name: string, input: object) {
+        this.callId = callId;
+        this.name = name;
+        this.input = input;
+    }
 }
 
 /**
@@ -4136,24 +4140,25 @@ export class LanguageModelToolResultPart {
     callId: string;
     content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>;
 
-    constructor(callId: string, content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>) { }
+    constructor(callId: string, content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>) {
+        this.callId = callId;
+        this.content = content;
+    }
 }
 
-/**
- * @stubbed
- */
 export class LanguageModelTextPart {
     value: string;
-    constructor(value: string) { }
+    constructor(value: string) {
+        this.value = value;
+    }
 }
 
-/**
- * @stubbed
- */
 export class LanguageModelToolResult {
     content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>;
 
-    constructor(content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>) { }
+    constructor(content: Array<LanguageModelTextPart | LanguageModelPromptTsxPart | LanguageModelDataPart | unknown>) {
+        this.content = content;
+    }
 }
 
 /**
@@ -4162,12 +4167,11 @@ export class LanguageModelToolResult {
 export class LanguageModelPromptTsxPart {
     value: unknown;
 
-    constructor(value: unknown) { }
+    constructor(value: unknown) {
+        this.value = value;
+    }
 }
 
-/**
- * @stubbed
- */
 export class LanguageModelDataPart {
     static image(data: Uint8Array, mime: string): LanguageModelDataPart {
         return new LanguageModelDataPart(data, mime);
@@ -4182,7 +4186,10 @@ export class LanguageModelDataPart {
     }
     mimeType: string;
     data: Uint8Array;
-    constructor(data: Uint8Array, mimeType: string) { }
+    constructor(data: Uint8Array, mimeType: string) {
+        this.data = data;
+        this.mimeType = mimeType;
+    }
 }
 
 /**