@theia/ai-copilot 1.76.0-next.7 → 1.76.0

package/src/browser/copilot-auth-dialog.tsx

@@ -16,7 +16,7 @@
 
 import * as React from '@theia/core/shared/react';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { DialogProps, DialogError } from '@theia/core/lib/browser/dialogs';
+import { DialogProps, DialogError, Dialog } from '@theia/core/lib/browser/dialogs';
 import { ReactDialog } from '@theia/core/lib/browser/dialogs/react-dialog';
 import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
@@ -68,22 +68,19 @@ export class CopilotAuthDialog extends ReactDialog<boolean> {
     protected init(): void {
         this.titleNode.textContent = this.props.title;
         this.appendAcceptButton(nls.localize('theia/ai/copilot/auth/authorize', 'I have authorized'));
-        this.appendCloseButton(nls.localizeByDefault('Cancel'));
+        this.appendCloseButton(Dialog.CANCEL);
     }
 
     protected updateButtonStates(): void {
         const isPolling = this.state === 'polling';
         const isSuccess = this.state === 'success';
+        // Singleton dialog: button state survives close, so reset it on every render.
         if (this.acceptButton) {
             this.acceptButton.disabled = isPolling || isSuccess;
-            if (isSuccess) {
-                this.acceptButton.style.display = 'none';
-            }
+            this.acceptButton.style.display = isSuccess ? 'none' : '';
         }
         if (this.closeButton) {
-            if (isSuccess) {
-                this.closeButton.textContent = nls.localizeByDefault('Close');
-            }
+            this.closeButton.textContent = isSuccess ? nls.localizeByDefault('Close') : Dialog.CANCEL;
         }
     }
 
@@ -105,6 +102,9 @@ export class CopilotAuthDialog extends ReactDialog<boolean> {
     protected async initiateFlow(): Promise<void> {
         try {
             this.state = 'loading';
+            this.deviceCodeResponse = undefined;
+            this.errorMessage = undefined;
+            this.copied = false;
             this.update();
 
             this.deviceCodeResponse = await this.authService.startSignIn(this.props.enterpriseUrl);

package/src/browser/copilot-frontend-application-contribution.ts

@@ -22,6 +22,9 @@ import { CopilotAuthService, CopilotLanguageModelsManager, CopilotModelDescripti
 import { COPILOT_ENABLED_PREF, COPILOT_ENTERPRISE_URL_PREF, COPILOT_EXECUTABLE_PATH_PREF, COPILOT_MODEL_OVERRIDES_PREF } from '../common/copilot-preferences';
 import { AICorePreferences, PREFERENCE_NAME_MAX_RETRIES } from '@theia/ai-core/lib/common/ai-core-preferences';
 import { CopilotCommands } from './copilot-command-contribution';
+import { ModelDiscoveryStatusService } from '@theia/ai-core/lib/browser';
+
+const COPILOT_PROVIDER_LABEL = 'GitHub Copilot';
 
 @injectable()
 export class CopilotFrontendApplicationContribution implements FrontendApplicationContribution {
@@ -44,11 +47,19 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
     @inject(CommandService)
     protected readonly commandService: CommandService;
 
+    @inject(ModelDiscoveryStatusService)
+    protected readonly discoveryStatus: ModelDiscoveryStatusService;
+
     protected prevModels: string[] = [];
     protected useAutoDiscovery = false;
 
     onStart(): void {
         this.preferenceService.ready.then(async () => {
+            this.discoveryStatus.registerProvider({
+                providerId: COPILOT_PROVIDER_ID,
+                label: COPILOT_PROVIDER_LABEL,
+                refresh: () => this.initializeModels()
+            });
             // Before anything reaches for the CLI: the backend cannot read the preferences itself.
             await this.updateExecutablePath();
             if (this.isCopilotEnabled()) {
@@ -56,8 +67,9 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
                 if (authState.migrationRequired) {
                     this.notifySignInRequired();
                 }
-                await this.initializeModels();
             }
+            // Also when disabled: that is a state of its own on the provider's page, not the absence of one.
+            await this.initializeModels();
 
             this.preferenceService.onPreferenceChanged(event => {
                 if (event.preferenceName === COPILOT_EXECUTABLE_PATH_PREF) {
@@ -72,6 +84,7 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
                         this.initializeModels();
                     } else {
                         this.removeAllCopilotModels();
+                        this.initializeModels();
                     }
                 } else if (event.preferenceName === COPILOT_ENTERPRISE_URL_PREF) {
                     // The domain is only read at sign-in time, so a change while signed in has no effect
@@ -96,6 +109,7 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
                         await this.discoverAndRegisterModels();
                     } else {
                         this.removeAllCopilotModels();
+                        this.setSignInRequiredStatus();
                     }
                 }
             });
@@ -158,9 +172,41 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
         }
     }
 
+    /** The state of a provider whose credential is a sign-in that has not happened, with the way to fix it. */
+    protected setSignInRequiredStatus(): void {
+        this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, {
+            state: 'no-credentials',
+            // What Copilot lacks is a sign-in, not an API key, so it says so rather than letting the
+            // state speak for it.
+            stateLabel: nls.localizeByDefault('Not signed in'),
+            message: nls.localize('theia/ai/copilot/discovery/signedOut',
+                'Not signed in to GitHub Copilot. Sign in to discover the models it offers.'),
+            action: { label: CopilotCommands.SIGN_IN.label!, commandId: CopilotCommands.SIGN_IN.id }
+        });
+    }
+
     protected async initializeModels(): Promise<void> {
+        if (!this.isCopilotEnabled()) {
+            this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, {
+                state: 'no-credentials',
+                stateLabel: nls.localizeByDefault('Disabled'),
+                message: nls.localize('theia/ai/copilot/discovery/disabled', 'The GitHub Copilot provider is disabled. Enable it to discover models.'),
+                action: undefined
+            });
+            return;
+        }
         const configuredModels = this.preferenceService.get<string[]>(COPILOT_MODEL_OVERRIDES_PREF, []);
         if (configuredModels.length > 0) {
+            this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, {
+                state: 'overridden',
+                stateLabel: undefined,
+                discovered: configuredModels.map(id => ({ id })),
+                message: nls.localize('theia/ai/copilot/discovery/overridden',
+                    'The model list is configured manually. Clear the model overrides to discover the models from GitHub Copilot again.'),
+                lastFetch: undefined,
+                fromCache: false,
+                action: undefined
+            });
             this.useAutoDiscovery = false;
             this.manager.createOrUpdateLanguageModels(
                 ...configuredModels.map((modelId: string) => this.createCopilotModelDescription(modelId))
@@ -173,7 +219,32 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
     }
 
     protected async discoverAndRegisterModels(): Promise<void> {
-        const modelIds = await this.manager.fetchAvailableModelIds();
+        // Runs are queued rather than overlapped: startup, a key change and a manual refresh can all
+        // ask within a moment of each other, and two runs in flight would compute what to unregister
+        // from the same stale list and leave the registry disagreeing with the provider.
+        this.discovering = this.discovering.then(() => this.runDiscovery().catch(error => this.discoveryStatus.reportError(COPILOT_PROVIDER_ID, error)));
+        return this.discovering;
+    }
+
+    protected discovering: Promise<void> = Promise.resolve();
+
+    protected async runDiscovery(): Promise<void> {
+        // Signing in is Copilot's equivalent of setting an API key, so a missing sign-in reads like a
+        // missing credential rather than like a failure: the CLI would answer the list call with an
+        // authorization error, which says the same thing in a way nobody can act on.
+        if (!(await this.authService.getAuthState()).isAuthenticated) {
+            this.setSignInRequiredStatus();
+            return;
+        }
+        this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, { state: 'fetching', stateLabel: undefined, message: undefined, action: undefined });
+        const { models, error } = await this.manager.fetchAvailableModels();
+        if (error) {
+            // The models of an earlier discovery stay registered; the manager already marks them
+            // unavailable, so they are visible as such rather than silently gone.
+            this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, { state: 'error', stateLabel: undefined, message: error, action: undefined });
+            return;
+        }
+        const modelIds = models.map(model => model.id);
         if (modelIds.length > 0) {
             const modelsToRemove = this.prevModels.filter(m => !modelIds.includes(m));
             if (modelsToRemove.length > 0) {
@@ -186,6 +257,15 @@ export class CopilotFrontendApplicationContribution implements FrontendApplicati
             );
             this.prevModels = [...modelIds];
         }
+        this.discoveryStatus.updateStatus(COPILOT_PROVIDER_ID, {
+            state: 'ready',
+            stateLabel: undefined,
+            discovered: models,
+            message: undefined,
+            lastFetch: Date.now(),
+            fromCache: false,
+            action: undefined
+        });
     }
 
     protected removeAllCopilotModels(): void {

package/src/common/copilot-language-models-manager.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { ModelDiscoveryResult } from '@theia/ai-core/lib/common';
 export const COPILOT_LANGUAGE_MODELS_MANAGER_PATH = '/services/copilot/language-model-manager';
 export const CopilotLanguageModelsManager = Symbol('CopilotLanguageModelsManager');
 
@@ -49,8 +50,9 @@ export interface CopilotLanguageModelsManager {
      */
     refreshModelsStatus(): Promise<void>;
     /**
-     * Fetches the list of available model IDs from the Copilot CLI.
-     * Requires the CLI to be signed in. Returns an empty array otherwise or if the call fails.
+     * Fetches the models the Copilot CLI offers. Requires the CLI to be signed in; a failure is
+     * reported as {@link ModelDiscoveryResult.error} with no models rather than thrown, since the
+     * CLI being absent or signed out is an expected state rather than a fault.
      */
-    fetchAvailableModelIds(): Promise<string[]>;
+    fetchAvailableModels(): Promise<ModelDiscoveryResult>;
 }

package/src/node/copilot-language-models-manager-impl.spec.ts

@@ -59,6 +59,10 @@ class TestableCopilotLanguageModelsManagerImpl extends CopilotLanguageModelsMana
     listFailure: Error | undefined;
     modelIds: string[] = ['gpt-5'];
 
+    callVendorOf(id: string): string | undefined {
+        return this.vendorOf(id);
+    }
+
     constructor(readonly registry: FakeRegistry) {
         super();
         Object.assign(this, {
@@ -104,7 +108,9 @@ describe('CopilotLanguageModelsManagerImpl - status', () => {
 
     it('should report models as unavailable when they cannot be listed, rather than as ready', async () => {
         manager.listFailure = new Error('not authorized to use this Copilot feature');
-        expect(await manager.fetchAvailableModelIds()).to.be.empty;
+        const result = await manager.fetchAvailableModels();
+        expect(result.models).to.be.empty;
+        expect(result.error).to.contain('not authorized');
         const status = await manager.callCalculateStatus();
         expect(status.status).to.equal('unavailable');
         expect(status.message).to.contain('not authorized');
@@ -113,7 +119,7 @@ describe('CopilotLanguageModelsManagerImpl - status', () => {
     it('should reflect a failed listing in the models that are already registered', async () => {
         await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
         manager.listFailure = new Error('socket hang up');
-        await manager.fetchAvailableModelIds();
+        await manager.fetchAvailableModels();
         expect(manager.registry.patches.map(patch => patch.id)).to.deep.equal(['copilot/gpt-5']);
         expect(manager.registry.models[0].status).to.deep.include({ status: 'unavailable' });
     });
@@ -121,12 +127,57 @@ describe('CopilotLanguageModelsManagerImpl - status', () => {
     it('should report ready again once the models can be listed', async () => {
         await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
         manager.listFailure = new Error('socket hang up');
-        await manager.fetchAvailableModelIds();
+        await manager.fetchAvailableModels();
         manager.listFailure = undefined;
-        expect(await manager.fetchAvailableModelIds()).to.deep.equal(['gpt-5']);
+        expect((await manager.fetchAvailableModels()).models).to.deep.equal([{ id: 'gpt-5', featured: true }]);
         expect(manager.registry.models[0].status).to.deep.equal({ status: 'ready' });
     });
 
+    it('nominates auto and one model of each major vendor before a second of any', async () => {
+        manager.modelIds = ['auto', 'gpt-5', 'gpt-4.1', 'claude-sonnet-4.5', 'claude-haiku-4', 'gemini-2.5-pro', 'gpt-5-2026-04-17'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        // Five in total: auto, the newest of each vendor, then the next of the first vendor with one left.
+        expect(featured).to.have.members(['auto', 'gpt-5', 'claude-sonnet-4.5', 'gemini-2.5-pro', 'claude-haiku-4']);
+    });
+
+    it('fills the list to five even when the CLI offers no auto', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-4.1', 'claude-sonnet-4.5', 'claude-haiku-4', 'gemini-3-pro', 'gemini-2.5-pro'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.members(['gpt-5', 'claude-sonnet-4.5', 'gemini-3-pro', 'gpt-4.1', 'claude-haiku-4']);
+    });
+
+    it('nominates no more than the five, however much one vendor offers', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-5-mini', 'gpt-4.1', 'gpt-4o', 'o5-preview', 'chatgpt-5-latest'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.lengthOf(5);
+    });
+
+    it('counts the reasoning models as OpenAI, rather than as a vendor of their own', () => {
+        expect(manager.callVendorOf('o5-preview')).to.equal('openai');
+        expect(manager.callVendorOf('gpt-4.1')).to.equal('openai');
+        expect(manager.callVendorOf('claude-sonnet-4.5')).to.equal('anthropic');
+        expect(manager.callVendorOf('grok-code-fast-1')).to.equal(undefined);
+    });
+
+    it('nominates nothing for the vendors beyond the three, which stay selectable but not preselected', async () => {
+        manager.modelIds = ['claude-sonnet-4.5', 'grok-code-fast-1', 'mistral-large', 'llama-4-maverick'];
+        const result = await manager.fetchAvailableModels();
+        expect(result.models.map(model => model.id)).to.have.lengthOf(4);
+        expect(result.models.filter(model => model.featured).map(model => model.id)).to.deep.equal(['claude-sonnet-4.5']);
+    });
+
+    it('recognises a vendor-qualified id, in case the CLI reports them that way', async () => {
+        manager.modelIds = ['google/gemini-2.5-pro', 'anthropic/claude-sonnet-4.5'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.have.members(['google/gemini-2.5-pro', 'anthropic/claude-sonnet-4.5']);
+    });
+
+    it('never nominates a release-pinned id, whose undated form is nominated instead', async () => {
+        manager.modelIds = ['gpt-5', 'gpt-5-2026-04-17'];
+        const featured = (await manager.fetchAvailableModels()).models.filter(model => model.featured).map(model => model.id);
+        expect(featured).to.deep.equal(['gpt-5']);
+    });
+
     it('should update an existing model instead of registering it twice', async () => {
         await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 3 });
         await manager.createOrUpdateLanguageModels({ id: 'copilot/gpt-5', model: 'gpt-5', maxRetries: 5 });

package/src/node/copilot-language-models-manager-impl.ts

@@ -14,10 +14,28 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { LanguageModelRegistry, LanguageModelStatus } from '@theia/ai-core';
+import { DiscoveredModels, LanguageModelRegistry, LanguageModelStatus, ModelDiscoveryResult } from '@theia/ai-core';
 import { DisposableCollection, ILogger, nls } from '@theia/core';
 import { inject, injectable, named, postConstruct, preDestroy } from '@theia/core/shared/inversify';
 import { CopilotLanguageModelsManager, CopilotModelDescription, COPILOT_PROVIDER_ID } from '../common';
+
+/** The id under which Copilot offers its own model selection; always worth showing. */
+const COPILOT_AUTO_MODEL_ID = 'auto';
+
+/** How many models Copilot nominates, matching what the other providers feature. */
+const NOMINATED_MODEL_COUNT = 5;
+
+/**
+ * The vendors one Copilot model each is nominated for, recognised by the prefix of the model id.
+ * Deliberately the three whose models the other providers of this application offer directly: those
+ * are the ones a user coming to the chat input expects to switch between. Copilot carries more, and
+ * they remain registered and selectable — just not preselected.
+ */
+const NOMINATED_VENDORS: ReadonlyArray<{ vendor: string; matches: RegExp }> = [
+    { vendor: 'anthropic', matches: /^claude/i },
+    { vendor: 'openai', matches: /^(gpt|chatgpt|o\d)/i },
+    { vendor: 'google', matches: /^gemini/i }
+];
 import { CopilotSdkLanguageModel } from './copilot-sdk-language-model';
 import { CopilotSdkClientProvider } from './copilot-sdk-client-provider';
 import { CopilotAuthServiceImpl } from './copilot-auth-service-impl';
@@ -130,19 +148,82 @@ export class CopilotLanguageModelsManagerImpl implements CopilotLanguageModelsMa
         }
     }
 
-    async fetchAvailableModelIds(): Promise<string[]> {
+    async fetchAvailableModels(): Promise<ModelDiscoveryResult> {
         try {
             const modelIds = await this.sdkClientProvider.listModelIds();
             this.logger.info(`Copilot: discovered ${modelIds.length} models [${modelIds.join(', ')}]`);
             await this.setDiscoveryFailure(undefined);
-            return modelIds;
+            // The CLI reports nothing but the id: no display name, and no release date to order by.
+            const featured = this.selectFeaturedModelIds(modelIds);
+            return { models: modelIds.map(id => ({ id, featured: featured.has(id) })), fromCache: false };
         } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
             this.logger.warn('Copilot: failed to fetch available models via the Copilot CLI:', error);
-            await this.setDiscoveryFailure(error instanceof Error ? error.message : String(error));
-            return [];
+            await this.setDiscoveryFailure(message);
+            return { models: [], fromCache: false, error: message };
         }
     }
 
+    /**
+     * Nominates the models the chat input should show without the user asking, up to
+     * {@link NOMINATED_MODEL_COUNT}. Copilot serves models of several vendors under one provider, so
+     * ranking them against each other by the numbers in their ids would show several models of
+     * whichever vendor counts highest and none of the others. The list is therefore filled vendor by
+     * vendor: `auto` first, which lets Copilot itself choose and is the entry most users want, then the
+     * newest model of each major vendor, then the next of each in turn until the list is full.
+     *
+     * Everything else Copilot carries is left to be chosen deliberately: the list is meant to be the
+     * handful of models one switches between while chatting, not a survey of the catalogue.
+     *
+     * Release-pinned ids are left out: the undated id of the same model is nominated, and pinning a
+     * release is the deliberate choice the check on its row makes.
+     */
+    protected selectFeaturedModelIds(modelIds: string[]): Set<string> {
+        const featured = new Set<string>();
+        const byVendor = new Map<string, string[]>();
+        for (const id of modelIds) {
+            if (id === COPILOT_AUTO_MODEL_ID) {
+                featured.add(id);
+                continue;
+            }
+            if (DiscoveredModels.undatedId(id) !== undefined) {
+                continue;
+            }
+            const vendor = this.vendorOf(id);
+            if (!vendor) {
+                continue;
+            }
+            byVendor.set(vendor, [...byVendor.get(vendor) ?? [], id]);
+        }
+        // Newest first within each vendor, the vendors themselves in the order they are named.
+        const ranked = NOMINATED_VENDORS.map(({ vendor }) =>
+            [...byVendor.get(vendor) ?? []].sort((left, right) => DiscoveredModels.compareByVersion(left, right)));
+        for (let rank = 0; featured.size < NOMINATED_MODEL_COUNT && ranked.some(ids => ids.length > rank); rank++) {
+            for (const ids of ranked) {
+                if (featured.size >= NOMINATED_MODEL_COUNT) {
+                    break;
+                }
+                if (ids[rank] !== undefined) {
+                    featured.add(ids[rank]);
+                }
+            }
+        }
+        return featured;
+    }
+
+    /**
+     * The vendor a Copilot model id belongs to, or `undefined` for a vendor that is not nominated.
+     * Matching on the id is all there is — the CLI reports nothing else — and it is deliberately narrow:
+     * a model of a vendor this does not name is still registered and still selectable, it is simply not
+     * one of the few the chat input starts with.
+     */
+    protected vendorOf(id: string): string | undefined {
+        // Matched against the last segment, so that an id the CLI qualifies with its vendor
+        // (`google/gemini-2.5-pro`) is recognised as readily as a bare one.
+        const name = id.substring(id.lastIndexOf('/') + 1);
+        return NOMINATED_VENDORS.find(candidate => candidate.matches.test(name))?.vendor;
+    }
+
     /**
      * Records the outcome of the last model discovery and reflects it in the status of the models.
      */

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

@@ -49,9 +49,10 @@ class TestableCopilotSdkLanguageModel extends CopilotSdkLanguageModel {
      * Runs a request against a session that reports itself idle as soon as it was sent to, and
      * reports what the session was configured with, what it was sent, and what was discarded.
      */
-    async captureTurn(request: UserRequest): Promise<{ config: Record<string, unknown>, prompt?: string, deleted?: string }> {
+    async captureTurn(request: UserRequest): Promise<{ config: Record<string, unknown>, prompt?: string, attachments?: unknown[], deleted?: string }> {
         let config: Record<string, unknown> = {};
         let prompt: string | undefined;
+        let attachments: unknown[] | undefined;
         let deleted: string | undefined;
         const listeners = new Map<string, (event: unknown) => void>();
         const session = {
@@ -60,8 +61,9 @@ class TestableCopilotSdkLanguageModel extends CopilotSdkLanguageModel {
                 listeners.set(event, handler);
                 return () => listeners.delete(event);
             },
-            send: async (message: { prompt: string }) => {
+            send: async (message: { prompt: string, attachments?: unknown[] }) => {
                 prompt = message.prompt;
+                attachments = message.attachments;
                 listeners.get('session.idle')?.({});
             },
             abort: async () => { },
@@ -81,7 +83,7 @@ class TestableCopilotSdkLanguageModel extends CopilotSdkLanguageModel {
         for await (const part of response.stream) {
             expect(part).to.exist;
         }
-        return { config, prompt, deleted };
+        return { config, prompt, attachments, deleted };
     }
 }
 
@@ -257,6 +259,18 @@ describe('CopilotSdkLanguageModel - turn', () => {
         const { deleted } = await model.captureTurn(request);
         expect(deleted).to.equal('test-session');
     });
+
+    it('should send a base64 image of the request as a blob attachment', async () => {
+        const requestWithImage = {
+            messages: [
+                { actor: 'user', type: 'text', text: 'what is this?' },
+                { actor: 'user', type: 'image', image: { base64data: 'aGk=', mimeType: 'image/png' } }
+            ]
+        } as unknown as UserRequest;
+        const { prompt, attachments } = await model.captureTurn(requestWithImage);
+        expect(prompt).to.equal('what is this?');
+        expect(attachments).to.deep.equal([{ type: 'blob', data: 'aGk=', mimeType: 'image/png' }]);
+    });
 });
 
 describe('CopilotStreamSink', () => {

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

@@ -24,7 +24,7 @@ import {
     UserRequest
 } from '@theia/ai-core';
 import { CancellationToken, ILogger } from '@theia/core';
-import type { CopilotClient, CopilotSession, PermissionHandler, Tool } from './copilot-sdk-types';
+import type { BlobMessageAttachment, CopilotClient, CopilotSession, PermissionHandler, Tool } from './copilot-sdk-types';
 import { buildSdkPrompt, buildSdkSystemMessage } from './copilot-sdk-mappers';
 
 /**
@@ -155,7 +155,7 @@ export class CopilotSdkLanguageModel implements LanguageModel {
 
     async request(request: UserRequest, cancellationToken?: CancellationToken): Promise<LanguageModelResponse> {
         const client = await this.clientProvider();
-        const { systemText, prompt } = buildSdkPrompt(request.messages);
+        const { systemText, prompt, attachments } = buildSdkPrompt(request.messages);
         const sink = new CopilotStreamSink();
 
         const tools = this.createTools(request.tools ?? [], sink);
@@ -177,7 +177,7 @@ export class CopilotSdkLanguageModel implements LanguageModel {
             onPermissionRequest: approveTheiaTools
         });
 
-        return { stream: this.streamResponse(client, session, prompt, sink, cancellationToken) };
+        return { stream: this.streamResponse(client, session, prompt, attachments, sink, cancellationToken) };
     }
 
     /**
@@ -235,6 +235,7 @@ export class CopilotSdkLanguageModel implements LanguageModel {
         client: CopilotClient,
         session: CopilotSession,
         prompt: string,
+        attachments: BlobMessageAttachment[] | undefined,
         sink: CopilotStreamSink,
         cancellationToken?: CancellationToken
     ): AsyncIterable<LanguageModelStreamResponsePart> {
@@ -292,7 +293,7 @@ export class CopilotSdkLanguageModel implements LanguageModel {
             } else {
                 // Deliberately not awaited: the turn only completes after the tool loop has run, and
                 // its parts have to be yielded while that happens.
-                session.send({ prompt }).catch(error => sink.finish(error));
+                session.send({ prompt, attachments }).catch(error => sink.finish(error));
             }
             yield* sink.drain();
             if (inputTokens !== undefined || outputTokens !== undefined) {

package/src/node/copilot-sdk-mappers.spec.ts

@@ -44,14 +44,16 @@ describe('copilot-sdk-mappers - selectSdkModelIds', () => {
         expect(result).to.deep.equal(['a', 'b']);
     });
 
-    it('drops a dated release when its family is offered as well', () => {
+    it('keeps a dated release alongside its family, so a release can be pinned', () => {
         const result = selectSdkModelIds([
             model('gpt-5'),
             model('gpt-5-2026-04-17'),
             model('claude-sonnet-5'),
             model('claude-sonnet-5-20260514')
         ]);
-        expect(result).to.deep.equal(['gpt-5', 'claude-sonnet-5']);
+        // Which of them the model pickers offer is decided by the favorite models service, which
+        // features the families; the releases stay selectable for whoever wants one.
+        expect(result).to.deep.equal(['gpt-5', 'gpt-5-2026-04-17', 'claude-sonnet-5', 'claude-sonnet-5-20260514']);
     });
 
     it('keeps a dated release that is the only way to select that model', () => {
@@ -120,6 +122,43 @@ describe('copilot-sdk-mappers - buildSdkPrompt', () => {
             'User: run it\n\nAssistant: [tool call: foo {"x":1}]\n\nUser: [tool result: done]'
         );
     });
+
+    it('turns a base64 user image into a blob attachment and drops it from the prompt text', () => {
+        const messages: LanguageModelMessage[] = [
+            { actor: 'user', type: 'text', text: 'what is this?' },
+            { actor: 'user', type: 'image', image: { base64data: 'aGk=', mimeType: 'image/png' } }
+        ];
+        const result = buildSdkPrompt(messages);
+        expect(result.prompt).to.equal('what is this?');
+        expect(result.attachments).to.deep.equal([{ type: 'blob', data: 'aGk=', mimeType: 'image/png' }]);
+    });
+
+    it('collects multiple base64 images in message order', () => {
+        const messages: LanguageModelMessage[] = [
+            { actor: 'user', type: 'image', image: { base64data: 'AAA=', mimeType: 'image/png' } },
+            { actor: 'user', type: 'image', image: { base64data: 'BBB=', mimeType: 'image/jpeg' } }
+        ];
+        const result = buildSdkPrompt(messages);
+        expect(result.attachments).to.deep.equal([
+            { type: 'blob', data: 'AAA=', mimeType: 'image/png' },
+            { type: 'blob', data: 'BBB=', mimeType: 'image/jpeg' }
+        ]);
+    });
+
+    it('leaves attachments undefined when there are no images', () => {
+        const result = buildSdkPrompt([{ actor: 'user', type: 'text', text: 'hi' }]);
+        expect(result.attachments).to.be.undefined;
+    });
+
+    it('does not attach a URL image and renders it as an omitted placeholder instead', () => {
+        const messages: LanguageModelMessage[] = [
+            { actor: 'user', type: 'text', text: 'look' },
+            { actor: 'user', type: 'image', image: { url: 'https://example.com/a.png' } }
+        ];
+        const result = buildSdkPrompt(messages);
+        expect(result.attachments).to.be.undefined;
+        expect(result.prompt).to.equal('User: look\n\nUser: [image omitted]');
+    });
 });
 
 describe('copilot-sdk-mappers - buildSdkSystemMessage', () => {