@theia/ai-chat 1.60.2 → 1.61.0

package/src/browser/change-set-file-resource.ts

@@ -14,147 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { MutableResource, Reference, ReferenceMutableResource, Resource, ResourceResolver, URI } from '@theia/core';
-import { injectable } from '@theia/core/shared/inversify';
+import { URI } from '@theia/core';
 
 export const CHANGE_SET_FILE_RESOURCE_SCHEME = 'changeset-file';
-export type ResourceInitializationOptions = Pick<Resource, 'autosaveable' | 'initiallyDirty' | 'readOnly'> & { contents?: string, onSave?: Resource['saveContents'] };
-export type ResourceUpdateOptions = Pick<ResourceInitializationOptions, 'contents' | 'onSave'>;
 
 export function createChangeSetFileUri(chatSessionId: string, elementUri: URI): URI {
     return elementUri.withScheme(CHANGE_SET_FILE_RESOURCE_SCHEME).withAuthority(chatSessionId);
 }
-
-export class UpdatableReferenceResource extends ReferenceMutableResource {
-    static acquire(resource: UpdatableReferenceResource): UpdatableReferenceResource {
-        DisposableRefCounter.acquire(resource.reference);
-        return resource;
-    }
-
-    constructor(protected override reference: DisposableRefCounter<DisposableMutableResource>) {
-        super(reference);
-    }
-
-    update(options: ResourceUpdateOptions): void {
-        this.reference.object.update(options);
-    }
-
-    get readOnly(): Resource['readOnly'] {
-        return this.reference.object.readOnly;
-    }
-
-    get initiallyDirty(): boolean {
-        return this.reference.object.initiallyDirty;
-    }
-
-    get autosaveable(): boolean {
-        return this.reference.object.autosaveable;
-    }
-}
-
-export class DisposableMutableResource extends MutableResource {
-    onSave: Resource['saveContents'] | undefined;
-    constructor(uri: URI, protected readonly options?: ResourceInitializationOptions) {
-        super(uri);
-        this.onSave = options?.onSave;
-        this.contents = options?.contents ?? '';
-    }
-
-    get readOnly(): Resource['readOnly'] {
-        return this.options?.readOnly || !this.onSave;
-    }
-
-    get autosaveable(): boolean {
-        return this.options?.autosaveable !== false;
-    }
-
-    get initiallyDirty(): boolean {
-        return !!this.options?.initiallyDirty;
-    }
-
-    override async saveContents(contents: string): Promise<void> {
-        if (this.options?.onSave) {
-            await this.options.onSave(contents);
-            this.update({ contents });
-        }
-    }
-
-    update(options: ResourceUpdateOptions): void {
-        if (options.contents !== undefined && options.contents !== this.contents) {
-            this.contents = options.contents;
-            this.fireDidChangeContents();
-        }
-        if ('onSave' in options && options.onSave !== this.onSave) {
-            this.onSave = options.onSave;
-        }
-    }
-
-    override dispose(): void {
-        this.onDidChangeContentsEmitter.dispose();
-    }
-}
-
-export class DisposableRefCounter<V = unknown> implements Reference<V> {
-    static acquire<V>(item: DisposableRefCounter<V>): DisposableRefCounter<V> {
-        item.refs++;
-        return item;
-    }
-    static create<V>(value: V, onDispose: () => void): DisposableRefCounter<V> {
-        return this.acquire(new this(value, onDispose));
-    }
-    readonly object: V;
-    protected refs = 0;
-    protected constructor(value: V, protected readonly onDispose: () => void) {
-        this.object = value;
-    }
-    dispose(): void {
-        this.refs--;
-        if (this.refs === 0) {
-            this.onDispose();
-        }
-    }
-}
-
-@injectable()
-export class ChangeSetFileResourceResolver implements ResourceResolver {
-    protected readonly cache = new Map<string, UpdatableReferenceResource>();
-
-    add(uri: URI, options?: ResourceInitializationOptions): UpdatableReferenceResource {
-        const key = uri.toString();
-        if (this.cache.has(key)) {
-            throw new Error(`Resource ${key} already exists.`);
-        }
-        const underlyingResource = new DisposableMutableResource(uri, options);
-        const ref = DisposableRefCounter.create(underlyingResource, () => {
-            underlyingResource.dispose();
-            this.cache.delete(key);
-        });
-        const refResource = new UpdatableReferenceResource(ref);
-        this.cache.set(key, refResource);
-        return refResource;
-    }
-
-    tryGet(uri: URI): UpdatableReferenceResource | undefined {
-        try {
-            return this.resolve(uri);
-        } catch {
-            return undefined;
-        }
-    }
-
-    update(uri: URI, contents: string): void {
-        const key = uri.toString();
-        const resource = this.cache.get(key);
-        if (!resource) {
-            throw new Error(`No resource for ${key}.`);
-        }
-        resource.update({ contents });
-    }
-
-    resolve(uri: URI): UpdatableReferenceResource {
-        const key = uri.toString();
-        const ref = this.cache.get(key);
-        if (!ref) { throw new Error(`No resource for ${key}.`); }
-        return UpdatableReferenceResource.acquire(ref);
-    }
-}

package/src/browser/change-set-variable.ts

@@ -18,13 +18,13 @@ import { MaybePromise, nls } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { AIVariable, ResolvedAIVariable, AIVariableContribution, AIVariableResolver, AIVariableService, AIVariableResolutionRequest, AIVariableContext } from '@theia/ai-core';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
-import { ChatSessionContext } from '../common';
+import { CHANGE_SET_SUMMARY_VARIABLE_ID, ChatSessionContext } from '../common';
 
 export const CHANGE_SET_SUMMARY_VARIABLE: AIVariable = {
-    id: 'changeSetSummary',
+    id: CHANGE_SET_SUMMARY_VARIABLE_ID,
     description: nls.localize('theia/ai/core/changeSetSummaryVariable/description', 'Provides a summary of the files in a change set and their contents.'),
 
-    name: 'changeSetSummary',
+    name: CHANGE_SET_SUMMARY_VARIABLE_ID,
 };
 
 @injectable()
@@ -41,14 +41,22 @@ export class ChangeSetVariableContribution implements AIVariableContribution, AI
     }
 
     async resolve(request: AIVariableResolutionRequest, context: AIVariableContext): Promise<ResolvedAIVariable | undefined> {
-        if (!ChatSessionContext.is(context) || request.variable.name !== CHANGE_SET_SUMMARY_VARIABLE.name || !context.model.changeSet?.getElements().length) { return undefined; }
+        if (!ChatSessionContext.is(context) || request.variable.name !== CHANGE_SET_SUMMARY_VARIABLE.name) { return undefined; }
+        if (!context.model.changeSet?.getElements().length) {
+            return {
+                variable: CHANGE_SET_SUMMARY_VARIABLE,
+                value: ''
+            };
+        }
         const entries = await Promise.all(
             context.model.changeSet.getElements().map(async element => `- file: ${await this.workspaceService.getWorkspaceRelativePath(element.uri)}, status: ${element.state}`)
         );
         return {
             variable: CHANGE_SET_SUMMARY_VARIABLE,
-            value: entries.join('\n')
+            value: `## Previously Proposed Changes
+You have previously proposed changes for the following files. Some suggestions may have been accepted by the user, while others may still be pending.
+${entries.join('\n')}
+`
         };
     }
 }
-

package/src/browser/context-file-variable-label-provider.ts

@@ -49,7 +49,7 @@ export class ContextFileVariableLabelProvider implements LabelProviderContributi
     }
 
     getDetails(element: object): string | undefined {
-        return this.changeSetFileService.getAdditionalInfo(this.getUri(element)!);
+        return this.labelProvider.getDetails(this.getUri(element)!);
     }
 
     protected getUri(element: object): URI | undefined {

package/src/browser/file-chat-variable-contribution.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { AIVariableContext, AIVariableResolutionRequest, PromptText } from '@theia/ai-core';
-import { AIVariableDropResult, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
+import { AIVariableCompletionContext, AIVariableDropResult, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
 import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
 import { CancellationToken, QuickInputService, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
@@ -23,6 +23,7 @@ import * as monaco from '@theia/monaco-editor-core';
 import { FileQuickPickItem, QuickFileSelectService } from '@theia/file-search/lib/browser/quick-file-select-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { VARIABLE_ADD_CONTEXT_COMMAND } from './ai-chat-frontend-contribution';
 
 @injectable()
 export class FileChatVariableContribution implements FrontendVariableContribution {
@@ -72,40 +73,36 @@ export class FileChatVariableContribution implements FrontendVariableContributio
         position: monaco.Position,
         matchString?: string
     ): Promise<monaco.languages.CompletionItem[] | undefined> {
-        const lineContent = model.getLineContent(position.lineNumber);
-        const indexOfVariableTrigger = lineContent.lastIndexOf(matchString ?? PromptText.VARIABLE_CHAR, position.column - 1);
+        const context = AIVariableCompletionContext.get(FILE_VARIABLE.name, model, position, matchString);
+        if (!context) { return undefined; }
+        const { userInput, range, prefix } = context;
 
-        // check if there is a variable trigger and no space typed between the variable trigger and the cursor
-        if (indexOfVariableTrigger === -1 || lineContent.substring(indexOfVariableTrigger).includes(' ')) {
-            return undefined;
-        }
-
-        // determine whether we are providing completions before or after the variable argument separator
-        const indexOfVariableArgSeparator = lineContent.lastIndexOf(PromptText.VARIABLE_SEPARATOR_CHAR, position.column - 1);
-        const triggerCharIndex = Math.max(indexOfVariableTrigger, indexOfVariableArgSeparator);
-
-        const typedWord = lineContent.substring(triggerCharIndex + 1, position.column - 1);
-        const range = new monaco.Range(position.lineNumber, triggerCharIndex + 2, position.lineNumber, position.column);
-        const picks = await this.quickFileSelectService.getPicks(typedWord, CancellationToken.None);
-        const matchVariableChar = lineContent[triggerCharIndex] === (matchString ? matchString : PromptText.VARIABLE_CHAR);
-        const prefix = matchVariableChar ? FILE_VARIABLE.name + PromptText.VARIABLE_SEPARATOR_CHAR : '';
+        const picks = await this.quickFileSelectService.getPicks(userInput, CancellationToken.None);
 
         return Promise.all(
             picks
                 .filter(FileQuickPickItem.is)
                 // only show files with highlights, if the user started typing to filter down the results
-                .filter(p => !typedWord || p.highlights?.label)
-                .map(async (pick, index) => ({
-                    label: pick.label,
-                    kind: monaco.languages.CompletionItemKind.File,
-                    range,
-                    insertText: `${prefix}${await this.wsService.getWorkspaceRelativePath(pick.uri)}`,
-                    detail: await this.wsService.getWorkspaceRelativePath(pick.uri.parent),
-                    // don't let monaco filter the items, as we only return picks that are filtered
-                    filterText: typedWord,
-                    // keep the order of the items, but move them to the end of the list
-                    sortText: `ZZ${index.toString().padStart(4, '0')}_${pick.label}`,
-                }))
+                .filter(p => !userInput || p.highlights?.label)
+                .map(async (pick, index) => {
+                    const relativePath = await this.wsService.getWorkspaceRelativePath(pick.uri);
+                    return {
+                        label: pick.label,
+                        kind: monaco.languages.CompletionItemKind.File,
+                        range,
+                        insertText: `${prefix}${relativePath}`,
+                        detail: await this.wsService.getWorkspaceRelativePath(pick.uri.parent),
+                        // don't let monaco filter the items, as we only return picks that are filtered
+                        filterText: userInput,
+                        // keep the order of the items, but move them to the end of the list
+                        sortText: `ZZ${index.toString().padStart(4, '0')}_${pick.label}`,
+                        command: {
+                            title: VARIABLE_ADD_CONTEXT_COMMAND.label!,
+                            id: VARIABLE_ADD_CONTEXT_COMMAND.id,
+                            arguments: [FILE_VARIABLE.name, relativePath]
+                        }
+                    };
+                })
         );
     }
 

package/src/browser/task-context-service.ts

@@ -0,0 +1,144 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { MaybePromise, ProgressService, URI, generateUuid, Event } from '@theia/core';
+import { ChatAgent, ChatAgentLocation, ChatService, ChatSession, MutableChatModel, MutableChatRequestModel, ParsedChatRequestTextPart } from '../common';
+import { ChatSessionSummaryAgent } from '../common/chat-session-summary-agent';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { AgentService, PromptService } from '@theia/ai-core';
+import { CHAT_SESSION_SUMMARY_PROMPT } from '../common/chat-session-summary-agent-prompt';
+
+export interface SummaryMetadata {
+    label: string;
+    uri?: URI;
+    sessionId?: string;
+}
+
+export interface Summary extends SummaryMetadata {
+    summary: string;
+    id: string;
+}
+
+export const TaskContextStorageService = Symbol('TextContextStorageService');
+export interface TaskContextStorageService {
+    onDidChange: Event<void>;
+    store(summary: Summary): MaybePromise<void>;
+    getAll(): Summary[];
+    get(identifier: string): Summary | undefined;
+    delete(identifier: string): MaybePromise<boolean>;
+    open(identifier: string): Promise<void>;
+}
+
+@injectable()
+export class TaskContextService {
+
+    protected pendingSummaries = new Map<string, Promise<Summary>>();
+
+    @inject(ChatService) protected readonly chatService: ChatService;
+    @inject(AgentService) protected readonly agentService: AgentService;
+    @inject(PromptService) protected readonly promptService: PromptService;
+    @inject(TaskContextStorageService) protected readonly storageService: TaskContextStorageService;
+    @inject(ProgressService) protected readonly progressService: ProgressService;
+
+    get onDidChange(): Event<void> {
+        return this.storageService.onDidChange;
+    }
+
+    getAll(): Array<Summary> {
+        return this.storageService.getAll();
+    }
+
+    async getSummary(sessionIdOrFilePath: string): Promise<string> {
+        const existing = this.storageService.get(sessionIdOrFilePath);
+        if (existing) { return existing.summary; }
+        const pending = this.pendingSummaries.get(sessionIdOrFilePath);
+        if (pending) {
+            return pending.then(({ summary }) => summary);
+        }
+        const session = this.chatService.getSession(sessionIdOrFilePath);
+        if (session) {
+            return this.summarize(session);
+        }
+        throw new Error('Unable to resolve summary request.');
+    }
+
+    /** Returns an ID that can be used to refer to the summary in the future. */
+    async summarize(session: ChatSession, promptId?: string, agent?: ChatAgent): Promise<string> {
+        const pending = this.pendingSummaries.get(session.id);
+        if (pending) { return pending.then(({ id }) => id); }
+        const existing = this.getSummaryForSession(session);
+        if (existing) { return existing.id; }
+        const summaryId = generateUuid();
+        const summaryDeferred = new Deferred<Summary>();
+        const progress = await this.progressService.showProgress({ text: `Summarize: ${session.title || session.id}`, options: { location: 'ai-chat' } });
+        this.pendingSummaries.set(session.id, summaryDeferred.promise);
+        try {
+            const newSummary: Summary = {
+                summary: await this.getLlmSummary(session, promptId, agent),
+                label: session.title || session.id,
+                sessionId: session.id,
+                id: summaryId
+            };
+            await this.storageService.store(newSummary);
+            return summaryId;
+        } catch (err) {
+            summaryDeferred.reject(err);
+            throw err;
+        } finally {
+            progress.cancel();
+            this.pendingSummaries.delete(session.id);
+        }
+    }
+
+    protected async getLlmSummary(session: ChatSession, promptId: string = CHAT_SESSION_SUMMARY_PROMPT.id, agent?: ChatAgent): Promise<string> {
+        agent = agent || this.agentService.getAgents().find<ChatAgent>((candidate): candidate is ChatAgent =>
+            'invoke' in candidate
+            && typeof candidate.invoke === 'function'
+            && candidate.id === ChatSessionSummaryAgent.ID
+        );
+        if (!agent) { throw new Error('Unable to identify agent for summary.'); }
+        const model = new MutableChatModel(ChatAgentLocation.Panel);
+        const prompt = await this.promptService.getPrompt(promptId || CHAT_SESSION_SUMMARY_PROMPT.id, undefined, { model: session.model });
+        if (!prompt) { return ''; }
+        const messages = session.model.getRequests().filter((candidate): candidate is MutableChatRequestModel => candidate instanceof MutableChatRequestModel);
+        messages.forEach(message => model['_hierarchy'].append(message));
+        const summaryRequest = model.addRequest({
+            variables: prompt.variables ?? [],
+            request: { text: prompt.text },
+            parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: prompt.text.length }, prompt.text)],
+            toolRequests: prompt.functionDescriptions ?? new Map()
+        }, agent.id);
+        await agent.invoke(summaryRequest);
+        return summaryRequest.response.response.asDisplayString();
+    }
+
+    hasSummary(chatSession: ChatSession): boolean {
+        return !!this.getSummaryForSession(chatSession);
+    }
+
+    protected getSummaryForSession(chatSession: ChatSession): Summary | undefined {
+        return this.storageService.getAll().find(candidate => candidate.sessionId === chatSession.id);
+    }
+
+    getLabel(id: string): string | undefined {
+        return this.storageService.get(id)?.label;
+    }
+
+    open(id: string): Promise<void> {
+        return this.storageService.open(id);
+    }
+}

package/src/browser/task-context-storage-service.ts

@@ -0,0 +1,75 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { Summary, TaskContextStorageService } from './task-context-service';
+import { Emitter } from '@theia/core';
+import { AIVariableResourceResolver } from '@theia/ai-core';
+import { TASK_CONTEXT_VARIABLE } from './task-context-variable';
+import { open, OpenerService } from '@theia/core/lib/browser';
+
+@injectable()
+export class InMemoryTaskContextStorage implements TaskContextStorageService {
+    protected summaries = new Map<string, Summary>();
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange = this.onDidChangeEmitter.event;
+
+    @inject(AIVariableResourceResolver)
+    protected readonly variableResourceResolver: AIVariableResourceResolver;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    store(summary: Summary): void {
+        this.summaries.set(summary.id, summary);
+        this.onDidChangeEmitter.fire();
+    }
+
+    getAll(): Summary[] {
+        return Array.from(this.summaries.values());
+    }
+
+    get(identifier: string): Summary | undefined {
+        return this.summaries.get(identifier);
+    }
+
+    delete(identifier: string): boolean {
+        const didDelete = this.summaries.delete(identifier);
+        if (didDelete) {
+            this.onDidChangeEmitter.fire();
+        }
+        return didDelete;
+    }
+
+    clear(): void {
+        if (this.summaries.size) {
+            this.summaries.clear();
+            this.onDidChangeEmitter.fire();
+        }
+    }
+
+    async open(identifier: string): Promise<void> {
+        const summary = this.get(identifier);
+        if (!summary) {
+            throw new Error('Unable to upon requested task context: none found.');
+        }
+        const resource = this.variableResourceResolver.getOrCreate({ variable: TASK_CONTEXT_VARIABLE, arg: identifier }, {}, summary.summary);
+        resource.update({ onSave: async content => { summary.summary = content; }, readOnly: false });
+        await open(this.openerService, resource.uri);
+        resource.dispose();
+    }
+}

package/src/browser/task-context-variable-contribution.ts

@@ -0,0 +1,93 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { AIVariableContext, AIVariableOpener, AIVariableResolutionRequest, AIVariableResolver, ResolvedAIContextVariable } from '@theia/ai-core';
+import { AIVariableCompletionContext, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
+import { MaybePromise, QuickInputService, QuickPickItem } from '@theia/core';
+import { ChatService } from '../common';
+import * as monaco from '@theia/monaco-editor-core';
+import { TaskContextService } from './task-context-service';
+import { TASK_CONTEXT_VARIABLE } from './task-context-variable';
+import { VARIABLE_ADD_CONTEXT_COMMAND } from './ai-chat-frontend-contribution';
+
+@injectable()
+export class TaskContextVariableContribution implements FrontendVariableContribution, AIVariableResolver, AIVariableOpener {
+    @inject(QuickInputService) protected readonly quickInputService: QuickInputService;
+    @inject(ChatService) protected readonly chatService: ChatService;
+    @inject(TaskContextService) protected readonly taskContextService: TaskContextService;
+
+    registerVariables(service: FrontendVariableService): void {
+        service.registerResolver(TASK_CONTEXT_VARIABLE, this);
+        service.registerArgumentPicker(TASK_CONTEXT_VARIABLE, this.pickSession.bind(this));
+        service.registerArgumentCompletionProvider(TASK_CONTEXT_VARIABLE, this.provideCompletionItems.bind(this));
+        service.registerOpener(TASK_CONTEXT_VARIABLE, this);
+    }
+
+    protected async pickSession(): Promise<string | undefined> {
+        const items = this.getItems();
+        const selection = await this.quickInputService.showQuickPick(items);
+        return selection?.id;
+    }
+
+    protected async provideCompletionItems(
+        model: monaco.editor.ITextModel,
+        position: monaco.Position,
+        matchString?: string
+    ): Promise<monaco.languages.CompletionItem[] | undefined> {
+        const context = AIVariableCompletionContext.get(TASK_CONTEXT_VARIABLE.name, model, position, matchString);
+        if (!context) { return undefined; }
+        const { userInput, range, prefix } = context;
+        return this.getItems().filter(candidate => QuickPickItem.is(candidate) && candidate.label.startsWith(userInput)).map(({ label, id }: QuickPickItem) => ({
+            label,
+            kind: monaco.languages.CompletionItemKind.Class,
+            range,
+            insertText: `${prefix}${id}`,
+            detail: id,
+            filterText: userInput,
+            command: {
+                title: VARIABLE_ADD_CONTEXT_COMMAND.label!,
+                id: VARIABLE_ADD_CONTEXT_COMMAND.id,
+                arguments: [TASK_CONTEXT_VARIABLE.name, id]
+            }
+        }));
+    }
+
+    protected getItems(): QuickPickItem[] {
+        const currentSession = this.chatService.getSessions().find(candidate => candidate.isActive);
+        const existingSummaries = this.taskContextService.getAll().filter(candidate => !currentSession || currentSession.id !== candidate.sessionId);
+        return existingSummaries;
+    }
+
+    canResolve(request: AIVariableResolutionRequest, context: AIVariableContext): MaybePromise<number> {
+        return request.variable.id === TASK_CONTEXT_VARIABLE.id ? 10000 : -5;
+    }
+
+    async resolve(request: AIVariableResolutionRequest, _context: AIVariableContext): Promise<ResolvedAIContextVariable | undefined> {
+        if (request.variable.id !== TASK_CONTEXT_VARIABLE.id || !request.arg) { return; }
+        const value = await this.taskContextService.getSummary(request.arg).catch(() => undefined);
+        return value ? { ...request, value, contextValue: value } : undefined;
+    }
+
+    canOpen(request: AIVariableResolutionRequest, context: AIVariableContext): MaybePromise<number> {
+        return this.canResolve(request, context);
+    }
+
+    async open(request: AIVariableResolutionRequest, _context: AIVariableContext): Promise<void> {
+        if (request.variable.id !== TASK_CONTEXT_VARIABLE.id || !request.arg) { throw new Error('Unable to service open request.'); }
+        return this.taskContextService.open(request.arg);
+    }
+}

package/src/browser/task-context-variable-label-provider.ts

@@ -0,0 +1,67 @@
+// *****************************************************************************
+// Copyright (C) 2025 Eclipse 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 { AIVariableResolutionRequest } from '@theia/ai-core';
+import { URI } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { codicon, LabelProviderContribution } from '@theia/core/lib/browser';
+import { TaskContextVariableContribution } from './task-context-variable-contribution';
+import { ChatService } from '../common';
+import { TaskContextService } from './task-context-service';
+import { TASK_CONTEXT_VARIABLE } from './task-context-variable';
+
+@injectable()
+export class TaskContextVariableLabelProvider implements LabelProviderContribution {
+    @inject(ChatService) protected readonly chatService: ChatService;
+    @inject(TaskContextVariableContribution) protected readonly chatVariableContribution: TaskContextVariableContribution;
+    @inject(TaskContextService) protected readonly taskContextService: TaskContextService;
+    protected isMine(element: object): element is AIVariableResolutionRequest & { arg: string } {
+        return AIVariableResolutionRequest.is(element) && element.variable.id === TASK_CONTEXT_VARIABLE.id && !!element.arg;
+    }
+
+    canHandle(element: object): number {
+        return this.isMine(element) ? 10 : -1;
+    }
+
+    getIcon(element: object): string | undefined {
+        if (!this.isMine(element)) { return undefined; }
+        return codicon('clippy');
+    }
+
+    getName(element: object): string | undefined {
+        if (!this.isMine(element)) { return undefined; }
+        const session = this.chatService.getSession(element.arg);
+        return session?.title ?? this.taskContextService.getLabel(element.arg) ?? session?.id ?? element.arg;
+    }
+
+    getLongName(element: object): string | undefined {
+        const short = this.getName(element);
+        const details = this.getDetails(element);
+        return `'${short}' (${details})`;
+    }
+
+    getDetails(element: object): string | undefined {
+        if (!this.isMine(element)) { return undefined; }
+        return `id: ${element.arg}`;
+    }
+
+    protected getUri(element: object): URI | undefined {
+        if (!AIVariableResolutionRequest.is(element)) {
+            return undefined;
+        }
+        return new URI(element.arg);
+    }
+}