@theia/ai-chat 1.61.0-next.8 → 1.61.0

package/src/browser/change-set-decorator-service.ts

@@ -0,0 +1,72 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { ContributionProvider, Emitter, type Event } from '@theia/core';
+import { type FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import debounce = require('@theia/core/shared/lodash.debounce');
+import type { ChangeSetDecoration, ChangeSetElement } from '../common';
+
+/**
+ * A decorator for a change set element.
+ * It allows to add additional information to the element, such as icons.
+ */
+export const ChangeSetDecorator = Symbol('ChangeSetDecorator');
+export interface ChangeSetDecorator {
+    readonly id: string;
+
+    readonly onDidChangeDecorations: Event<void>;
+
+    decorate(element: ChangeSetElement): ChangeSetDecoration | undefined;
+}
+
+@injectable()
+export class ChangeSetDecoratorService implements FrontendApplicationContribution {
+
+    protected readonly onDidChangeDecorationsEmitter = new Emitter<void>();
+    readonly onDidChangeDecorations = this.onDidChangeDecorationsEmitter.event;
+
+    @inject(ContributionProvider) @named(ChangeSetDecorator)
+    protected readonly contributions: ContributionProvider<ChangeSetDecorator>;
+
+    initialize(): void {
+        this.contributions.getContributions().map(decorator => decorator.onDidChangeDecorations(this.fireDidChangeDecorations));
+    }
+
+    protected readonly fireDidChangeDecorations = debounce(() => {
+        this.onDidChangeDecorationsEmitter.fire(undefined);
+    }, 150);
+
+    getDecorations(element: ChangeSetElement): ChangeSetDecoration[] {
+        const decorators = this.contributions.getContributions();
+        const decorations: ChangeSetDecoration[] = [];
+        for (const decorator of decorators) {
+            const decoration = decorator.decorate(element);
+            if (decoration) {
+                decorations.push(decoration);
+            }
+        }
+
+        decorations.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+
+        return decorations;
+    }
+
+    getAdditionalInfoSuffixIcon(element: ChangeSetElement): string[] | undefined {
+        const decorations = this.getDecorations(element);
+        return decorations.find(d => d.additionalInfoSuffixIcon)?.additionalInfoSuffixIcon;
+    }
+}

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

@@ -17,11 +17,13 @@
 import { DisposableCollection, Emitter, URI } from '@theia/core';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { Replacement } from '@theia/core/lib/common/content-replacer';
+import { ConfigurableInMemoryResources, ConfigurableMutableReferenceResource } from '@theia/ai-core';
 import { ChangeSetElement, ChangeSetImpl } from '../common';
-import { ChangeSetFileResourceResolver, createChangeSetFileUri, UpdatableReferenceResource } from './change-set-file-resource';
+import { createChangeSetFileUri } from './change-set-file-resource';
 import { ChangeSetFileService } from './change-set-file-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { ConfirmDialog } from '@theia/core/lib/browser';
+import { ChangeSetDecoratorService } from './change-set-decorator-service';
 
 export const ChangeSetFileElementFactory = Symbol('ChangeSetFileElementFactory');
 export type ChangeSetFileElementFactory = (elementProps: ChangeSetElementArgs) => ChangeSetFileElement;
@@ -60,11 +62,14 @@ export class ChangeSetFileElement implements ChangeSetElement {
     @inject(ChangeSetFileService)
     protected readonly changeSetFileService: ChangeSetFileService;
 
+    @inject(ChangeSetDecoratorService)
+    protected readonly changeSetDecoratorService: ChangeSetDecoratorService;
+
     @inject(FileService)
     protected readonly fileService: FileService;
 
-    @inject(ChangeSetFileResourceResolver)
-    protected readonly resourceResolver: ChangeSetFileResourceResolver;
+    @inject(ConfigurableInMemoryResources)
+    protected readonly inMemoryResources: ConfigurableInMemoryResources;
 
     protected readonly toDispose = new DisposableCollection();
     protected _state: ChangeSetElementState;
@@ -73,8 +78,8 @@ export class ChangeSetFileElement implements ChangeSetElement {
 
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
-    protected readOnlyResource: UpdatableReferenceResource;
-    protected changeResource: UpdatableReferenceResource;
+    protected readOnlyResource: ConfigurableMutableReferenceResource;
+    protected changeResource: ConfigurableMutableReferenceResource;
 
     @postConstruct()
     init(): void {
@@ -93,17 +98,17 @@ export class ChangeSetFileElement implements ChangeSetElement {
     }
 
     protected getResources(): void {
-        this.readOnlyResource = this.resourceResolver.tryGet(this.readOnlyUri) ?? this.resourceResolver.add(this.readOnlyUri, { autosaveable: false, readOnly: true });
-        let changed = this.resourceResolver.tryGet(this.changedUri);
-        if (changed) {
-            changed.update({ contents: this.targetState, onSave: content => this.writeChanges(content) });
-        } else {
-            changed = this.resourceResolver.add(this.changedUri, { contents: this.targetState, onSave: content => this.writeChanges(content), autosaveable: false });
-        }
-        this.changeResource = changed;
+        this.readOnlyResource = this.getInMemoryUri(this.readOnlyUri);
+        this.readOnlyResource.update({ autosaveable: false, readOnly: true });
+        this.changeResource = this.getInMemoryUri(this.changedUri);
+        this.changeResource.update({ contents: this.targetState, onSave: content => this.writeChanges(content), autosaveable: false });
         this.toDispose.pushAll([this.readOnlyResource, this.changeResource]);
     }
 
+    protected getInMemoryUri(uri: URI): ConfigurableMutableReferenceResource {
+        try { return this.inMemoryResources.resolve(uri); } catch { return this.inMemoryResources.add(uri, { contents: '' }); }
+    }
+
     protected listenForOriginalFileChanges(): void {
         this.toDispose.push(this.fileService.onDidFilesChange(async event => {
             if (!event.contains(this.uri)) { return; }

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();
+    }
+}