VS Code Language Model (vscode.lm) & Chat Participant (vscode.chat) API Bridge

[codeCraft-Ritik]

Feature 1: VS Code Language Model (vscode.lm) & Chat Participant (vscode.chat) API Bridge

1. Feature Title

Bidirectional RPC Extension Host Bridge for VS Code Language Model (vscode.lm) and Chat Participant (vscode.chat) APIs

2. Problem / Gap

Theia's primary architectural differentiator is full compatibility with the VS Code extension ecosystem. Over 2024–2026, the extension ecosystem underwent an AI revolution: tools such as GitHub Copilot Chat, Continue, Cline, Roo Code, AWS Q Developer, and GitLab Duo standardized on two official VS Code APIs:

1. vscode.lm — To discover available language models (selectChatModels), stream completions (LanguageModelChat.sendRequest), and count tokens.
2. vscode.chat — To register interactive chat participants (createChatParticipant), custom prompt handlers, and mapped edit providers.

In Theia's current extension host implementation (packages/plugin-ext/src/plugin/plugin-context.ts#L1353-L1402), these core APIs are hardcoded as dead stubs:

// packages/plugin-ext/src/plugin/plugin-context.ts
const chat: typeof theia.chat = {
    /** @stubbed ChatRequestHandler */
    createChatParticipant(id: string, handler: theia.ChatRequestHandler): theia.ChatParticipant {
        return {
            id,
            requestHandler: handler,
            dispose() { },
            onDidReceiveFeedback: () => Event.None
        };
    }
};

const lm: typeof theia.lm = {
    /** @stubbed LanguageModelChat */
    selectChatModels(selector?: theia.LanguageModelChatSelector): Thenable<theia.LanguageModelChat[]> {
        return Promise.resolve([]); // Always empty!
    },
    /** @stubbed */
    registerLanguageModelChatProvider(vendor: string, provider: theia.LanguageModelChatProvider): theia.Disposable {
        return Disposable.NULL;
    }
};

Furthermore:

• In packages/plugin-ext/src/main/browser/lm-main.ts, only McpServerDefinitionRegistryMainImpl is implemented; there is no LanguageModelChatMainImpl or ChatParticipantMainImpl.
• In packages/plugin-ext/src/common/plugin-api-rpc.ts, LM_TOOLS_MAIN and LM_TOOLS_EXT exist for tools, but no RPC channel exists for chat models or chat participants.

Consequence: When users or enterprise adopters install modern AI extensions into Theia or Theia-based products (such as Arduino IDE 2.0, Eclipse Che, or Gitpod), the extensions fail silently or become completely unusable because no models are reported and chat participants are never wired into Theia's UI.

3. Proposed Solution

Build the bidirectional RPC bridge between Theia's extension host plugin process (@theia/plugin-ext) and Theia's existing native AI subsystem (@theia/ai-core and @theia/ai-chat):

+-------------------------------------------------------------+
| Extension Host Process (Plugin Runner)                      |
|                                                             |
|  [VS Code Extension (e.g. Continue / Cline / Copilot)]      |
|           |                                                 |
|    vscode.lm.selectChatModels() / sendRequest()             |
|    vscode.chat.createChatParticipant()                      |
|           v                                                 |
|  [LanguageModelExtImpl]      [ChatParticipantExtImpl]       |
+-------------------------------------------------------------+
                            |  RPC Protocol
                            v
+-------------------------------------------------------------+
| Theia Frontend / Main Process                               |
|                                                             |
|  [LanguageModelChatMainImpl]  [ChatParticipantMainImpl]     |
|           |                               |                 |
|           v                               v                 |
|  [LanguageModelRegistry]         [ChatAgentService]         |
|  (@theia/ai-core)                (@theia/ai-chat)           |
|           |                               |                 |
|  - Ollama / Claude / OpenAI      - Appears in Chat UI View  |
|  - Token Streaming & Cancel      - @participant in Chat     |
+-------------------------------------------------------------+

1. Model Discovery & Request Streaming: Connect vscode.lm.selectChatModels() via RPC to LanguageModelRegistry in @theia/ai-core. Streaming responses returned by LanguageModel.sendRequest() are streamed across the RPC channel using LanguageModelStreamResponse chunks.
2. Chat Participant Registration: Connect vscode.chat.createChatParticipant() to Theia's ChatAgentService. When an extension registers a participant, it is registered as an active chat agent, appearing in @theia/ai-chat-ui autocomplete (@<participantId>). User prompts directed to that participant are dispatched via RPC to the extension's handler.

4. Why it is Useful

• Immediate Extension Compatibility: Unlocks dozens of the most requested AI plugins on Open VSX and the VS Code marketplace with zero changes required to the extension code.
• Leverages Existing Infrastructure: Reuses Theia's already robust LanguageModelRegistry (which supports Anthropic, OpenAI, Ollama, Gemini, and local LLMs) to power VS Code extensions.
• Strategic IDE Positioning: Solidifies Theia's position as the leading open-source alternative to VS Code by eliminating the single biggest compatibility gap in the AI era.

5. Relevant Code / Files

• packages/plugin-ext/src/plugin/plugin-context.ts#L1353-L1402: Remove stubbed implementations for theia.chat and theia.lm.
• packages/plugin-ext/src/common/plugin-api-rpc.ts: Define MAIN_RPC_CONTEXT.LANGUAGE_MODEL_MAIN and EXT_RPC_CONTEXT.LANGUAGE_MODEL_EXT, plus CHAT_PARTICIPANT_MAIN and CHAT_PARTICIPANT_EXT.
• packages/plugin-ext/src/common/lm-protocol.ts: Declare RPC contracts LanguageModelChatMain, LanguageModelChatExt, ChatParticipantMain, and ChatParticipantExt.
• packages/plugin-ext/src/main/browser/lm-main.ts: Implement LanguageModelChatMainImpl and ChatParticipantMainImpl consuming LanguageModelRegistry and ChatAgentService.
• packages/plugin-ext/src/plugin/lm-ext.ts: Implement LanguageModelChatExtImpl with sendRequest() token generator and CancellationToken binding.
• packages/ai-core/src/common/language-model.ts#L761-L770: Reference existing LanguageModelRegistry methods (selectLanguageModels, getLanguageModels).

6. Implementation Idea

1. RPC Protocol Definition:

   export interface LanguageModelChatMain {
       $selectChatModels(selector?: LanguageModelChatSelectorDto): Promise<LanguageModelChatDto[]>;
       $sendChatRequest(handle: number, requestId: number, messages: LanguageModelChatMessageDto[], options: LanguageModelChatRequestOptionsDto): Promise<void>;
       $cancelChatRequest(requestId: number): void;
       $countTokens(modelId: string, text: string): Promise<number>;
   }
   export interface LanguageModelChatExt {
       $acceptChatResponseChunk(requestId: number, chunk: LanguageModelResponsePartDto): void;
       $acceptChatResponseDone(requestId: number, error?: string): void;
   }

2. Main-Side Wiring (LanguageModelChatMainImpl):
   Inject FrontendLanguageModelRegistry (or LanguageModelRegistry). Map Theia's LanguageModel objects to LanguageModelChatDto (id, vendor, family, name, version, maxInputTokens). On $sendChatRequest, invoke model.sendRequest(), listen to the stream, and push chunks across RPC via $acceptChatResponseChunk.
3. Chat Participant Bridge (ChatParticipantMainImpl):
   Implement an adapter that implements Theia's ChatAgent interface. When an extension calls $registerChatParticipant(id, name), register an agent with ChatAgentService. When the user types @participant <prompt> in Theia's AI Chat, invoke $handleChatParticipantRequest on the extension host.

7. Acceptance Criteria

• Calling vscode.lm.selectChatModels() from a sample VS Code extension returns all active models configured in Theia's LanguageModelRegistry.
• Streaming completions via chat.sendRequest(messages) stream tokens progressively to the extension without stalling the UI thread.
• Passing a vscode.CancellationToken aborts the in-flight request cleanly in Theia's backend provider.
• Extensions calling vscode.chat.createChatParticipant('copilot', handler) dynamically register @copilot in Theia's Chat UI input dropdown.
• Directing a chat prompt to @participant dispatches the request to the extension's handler and streams the response markdown into the active chat session.