@theia/ai-chat 1.63.0-next.0 → 1.63.0-next.52

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

@@ -15,12 +15,15 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { MaybePromise, ProgressService, URI, generateUuid, Event } from '@theia/core';
+import { MaybePromise, ProgressService, URI, generateUuid, Event, EOL } from '@theia/core';
 import { ChatAgent, ChatAgentLocation, ChatService, ChatSession, MutableChatModel, MutableChatRequestModel, ParsedChatRequestTextPart } from '../common';
+import { PreferenceService } from '@theia/core/lib/browser';
 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 { AgentService, PromptService, ResolvedPromptFragment } from '@theia/ai-core';
 import { CHAT_SESSION_SUMMARY_PROMPT } from '../common/chat-session-summary-agent-prompt';
+import { ChangeSetFileElementFactory } from './change-set-file-element';
+import * as yaml from 'js-yaml';
 
 export interface SummaryMetadata {
     label: string;
@@ -33,7 +36,7 @@ export interface Summary extends SummaryMetadata {
     id: string;
 }
 
-export const TaskContextStorageService = Symbol('TextContextStorageService');
+export const TaskContextStorageService = Symbol('TaskContextStorageService');
 export interface TaskContextStorageService {
     onDidChange: Event<void>;
     store(summary: Summary): MaybePromise<void>;
@@ -53,6 +56,9 @@ export class TaskContextService {
     @inject(PromptService) protected readonly promptService: PromptService;
     @inject(TaskContextStorageService) protected readonly storageService: TaskContextStorageService;
     @inject(ProgressService) protected readonly progressService: ProgressService;
+    @inject(PreferenceService) protected readonly preferenceService: PreferenceService;
+    @inject(ChangeSetFileElementFactory)
+    protected readonly fileChangeFactory: ChangeSetFileElementFactory;
 
     get onDidChange(): Event<void> {
         return this.storageService.onDidChange;
@@ -77,18 +83,19 @@ export class TaskContextService {
     }
 
     /** 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> {
+    async summarize(session: ChatSession, promptId?: string, agent?: ChatAgent, override = true): 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; }
+        if (existing && !override) { 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 prompt = await this.getSystemPrompt(session, promptId);
             const newSummary: Summary = {
-                summary: await this.getLlmSummary(session, promptId, agent),
+                summary: await this.getLlmSummary(session, prompt, agent),
                 label: session.title || session.id,
                 sessionId: session.id,
                 id: summaryId
@@ -97,6 +104,13 @@ export class TaskContextService {
             return summaryId;
         } catch (err) {
             summaryDeferred.reject(err);
+            const errorSummary: Summary = {
+                summary: `Summary creation failed: ${err instanceof Error ? err.message : typeof err === 'string' ? err : 'Unknown error'}`,
+                label: session.title || session.id,
+                sessionId: session.id,
+                id: summaryId
+            };
+            await this.storageService.store(errorSummary);
             throw err;
         } finally {
             progress.cancel();
@@ -104,7 +118,95 @@ export class TaskContextService {
         }
     }
 
-    protected async getLlmSummary(session: ChatSession, promptId: string = CHAT_SESSION_SUMMARY_PROMPT.id, agent?: ChatAgent): Promise<string> {
+    async update(session: ChatSession, promptId?: string, agent?: ChatAgent, override = true): Promise<string> {
+        // Get the existing summary for the session
+        const existingSummary = this.getSummaryForSession(session);
+        if (!existingSummary) {
+            // If no summary exists, create one instead
+            // TODO: Maybe we could also look into the task context folder and ask for the existing ones with an additional menu to create a new one?
+            return this.summarize(session, promptId, agent, override);
+        }
+
+        const progress = await this.progressService.showProgress({ text: `Updating: ${session.title || session.id}`, options: { location: 'ai-chat' } });
+        try {
+            const prompt = await this.getSystemPrompt(session, promptId);
+            if (!prompt) {
+                return '';
+            }
+
+            // Get the task context file path
+            const taskContextStorageDirectory = this.preferenceService.get(
+                // preference key is defined in TASK_CONTEXT_STORAGE_DIRECTORY_PREF in @theia/ai-ide
+                'ai-features.promptTemplates.taskContextStorageDirectory',
+                '.prompts/task-contexts'
+            );
+            const taskContextFileVariable = session.model.context.getVariables().find(variableReq => variableReq.variable.id === 'file-provider' &&
+                typeof variableReq.arg === 'string' &&
+                (variableReq.arg.startsWith(taskContextStorageDirectory)));
+
+            // Check if we have a document path to update
+            if (taskContextFileVariable && typeof taskContextFileVariable.arg === 'string') {
+                // Set document path in prompt template
+                const documentPath = taskContextFileVariable.arg;
+
+                // Modify prompt to include the document path and content
+                prompt.text = prompt.text + '\nThe document to update is: ' + documentPath + '\n\n## Current Document Content\n\n' + existingSummary.summary;
+
+                // Get updated document content from LLM
+                const updatedDocumentContent = await this.getLlmSummary(session, prompt, agent);
+
+                if (existingSummary.uri) {
+                    // updated document metadata shall be updated.
+                    // otherwise, frontmatter won't be set
+                    const frontmatter = {
+                        sessionId: existingSummary.sessionId,
+                        date: new Date().toISOString(),
+                        label: existingSummary.label,
+                    };
+                    const content = yaml.dump(frontmatter).trim() + `${EOL}---${EOL}` + updatedDocumentContent;
+
+                    session.model.changeSet.addElements(this.fileChangeFactory({
+                        uri: existingSummary.uri,
+                        type: 'modify',
+                        state: 'pending',
+                        targetState: content,
+                        requestId: session.model.id, // not a request id, as no changeRequest made yet.
+                        chatSessionId: session.id
+                    }));
+                } else {
+                    const updatedSummary: Summary = {
+                        ...existingSummary,
+                        summary: updatedDocumentContent
+                    };
+
+                    // Store the updated summary
+                    await this.storageService.store(updatedSummary);
+                }
+                return existingSummary.id;
+            } else {
+                // Fall back to standard update if no document path is found
+                const updatedSummaryText = await this.getLlmSummary(session, prompt, agent);
+                const updatedSummary: Summary = {
+                    ...existingSummary,
+                    summary: updatedSummaryText
+                };
+                await this.storageService.store(updatedSummary);
+                return updatedSummary.id;
+            }
+        } catch (err) {
+            const errorSummary: Summary = {
+                ...existingSummary,
+                summary: `Summary update failed: ${err instanceof Error ? err.message : typeof err === 'string' ? err : 'Unknown error'}`
+            };
+            await this.storageService.store(errorSummary);
+            throw err;
+        } finally {
+            progress.cancel();
+        }
+    }
+
+    protected async getLlmSummary(session: ChatSession, prompt: ResolvedPromptFragment | undefined, agent?: ChatAgent): Promise<string> {
+        if (!prompt) { return ''; }
         agent = agent || this.agentService.getAgents().find<ChatAgent>((candidate): candidate is ChatAgent =>
             'invoke' in candidate
             && typeof candidate.invoke === 'function'
@@ -112,8 +214,7 @@ export class TaskContextService {
         );
         if (!agent) { throw new Error('Unable to identify agent for summary.'); }
         const model = new MutableChatModel(ChatAgentLocation.Panel);
-        const prompt = await this.promptService.getResolvedPromptFragment(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({
@@ -126,6 +227,11 @@ export class TaskContextService {
         return summaryRequest.response.response.asDisplayString();
     }
 
+    protected async getSystemPrompt(session: ChatSession, promptId: string = CHAT_SESSION_SUMMARY_PROMPT.id): Promise<ResolvedPromptFragment | undefined> {
+        const prompt = await this.promptService.getResolvedPromptFragment(promptId || CHAT_SESSION_SUMMARY_PROMPT.id, undefined, { model: session.model });
+        return prompt;
+    }
+
     hasSummary(chatSession: ChatSession): boolean {
         return !!this.getSummaryForSession(chatSession);
     }

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

@@ -28,6 +28,10 @@ export class InMemoryTaskContextStorage implements TaskContextStorageService {
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
+    protected sanitizeLabel(label: string): string {
+        return label.replace(/^[^\p{L}\p{N}]+/vg, '');
+    }
+
     @inject(AIVariableResourceResolver)
     protected readonly variableResourceResolver: AIVariableResourceResolver;
 
@@ -35,7 +39,7 @@ export class InMemoryTaskContextStorage implements TaskContextStorageService {
     protected readonly openerService: OpenerService;
 
     store(summary: Summary): void {
-        this.summaries.set(summary.id, summary);
+        this.summaries.set(summary.id, { ...summary, label: this.sanitizeLabel(summary.label) });
         this.onDidChangeEmitter.fire();
     }
 

package/src/common/change-set.ts

@@ -0,0 +1,197 @@
+// *****************************************************************************
+// 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 { ArrayUtils, Disposable, Emitter, Event, URI } from '@theia/core';
+
+export interface ChangeSetElement {
+    readonly uri: URI;
+
+    onDidChange?: Event<void>
+    readonly name?: string;
+    readonly icon?: string;
+    readonly additionalInfo?: string;
+
+    readonly state?: 'pending' | 'applied' | 'stale';
+    readonly type?: 'add' | 'modify' | 'delete';
+    readonly data?: { [key: string]: unknown };
+
+    /** Called when an element is shown in the UI */
+    onShow?(): void;
+    /** Called when an element is hidden in the UI */
+    onHide?(): void;
+    open?(): Promise<void>;
+    openChange?(): Promise<void>;
+    apply?(): Promise<void>;
+    revert?(): Promise<void>;
+    dispose?(): void;
+}
+
+export interface ChatUpdateChangeSetEvent {
+    kind: 'updateChangeSet';
+    elements?: ChangeSetElement[];
+    title?: string;
+}
+
+export interface ChangeSetChangeEvent {
+    title?: string;
+    added?: URI[],
+    removed?: URI[],
+    modified?: URI[],
+    /** Fired when only the state of a given element changes, not its contents */
+    state?: URI[],
+}
+
+export interface ChangeSet extends Disposable {
+    onDidChange: Event<ChatUpdateChangeSetEvent>;
+    readonly title: string;
+    setTitle(title: string): void;
+    getElements(): ChangeSetElement[];
+    /**
+     * Find an element by URI.
+     * @param uri The URI to look for.
+     * @returns The element with the given URI, or undefined if not found.
+     */
+    getElementByURI(uri: URI): ChangeSetElement | undefined;
+    /** @returns true if addition produces a change; false otherwise. */
+    addElements(...elements: ChangeSetElement[]): boolean;
+    setElements(...elements: ChangeSetElement[]): void;
+    /** @returns true if deletion produces a change; false otherwise. */
+    removeElements(...uris: URI[]): boolean;
+    dispose(): void;
+}
+
+export class ChangeSetImpl implements ChangeSet {
+    /** @param changeSets ordered from tip to root. */
+    static combine(changeSets: Iterable<ChangeSetImpl>): Map<string, ChangeSetElement | undefined> {
+        const result = new Map<string, ChangeSetElement | undefined>();
+        for (const next of changeSets) {
+            next._elements.forEach((value, key) => !result.has(key) && result.set(key, value));
+            // Break at the first element whose values were set, not just changed through addition and deletion.
+            if (next.hasBeenSet) {
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    protected readonly _onDidChangeEmitter = new Emitter<ChatUpdateChangeSetEvent>();
+    onDidChange: Event<ChatUpdateChangeSetEvent> = this._onDidChangeEmitter.event;
+    protected readonly _onDidChangeContentsEmitter = new Emitter<ChangeSetChangeEvent>();
+    onDidChangeContents: Event<ChangeSetChangeEvent> = this._onDidChangeContentsEmitter.event;
+
+    protected hasBeenSet = false;
+    protected _elements = new Map<string, ChangeSetElement | undefined>();
+    protected _title = 'Suggested Changes';
+    get title(): string {
+        return this._title;
+    }
+
+    constructor(elements: ChangeSetElement[] = []) {
+        this.addElements(...elements);
+    }
+
+    getElements(): ChangeSetElement[] {
+        return ArrayUtils.coalesce(Array.from(this._elements.values()));
+    }
+
+    /** Will replace any element that is already present, using URI as identity criterion. */
+    addElements(...elements: ChangeSetElement[]): boolean {
+        const added: URI[] = [];
+        const modified: URI[] = [];
+        elements.forEach(element => {
+            if (this.doAdd(element)) {
+                modified.push(element.uri);
+            } else {
+                added.push(element.uri);
+            }
+        });
+        this.notifyChange({ added, modified });
+        return !!(added.length || modified.length);
+    }
+
+    setTitle(title: string): void {
+        this._title = title;
+        this.notifyChange({ title });
+    }
+
+    protected doAdd(element: ChangeSetElement): boolean {
+        const id = element.uri.toString();
+        const existing = this._elements.get(id);
+        existing?.dispose?.();
+        this._elements.set(id, element);
+        element.onDidChange?.(() => this.notifyChange({ state: [element.uri] }));
+        return !!existing;
+    }
+
+    setElements(...elements: ChangeSetElement[]): void {
+        this.hasBeenSet = true;
+        const added = [];
+        const modified = [];
+        const removed = [];
+        const toHandle = new Set(this._elements.keys());
+        for (const element of elements) {
+            toHandle.delete(element.uri.toString());
+            if (this.doAdd(element)) {
+                added.push(element.uri);
+            } else {
+                modified.push(element.uri);
+            }
+        }
+        for (const toDelete of toHandle) {
+            const uri = new URI(toDelete);
+            if (this.doDelete(uri)) {
+                removed.push(uri);
+            }
+        }
+        this.notifyChange({ added, modified, removed });
+    }
+
+    removeElements(...uris: URI[]): boolean {
+        const removed: URI[] = [];
+        for (const uri of uris) {
+            if (this.doDelete(uri)) {
+                removed.push(uri);
+            }
+        }
+        this.notifyChange({ removed });
+        return !!removed.length;
+    }
+
+    getElementByURI(uri: URI): ChangeSetElement | undefined {
+        return this._elements.get(uri.toString());
+    }
+
+    protected doDelete(uri: URI): boolean {
+        const id = uri.toString();
+        const delendum = this._elements.get(id);
+        if (delendum) {
+            delendum.dispose?.();
+        }
+        this._elements.set(id, undefined);
+        return !!delendum;
+    }
+
+    protected notifyChange(change: ChangeSetChangeEvent): void {
+        this._onDidChangeContentsEmitter.fire(change);
+        this._onDidChangeEmitter.fire({ kind: 'updateChangeSet', elements: this.getElements(), title: this.title });
+    }
+
+    dispose(): void {
+        this._onDidChangeEmitter.dispose();
+        this._elements.forEach(element => element?.dispose?.());
+    }
+}

package/src/common/chat-agent-service.ts

@@ -25,6 +25,7 @@ import { ChatAgent } from './chat-agents';
 import { AgentService } from '@theia/ai-core';
 
 export const ChatAgentService = Symbol('ChatAgentService');
+export const ChatAgentServiceFactory = Symbol('ChatAgentServiceFactory');
 /**
  * The ChatAgentService provides access to the available chat agents.
  */

package/src/common/chat-agents.ts

@@ -54,17 +54,19 @@ import { inject, injectable, named, postConstruct } from '@theia/core/shared/inv
 import { ChatAgentService } from './chat-agent-service';
 import {
     ChatModel,
-    MutableChatRequestModel,
+    ChatRequestModel,
     ChatResponseContent,
     ErrorChatResponseContentImpl,
     MarkdownChatResponseContentImpl,
-    ToolCallChatResponseContentImpl,
-    ChatRequestModel,
+    MutableChatRequestModel,
     ThinkingChatResponseContentImpl,
+    ToolCallChatResponseContentImpl,
+    ErrorChatResponseContent,
 } from './chat-model';
+import { ChatToolRequest, ChatToolRequestService } from './chat-tool-request-service';
 import { parseContents } from './parse-contents';
 import { DefaultResponseContentFactory, ResponseContentMatcher, ResponseContentMatcherProvider } from './response-content-matcher';
-import { ChatToolRequest, ChatToolRequestService } from './chat-tool-request-service';
+import { ImageContextVariable } from './image-context-variable';
 
 /**
  * System message content, enriched with function descriptions.
@@ -218,6 +220,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
     };
 
     protected handleError(request: MutableChatRequestModel, error: Error): void {
+        console.error('Error handling chat interaction:', error);
         request.response.response.addContent(new ErrorChatResponseContentImpl(error));
         request.response.error(error);
     }
@@ -252,23 +255,41 @@ export abstract class AbstractChatAgent implements ChatAgent {
         const requestMessages = model.getRequests().flatMap(request => {
             const messages: LanguageModelMessage[] = [];
             const text = request.message.parts.map(part => part.promptText).join('');
-            messages.push({
-                actor: 'user',
-                type: 'text',
-                text: text,
-            });
-            if (request.response.isComplete || includeResponseInProgress) {
-                const responseMessages: LanguageModelMessage[] = request.response.response.content.flatMap(c => {
-                    if (ChatResponseContent.hasToLanguageModelMessage(c)) {
-                        return c.toLanguageModelMessage();
+            if (text.length > 0) {
+                messages.push({
+                    actor: 'user',
+                    type: 'text',
+                    text: text,
+                });
+            }
+            const imageMessages = request.context.variables
+                .filter(variable => ImageContextVariable.isResolvedImageContext(variable))
+                .map(variable => ImageContextVariable.parseResolved(variable))
+                .filter(content => content !== undefined)
+                .map(content => ({
+                    actor: 'user' as const,
+                    type: 'image' as const,
+                    image: {
+                        base64data: content!.data,
+                        mimeType: content!.mimeType
                     }
+                }));
+            messages.push(...imageMessages);
 
-                    return {
-                        actor: 'ai',
-                        type: 'text',
-                        text: c.asString?.() ?? c.asDisplayString?.() ?? '',
-                    } as TextMessage;
-                });
+            if (request.response.isComplete || includeResponseInProgress) {
+                const responseMessages: LanguageModelMessage[] = request.response.response.content
+                    .filter(c => !ErrorChatResponseContent.is(c))
+                    .flatMap(c => {
+                        if (ChatResponseContent.hasToLanguageModelMessage(c)) {
+                            return c.toLanguageModelMessage();
+                        }
+
+                        return {
+                            actor: 'ai',
+                            type: 'text',
+                            text: c.asString?.() ?? c.asDisplayString?.() ?? '',
+                        } as TextMessage;
+                    });
                 messages.push(...responseMessages);
             }
             return messages;