@theia/ai-copilot 1.68.0-next.79

package/src/common/index.ts

@@ -0,0 +1,19 @@
+// *****************************************************************************
+// Copyright (C) 2026 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
+// *****************************************************************************
+
+export * from './copilot-language-models-manager';
+export * from './copilot-auth-service';
+export * from './copilot-preferences';

package/src/node/copilot-auth-service-impl.ts

@@ -0,0 +1,274 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { Emitter, Event } from '@theia/core';
+import { KeyStoreService } from '@theia/core/lib/common/key-store';
+import {
+    CopilotAuthService,
+    CopilotAuthServiceClient,
+    CopilotAuthState,
+    DeviceCodeResponse
+} from '../common/copilot-auth-service';
+
+const COPILOT_CLIENT_ID = 'Iv23ctNZvWb5IGBKdyPY';
+const COPILOT_SCOPE = 'read:user';
+const COPILOT_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
+const KEYSTORE_SERVICE = 'theia-copilot-auth';
+const KEYSTORE_ACCOUNT = 'github-copilot';
+const USER_AGENT = 'Theia-Copilot/1.0.0';
+
+/**
+ * Maximum number of polling attempts for token retrieval.
+ * With a default 5-second interval, this allows approximately 5 minutes of polling.
+ */
+const MAX_POLLING_ATTEMPTS = 60;
+
+interface StoredCredentials {
+    accessToken: string;
+    accountLabel?: string;
+    enterpriseUrl?: string;
+}
+
+/**
+ * Backend implementation of the GitHub Copilot OAuth Device Flow authentication service.
+ * Handles device code generation, token polling, and credential storage.
+ */
+@injectable()
+export class CopilotAuthServiceImpl implements CopilotAuthService {
+
+    @inject(KeyStoreService)
+    protected readonly keyStoreService: KeyStoreService;
+
+    protected client: CopilotAuthServiceClient | undefined;
+    protected cachedState: CopilotAuthState | undefined;
+
+    protected readonly onAuthStateChangedEmitter = new Emitter<CopilotAuthState>();
+    readonly onAuthStateChanged: Event<CopilotAuthState> = this.onAuthStateChangedEmitter.event;
+
+    setClient(client: CopilotAuthServiceClient | undefined): void {
+        this.client = client;
+    }
+
+    protected getOAuthEndpoints(enterpriseUrl?: string): { deviceCodeUrl: string; accessTokenUrl: string } {
+        if (enterpriseUrl) {
+            const domain = enterpriseUrl
+                .replace(/^https?:\/\//, '')
+                .replace(/\/$/, '');
+            return {
+                deviceCodeUrl: `https://${domain}/login/device/code`,
+                accessTokenUrl: `https://${domain}/login/oauth/access_token`
+            };
+        }
+        return {
+            deviceCodeUrl: 'https://github.com/login/device/code',
+            accessTokenUrl: 'https://github.com/login/oauth/access_token'
+        };
+    }
+
+    async initiateDeviceFlow(enterpriseUrl?: string): Promise<DeviceCodeResponse> {
+        const endpoints = this.getOAuthEndpoints(enterpriseUrl);
+
+        const response = await fetch(endpoints.deviceCodeUrl, {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'User-Agent': USER_AGENT
+            },
+            body: JSON.stringify({
+                client_id: COPILOT_CLIENT_ID,
+                scope: COPILOT_SCOPE
+            })
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to initiate device authorization: ${response.status} - ${errorText}`);
+        }
+
+        const data = await response.json() as DeviceCodeResponse;
+        return data;
+    }
+
+    async pollForToken(deviceCode: string, interval: number, enterpriseUrl?: string): Promise<boolean> {
+        const endpoints = this.getOAuthEndpoints(enterpriseUrl);
+        let attempts = 0;
+
+        while (attempts < MAX_POLLING_ATTEMPTS) {
+            await this.delay(interval * 1000);
+            attempts++;
+
+            const response = await fetch(endpoints.accessTokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    'User-Agent': USER_AGENT
+                },
+                body: JSON.stringify({
+                    client_id: COPILOT_CLIENT_ID,
+                    device_code: deviceCode,
+                    grant_type: COPILOT_GRANT_TYPE
+                })
+            });
+
+            if (!response.ok) {
+                console.error(`Token request failed: ${response.status}`);
+                continue;
+            }
+
+            const data = await response.json() as {
+                access_token?: string;
+                error?: string;
+                error_description?: string;
+            };
+
+            if (data.access_token) {
+                // Get user info for account label
+                const accountLabel = await this.fetchAccountLabel(data.access_token, enterpriseUrl);
+
+                // Store credentials
+                const credentials: StoredCredentials = {
+                    accessToken: data.access_token,
+                    accountLabel,
+                    enterpriseUrl
+                };
+
+                await this.keyStoreService.setPassword(
+                    KEYSTORE_SERVICE,
+                    KEYSTORE_ACCOUNT,
+                    JSON.stringify(credentials)
+                );
+
+                // Update cached state and notify
+                const newState: CopilotAuthState = {
+                    isAuthenticated: true,
+                    accountLabel,
+                    enterpriseUrl
+                };
+                this.updateAuthState(newState);
+
+                return true;
+            }
+
+            if (data.error === 'authorization_pending') {
+                // User hasn't authorized yet, continue polling
+                continue;
+            }
+
+            if (data.error === 'slow_down') {
+                // Increase polling interval
+                interval += 5;
+                continue;
+            }
+
+            if (data.error === 'expired_token' || data.error === 'access_denied') {
+                console.error(`Authorization failed: ${data.error} - ${data.error_description}`);
+                return false;
+            }
+
+            if (data.error) {
+                console.error(`Unexpected error: ${data.error} - ${data.error_description}`);
+                return false;
+            }
+        }
+
+        return false;
+    }
+
+    protected async fetchAccountLabel(accessToken: string, enterpriseUrl?: string): Promise<string | undefined> {
+        try {
+            const apiBaseUrl = enterpriseUrl
+                ? `https://${enterpriseUrl.replace(/^https?:\/\//, '').replace(/\/$/, '')}/api/v3`
+                : 'https://api.github.com';
+
+            const response = await fetch(`${apiBaseUrl}/user`, {
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'User-Agent': USER_AGENT,
+                    'Accept': 'application/vnd.github.v3+json'
+                }
+            });
+
+            if (response.ok) {
+                const userData = await response.json() as { login?: string };
+                return userData.login;
+            }
+        } catch (error) {
+            console.warn('Failed to fetch GitHub user info:', error);
+        }
+        return undefined;
+    }
+
+    async getAuthState(): Promise<CopilotAuthState> {
+        if (this.cachedState) {
+            return this.cachedState;
+        }
+
+        try {
+            const stored = await this.keyStoreService.getPassword(KEYSTORE_SERVICE, KEYSTORE_ACCOUNT);
+            if (stored) {
+                const credentials: StoredCredentials = JSON.parse(stored);
+                this.cachedState = {
+                    isAuthenticated: true,
+                    accountLabel: credentials.accountLabel,
+                    enterpriseUrl: credentials.enterpriseUrl
+                };
+                return this.cachedState;
+            }
+        } catch (error) {
+            console.warn('Failed to retrieve Copilot credentials:', error);
+        }
+
+        this.cachedState = { isAuthenticated: false };
+        return this.cachedState;
+    }
+
+    async getAccessToken(): Promise<string | undefined> {
+        try {
+            const stored = await this.keyStoreService.getPassword(KEYSTORE_SERVICE, KEYSTORE_ACCOUNT);
+            if (stored) {
+                const credentials: StoredCredentials = JSON.parse(stored);
+                return credentials.accessToken;
+            }
+        } catch (error) {
+            console.warn('Failed to retrieve Copilot access token:', error);
+        }
+        return undefined;
+    }
+
+    async signOut(): Promise<void> {
+        try {
+            await this.keyStoreService.deletePassword(KEYSTORE_SERVICE, KEYSTORE_ACCOUNT);
+        } catch (error) {
+            console.warn('Failed to delete Copilot credentials:', error);
+        }
+
+        const newState: CopilotAuthState = { isAuthenticated: false };
+        this.updateAuthState(newState);
+    }
+
+    protected updateAuthState(state: CopilotAuthState): void {
+        this.cachedState = state;
+        this.onAuthStateChangedEmitter.fire(state);
+        this.client?.onAuthStateChanged(state);
+    }
+
+    protected delay(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}

package/src/node/copilot-backend-module.ts

@@ -0,0 +1,58 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { ConnectionHandler, RpcConnectionHandler } from '@theia/core';
+import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+import {
+    CopilotLanguageModelsManager,
+    COPILOT_LANGUAGE_MODELS_MANAGER_PATH,
+    CopilotAuthService,
+    COPILOT_AUTH_SERVICE_PATH,
+    CopilotAuthServiceClient
+} from '../common';
+import { CopilotLanguageModelsManagerImpl } from './copilot-language-models-manager-impl';
+import { CopilotAuthServiceImpl } from './copilot-auth-service-impl';
+
+const copilotConnectionModule = ConnectionContainerModule.create(({ bind }) => {
+    bind(CopilotAuthServiceImpl).toSelf().inSingletonScope();
+    bind(CopilotAuthService).toService(CopilotAuthServiceImpl);
+
+    bind(CopilotLanguageModelsManagerImpl).toSelf().inSingletonScope();
+    bind(CopilotLanguageModelsManager).toService(CopilotLanguageModelsManagerImpl);
+
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new RpcConnectionHandler<CopilotAuthServiceClient>(
+            COPILOT_AUTH_SERVICE_PATH,
+            client => {
+                const authService = ctx.container.get<CopilotAuthServiceImpl>(CopilotAuthService);
+                authService.setClient(client);
+                return authService;
+            }
+        )
+    ).inSingletonScope();
+
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new RpcConnectionHandler(
+            COPILOT_LANGUAGE_MODELS_MANAGER_PATH,
+            () => ctx.container.get(CopilotLanguageModelsManager)
+        )
+    ).inSingletonScope();
+});
+
+export default new ContainerModule(bind => {
+    bind(ConnectionContainerModule).toConstantValue(copilotConnectionModule);
+});

package/src/node/copilot-language-model.ts

@@ -0,0 +1,262 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 {
+    ImageContent,
+    LanguageModel,
+    LanguageModelMessage,
+    LanguageModelParsedResponse,
+    LanguageModelRequest,
+    LanguageModelResponse,
+    LanguageModelStatus,
+    LanguageModelTextResponse,
+    TokenUsageService,
+    UserRequest
+} from '@theia/ai-core';
+import { CancellationToken } from '@theia/core';
+import OpenAI from 'openai';
+import { RunnableToolFunctionWithoutParse } from 'openai/lib/RunnableFunction';
+import { ChatCompletionMessageParam } from 'openai/resources';
+import { StreamingAsyncIterator } from '@theia/ai-openai/lib/node/openai-streaming-iterator';
+import { COPILOT_PROVIDER_ID } from '../common';
+import type { RunnerOptions } from 'openai/lib/AbstractChatCompletionRunner';
+import type { ChatCompletionStream } from 'openai/lib/ChatCompletionStream';
+
+const COPILOT_API_BASE_URL = 'https://api.githubcopilot.com';
+const USER_AGENT = 'Theia-Copilot/1.0.0';
+
+/**
+ * Language model implementation for GitHub Copilot.
+ * Uses the OpenAI SDK to communicate with the Copilot API.
+ */
+export class CopilotLanguageModel implements LanguageModel {
+
+    protected runnerOptions: RunnerOptions = {
+        maxChatCompletions: 100
+    };
+
+    constructor(
+        public readonly id: string,
+        public model: string,
+        public status: LanguageModelStatus,
+        public enableStreaming: boolean,
+        public supportsStructuredOutput: boolean,
+        public maxRetries: number,
+        protected readonly accessTokenProvider: () => Promise<string | undefined>,
+        protected readonly enterpriseUrlProvider: () => string | undefined,
+        protected readonly tokenUsageService?: TokenUsageService
+    ) { }
+
+    protected getSettings(request: LanguageModelRequest): Record<string, unknown> {
+        return request.settings ?? {};
+    }
+
+    async request(request: UserRequest, cancellationToken?: CancellationToken): Promise<LanguageModelResponse> {
+        const openai = await this.initializeCopilotClient();
+
+        if (request.response_format?.type === 'json_schema' && this.supportsStructuredOutput) {
+            return this.handleStructuredOutputRequest(openai, request);
+        }
+
+        const settings = this.getSettings(request);
+
+        if (!this.enableStreaming || (typeof settings.stream === 'boolean' && !settings.stream)) {
+            return this.handleNonStreamingRequest(openai, request);
+        }
+
+        if (cancellationToken?.isCancellationRequested) {
+            return { text: '' };
+        }
+
+        if (this.id.startsWith(`${COPILOT_PROVIDER_ID}/`)) {
+            settings['stream_options'] = { include_usage: true };
+        }
+
+        let runner: ChatCompletionStream;
+        const tools = this.createTools(request);
+
+        if (tools) {
+            runner = openai.chat.completions.runTools({
+                model: this.model,
+                messages: this.processMessages(request.messages),
+                stream: true,
+                tools: tools,
+                tool_choice: 'auto',
+                ...settings
+            }, {
+                ...this.runnerOptions,
+                maxRetries: this.maxRetries
+            });
+        } else {
+            runner = openai.chat.completions.stream({
+                model: this.model,
+                messages: this.processMessages(request.messages),
+                stream: true,
+                ...settings
+            });
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { stream: new StreamingAsyncIterator(runner as any, request.requestId, cancellationToken, this.tokenUsageService, this.id) };
+    }
+
+    protected async handleNonStreamingRequest(openai: OpenAI, request: UserRequest): Promise<LanguageModelTextResponse> {
+        const settings = this.getSettings(request);
+        const response = await openai.chat.completions.create({
+            model: this.model,
+            messages: this.processMessages(request.messages),
+            ...settings
+        });
+
+        const message = response.choices[0].message;
+
+        if (this.tokenUsageService && response.usage) {
+            await this.tokenUsageService.recordTokenUsage(
+                this.id,
+                {
+                    inputTokens: response.usage.prompt_tokens,
+                    outputTokens: response.usage.completion_tokens,
+                    requestId: request.requestId
+                }
+            );
+        }
+
+        return {
+            text: message.content ?? ''
+        };
+    }
+
+    protected async handleStructuredOutputRequest(openai: OpenAI, request: UserRequest): Promise<LanguageModelParsedResponse> {
+        const settings = this.getSettings(request);
+        const result = await openai.chat.completions.parse({
+            model: this.model,
+            messages: this.processMessages(request.messages),
+            response_format: request.response_format,
+            ...settings
+        });
+
+        const message = result.choices[0].message;
+        if (message.refusal || message.parsed === undefined) {
+            console.error('Error in Copilot chat completion:', JSON.stringify(message));
+        }
+
+        if (this.tokenUsageService && result.usage) {
+            await this.tokenUsageService.recordTokenUsage(
+                this.id,
+                {
+                    inputTokens: result.usage.prompt_tokens,
+                    outputTokens: result.usage.completion_tokens,
+                    requestId: request.requestId
+                }
+            );
+        }
+
+        return {
+            content: message.content ?? '',
+            parsed: message.parsed
+        };
+    }
+
+    protected createTools(request: LanguageModelRequest): RunnableToolFunctionWithoutParse[] | undefined {
+        return request.tools?.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+                function: (args_string: string) => tool.handler(args_string)
+            }
+        } as RunnableToolFunctionWithoutParse));
+    }
+
+    protected async initializeCopilotClient(): Promise<OpenAI> {
+        const accessToken = await this.accessTokenProvider();
+        if (!accessToken) {
+            throw new Error('Not authenticated with GitHub Copilot. Please sign in first.');
+        }
+
+        const enterpriseUrl = this.enterpriseUrlProvider();
+        const baseURL = enterpriseUrl
+            ? `https://copilot-api.${enterpriseUrl.replace(/^https?:\/\//, '').replace(/\/$/, '')}`
+            : COPILOT_API_BASE_URL;
+
+        return new OpenAI({
+            apiKey: accessToken,
+            baseURL,
+            defaultHeaders: {
+                'User-Agent': USER_AGENT,
+                'Openai-Intent': 'conversation-edits',
+                'X-Initiator': 'user'
+            }
+        });
+    }
+
+    protected processMessages(messages: LanguageModelMessage[]): ChatCompletionMessageParam[] {
+        return messages.filter(m => m.type !== 'thinking').map(m => this.toOpenAIMessage(m));
+    }
+
+    protected toOpenAIMessage(message: LanguageModelMessage): ChatCompletionMessageParam {
+        if (LanguageModelMessage.isTextMessage(message)) {
+            return {
+                role: this.toOpenAiRole(message),
+                content: message.text
+            };
+        }
+        if (LanguageModelMessage.isToolUseMessage(message)) {
+            return {
+                role: 'assistant',
+                tool_calls: [{
+                    id: message.id,
+                    function: {
+                        name: message.name,
+                        arguments: JSON.stringify(message.input)
+                    },
+                    type: 'function'
+                }]
+            };
+        }
+        if (LanguageModelMessage.isToolResultMessage(message)) {
+            return {
+                role: 'tool',
+                tool_call_id: message.tool_use_id,
+                content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
+            };
+        }
+        if (LanguageModelMessage.isImageMessage(message) && message.actor === 'user') {
+            return {
+                role: 'user',
+                content: [{
+                    type: 'image_url',
+                    image_url: {
+                        url: ImageContent.isBase64(message.image)
+                            ? `data:${message.image.mimeType};base64,${message.image.base64data}`
+                            : message.image.url
+                    }
+                }]
+            };
+        }
+        throw new Error(`Unknown message type: '${JSON.stringify(message)}'`);
+    }
+
+    protected toOpenAiRole(message: LanguageModelMessage): 'developer' | 'user' | 'assistant' | 'system' {
+        if (message.actor === 'system') {
+            return 'developer';
+        } else if (message.actor === 'ai') {
+            return 'assistant';
+        }
+        return 'user';
+    }
+}