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

package/src/browser/agent-delegation-tool.ts

@@ -0,0 +1,207 @@
+// *****************************************************************************
+// 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 { ToolProvider, ToolRequest } from '@theia/ai-core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import {
+    ChatAgentService,
+    ChatAgentServiceFactory,
+    ChatRequest,
+    ChatService,
+    ChatServiceFactory,
+    MutableChatRequestModel,
+    MutableChatModel,
+    ChatSession,
+} from '../common';
+import { DelegationResponseContent } from './delegation-response-content';
+
+export const AGENT_DELEGATION_FUNCTION_ID = 'delegateToAgent';
+
+@injectable()
+export class AgentDelegationTool implements ToolProvider {
+    static ID = AGENT_DELEGATION_FUNCTION_ID;
+
+    @inject(ChatAgentServiceFactory)
+    protected readonly getChatAgentService: () => ChatAgentService;
+
+    @inject(ChatServiceFactory)
+    protected readonly getChatService: () => ChatService;
+
+    getTool(): ToolRequest {
+        return {
+            id: AgentDelegationTool.ID,
+            name: AgentDelegationTool.ID,
+            description:
+                'Delegate a task or question to a specific AI agent. This tool allows you to submit requests to specialized agents based on their capabilities.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    agentId: {
+                        type: 'string',
+                        description:
+                            'The ID of the AI agent to delegate the task to.',
+                    },
+                    prompt: {
+                        type: 'string',
+                        description:
+                            'The task, question, or prompt to pass to the specified agent.',
+                    },
+                },
+                required: ['agentId', 'prompt'],
+            },
+            handler: (arg_string: string, ctx: MutableChatRequestModel) =>
+                this.delegateToAgent(arg_string, ctx),
+        };
+    }
+
+    private async delegateToAgent(
+        arg_string: string,
+        ctx: MutableChatRequestModel
+    ): Promise<string> {
+        try {
+            const args = JSON.parse(arg_string);
+            const { agentId, prompt } = args;
+
+            if (!agentId || !prompt) {
+                const errorMsg = 'Both agentId and prompt parameters are required.';
+                console.error(errorMsg, { agentId, prompt });
+                return errorMsg;
+            }
+
+            // Check if the specified agent exists
+            const agent = this.getChatAgentService().getAgent(agentId);
+            if (!agent) {
+                const availableAgents = this.getChatAgentService()
+                    .getAgents()
+                    .map(a => a.id);
+                const errorMsg = `Agent '${agentId}' not found or not enabled. Available agents: ${availableAgents.join(', ')}`;
+                console.error(errorMsg);
+                return errorMsg;
+            }
+
+            let newSession;
+            try {
+                // FIXME: this creates a new conversation visible in the UI (Panel), which we don't want
+                // It is not possible to start a session without specifying a location (default=Panel)
+                const chatService = this.getChatService();
+
+                // Store the current active session to restore it after delegation
+                const currentActiveSession = chatService.getActiveSession();
+
+                newSession = chatService.createSession(
+                    undefined,
+                    { focus: false },
+                    agent
+                );
+
+                // Immediately restore the original active session to avoid confusing the user
+                if (currentActiveSession) {
+                    chatService.setActiveSession(currentActiveSession.id, { focus: false });
+                }
+
+                // Setup ChangeSet bubbling from delegated session to parent session
+                this.setupChangeSetBubbling(newSession, ctx.session, agent.name);
+            } catch (sessionError) {
+                const errorMsg = `Failed to create chat session for agent '${agentId}': ${sessionError instanceof Error ? sessionError.message : sessionError}`;
+                console.error(errorMsg, sessionError);
+                return errorMsg;
+            }
+
+            // Send the request
+            const chatRequest: ChatRequest = {
+                text: prompt,
+            };
+
+            let response;
+            try {
+                const chatService = this.getChatService();
+                response = await chatService.sendRequest(
+                    newSession.id,
+                    chatRequest
+                );
+            } catch (sendError) {
+                const errorMsg = `Failed to send request to agent '${agentId}': ${sendError instanceof Error ? sendError.message : sendError}`;
+                console.error(errorMsg, sendError);
+                return errorMsg;
+            }
+
+            if (response) {
+                // Add the response content immediately to enable streaming
+                // The renderer will handle the streaming updates
+                ctx.response.response.addContent(
+                    new DelegationResponseContent(agent.name, prompt, response)
+                );
+
+                try {
+                    // Wait for completion to return the final result as tool output
+                    const result = await response.responseCompleted;
+                    const stringResult = result.response.asString();
+                    // Return the raw text to the top-level Agent, as a tool result
+                    return stringResult;
+                } catch (completionError) {
+                    const errorMsg = `Failed to complete response from agent '${agentId}': ${completionError instanceof Error ? completionError.message : completionError}`;
+                    console.error(errorMsg, completionError);
+                    return errorMsg;
+                }
+            } else {
+                const errorMsg = `Delegation to agent '${agentId}' has failed: no response returned.`;
+                console.error(errorMsg);
+                return errorMsg;
+            }
+        } catch (error) {
+            console.error('Failed to delegate to agent', error);
+            return JSON.stringify({
+                error: `Failed to parse arguments or delegate to agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+
+    /**
+     * Sets up monitoring of the ChangeSet in the delegated session and bubbles changes to the parent session.
+     * @param delegatedSession The session created for the delegated agent
+     * @param parentModel The parent session model that should receive the bubbled changes
+     * @param agentName The name of the agent for attribution purposes
+     */
+    private setupChangeSetBubbling(
+        delegatedSession: ChatSession,
+        parentModel: MutableChatModel,
+        agentName: string
+    ): void {
+        // Monitor ChangeSet for bubbling
+        delegatedSession.model.changeSet.onDidChange(_event => {
+            this.bubbleChangeSet(delegatedSession, parentModel, agentName);
+        });
+    }
+
+    /**
+     * Bubbles the ChangeSet from the delegated session to the parent session.
+     * @param delegatedSession The session from which to bubble changes
+     * @param parentModel The parent session model to receive the bubbled changes
+     * @param agentName The name of the agent for attribution purposes
+     */
+    private bubbleChangeSet(
+        delegatedSession: ChatSession,
+        parentModel: MutableChatModel,
+        agentName: string
+    ): void {
+        const delegatedElements = delegatedSession.model.changeSet.getElements();
+        if (delegatedElements.length > 0) {
+            const bubbledTitle = `Changes from ${agentName}`;
+            parentModel.changeSet.setTitle(bubbledTitle);
+            parentModel.changeSet.addElements(...delegatedElements);
+        }
+    }
+}

package/src/browser/ai-chat-frontend-module.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Agent, AgentService, AIVariableContribution } from '@theia/ai-core/lib/common';
+import { Agent, AgentService, AIVariableContribution, bindToolProvider } from '@theia/ai-core/lib/common';
 import { bindContributionProvider, CommandContribution } from '@theia/core';
 import { FrontendApplicationContribution, LabelProviderContribution, PreferenceContribution } from '@theia/core/lib/browser';
 import { ContainerModule } from '@theia/core/shared/inversify';
@@ -26,17 +26,21 @@ import {
     ChatRequestParserImpl,
     ChatService,
     ToolCallChatResponseContentFactory,
-    PinChatAgent
+    PinChatAgent,
+    ChatServiceFactory,
+    ChatAgentServiceFactory
 } from '../common';
 import { ChatAgentsVariableContribution } from '../common/chat-agents-variable-contribution';
 import { CustomChatAgent } from '../common/custom-chat-agent';
 import { DefaultResponseContentFactory, DefaultResponseContentMatcherProvider, ResponseContentMatcherProvider } from '../common/response-content-matcher';
 import { aiChatPreferences } from './ai-chat-preferences';
+import { bindChatToolPreferences, ToolConfirmationManager } from './chat-tool-preferences';
 import { ChangeSetElementArgs, ChangeSetFileElement, ChangeSetFileElementFactory } from './change-set-file-element';
 import { AICustomAgentsFrontendApplicationContribution } from './custom-agent-frontend-application-contribution';
 import { FrontendChatServiceImpl } from './frontend-chat-service';
 import { CustomAgentFactory } from './custom-agent-factory';
 import { ChatToolRequestService } from '../common/chat-tool-request-service';
+import { FrontendChatToolRequestService } from './chat-tool-request-service';
 import { ChangeSetFileService } from './change-set-file-service';
 import { ContextVariableLabelProvider } from './context-variable-label-provider';
 import { ContextFileVariableLabelProvider } from './context-file-variable-label-provider';
@@ -52,12 +56,15 @@ import { TaskContextVariableLabelProvider } from './task-context-variable-label-
 import { TaskContextService, TaskContextStorageService } from './task-context-service';
 import { InMemoryTaskContextStorage } from './task-context-storage-service';
 import { AIChatFrontendContribution } from './ai-chat-frontend-contribution';
+import { ImageContextVariableContribution } from './image-context-variable-contribution';
+import { AgentDelegationTool } from './agent-delegation-tool';
 
 export default new ContainerModule(bind => {
     bindContributionProvider(bind, Agent);
     bindContributionProvider(bind, ChatAgent);
 
-    bind(ChatToolRequestService).toSelf().inSingletonScope();
+    bind(FrontendChatToolRequestService).toSelf().inSingletonScope();
+    bind(ChatToolRequestService).toService(FrontendChatToolRequestService);
 
     bind(ChatAgentServiceImpl).toSelf().inSingletonScope();
     bind(ChatAgentService).toService(ChatAgentServiceImpl);
@@ -80,8 +87,19 @@ export default new ContainerModule(bind => {
     bind(FrontendChatServiceImpl).toSelf().inSingletonScope();
     bind(ChatService).toService(FrontendChatServiceImpl);
 
+    bind(ChatServiceFactory).toDynamicValue(ctx => () =>
+        ctx.container.get<ChatService>(ChatService)
+    );
+    bind(ChatAgentServiceFactory).toDynamicValue(ctx => () =>
+        ctx.container.get<ChatAgentService>(ChatAgentService)
+    );
+
     bind(PreferenceContribution).toConstantValue({ schema: aiChatPreferences });
 
+    // Tool confirmation preferences
+    bindChatToolPreferences(bind);
+    bind(ToolConfirmationManager).toSelf().inSingletonScope();
+
     bind(CustomChatAgent).toSelf();
     bind(CustomAgentFactory).toFactory<CustomChatAgent, [string, string, string, string, string]>(
         ctx => (id: string, name: string, description: string, prompt: string, defaultLLM: string) => {
@@ -124,14 +142,21 @@ export default new ContainerModule(bind => {
 
     bind(ChatSessionSummaryAgent).toSelf().inSingletonScope();
     bind(Agent).toService(ChatSessionSummaryAgent);
+
     bind(TaskContextVariableContribution).toSelf().inSingletonScope();
     bind(AIVariableContribution).toService(TaskContextVariableContribution);
     bind(TaskContextVariableLabelProvider).toSelf().inSingletonScope();
     bind(LabelProviderContribution).toService(TaskContextVariableLabelProvider);
 
+    bind(ImageContextVariableContribution).toSelf().inSingletonScope();
+    bind(AIVariableContribution).toService(ImageContextVariableContribution);
+    bind(LabelProviderContribution).toService(ImageContextVariableContribution);
+
     bind(TaskContextService).toSelf().inSingletonScope();
     bind(InMemoryTaskContextStorage).toSelf().inSingletonScope();
     bind(TaskContextStorageService).toService(InMemoryTaskContextStorage);
     bind(AIChatFrontendContribution).toSelf().inSingletonScope();
     bind(CommandContribution).toService(AIChatFrontendContribution);
+
+    bindToolProvider(AgentDelegationTool, bind);
 });

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

@@ -18,7 +18,7 @@ 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 { ChangeSetElement } from '../common';
 import { createChangeSetFileUri } from './change-set-file-resource';
 import { ChangeSetFileService } from './change-set-file-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
@@ -33,10 +33,10 @@ export const ChangeSetElementArgs = Symbol('ChangeSetElementArgs');
 export interface ChangeSetElementArgs extends Partial<ChangeSetElement> {
     /** The URI of the element, expected to be unique within the same change set. */
     uri: URI;
-    /** The change set containing this element. */
-    changeSet: ChangeSetImpl;
     /** The id of the chat session containing this change set element. */
     chatSessionId: string;
+    /** The id of the request with which this change set element is associated. */
+    requestId: string;
     /**
      * The state of the file after the changes have been applied.
      * If `undefined`, there is no change.
@@ -71,38 +71,52 @@ export class ChangeSetFileElement implements ChangeSetElement {
     @inject(ConfigurableInMemoryResources)
     protected readonly inMemoryResources: ConfigurableInMemoryResources;
 
+    @inject(ChangeSetFileElementFactory) protected readonly factory: ChangeSetFileElementFactory;
+
     protected readonly toDispose = new DisposableCollection();
     protected _state: ChangeSetElementState;
 
-    protected originalContent: string | undefined;
+    private _originalContent: string | undefined;
+    protected _initialized = false;
+    protected _initializationPromise: Promise<void> | undefined;
 
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
-    protected readOnlyResource: ConfigurableMutableReferenceResource;
-    protected changeResource: ConfigurableMutableReferenceResource;
+    protected _readOnlyResource: ConfigurableMutableReferenceResource;
+    protected _changeResource: ConfigurableMutableReferenceResource;
 
     @postConstruct()
     init(): void {
-        this.getResources();
-        this.obtainOriginalContent();
-        this.listenForOriginalFileChanges();
+        this._initializationPromise = this.initializeAsync();
         this.toDispose.push(this.onDidChangeEmitter);
     }
 
-    protected async obtainOriginalContent(): Promise<void> {
-        this.originalContent = await this.changeSetFileService.read(this.uri);
-        this.readOnlyResource.update({ contents: this.originalContent ?? '' });
-        if (this.state === 'applied') {
+    protected async initializeAsync(): Promise<void> {
+        await this.obtainOriginalContent();
+        this.listenForOriginalFileChanges();
+        this._initialized = true;
+    }
 
-        }
+    /**
+     * Ensures that the element is fully initialized before proceeding.
+     * This includes loading the original content from the file system.
+     */
+    async ensureInitialized(): Promise<void> {
+        await this._initializationPromise;
     }
 
-    protected getResources(): void {
-        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]);
+    /**
+     * Returns true if the element has been fully initialized.
+     */
+    get isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    protected async obtainOriginalContent(): Promise<void> {
+        this._originalContent = await this.changeSetFileService.read(this.uri);
+        if (this._readOnlyResource) {
+            this.readOnlyResource.update({ contents: this._originalContent ?? '' });
+        }
     }
 
     protected getInMemoryUri(uri: URI): ConfigurableMutableReferenceResource {
@@ -112,10 +126,14 @@ export class ChangeSetFileElement implements ChangeSetElement {
     protected listenForOriginalFileChanges(): void {
         this.toDispose.push(this.fileService.onDidFilesChange(async event => {
             if (!event.contains(this.uri)) { return; }
+            if (!this._initialized && this._initializationPromise) {
+                // make sure we are initialized
+                await this._initializationPromise;
+            }
             // If we are applied, the tricky thing becomes the question what to revert to; otherwise, what to apply.
             const newContent = await this.changeSetFileService.read(this.uri).catch(() => '');
             this.readOnlyResource.update({ contents: newContent });
-            if (newContent === this.originalContent) {
+            if (newContent === this._originalContent) {
                 this.state = 'pending';
             } else if (newContent === this.targetState) {
                 this.state = 'applied';
@@ -129,12 +147,41 @@ export class ChangeSetFileElement implements ChangeSetElement {
         return this.elementProps.uri;
     }
 
+    protected get readOnlyResource(): ConfigurableMutableReferenceResource {
+        if (!this._readOnlyResource) {
+            this._readOnlyResource = this.getInMemoryUri(ChangeSetFileElement.toReadOnlyUri(this.uri, this.elementProps.chatSessionId));
+            this._readOnlyResource.update({
+                autosaveable: false,
+                readOnly: true,
+                contents: this._originalContent ?? ''
+            });
+            this.toDispose.push(this._readOnlyResource);
+
+            // If not yet initialized, update the resource once initialization completes
+            if (!this._initialized) {
+                this._initializationPromise?.then(() => {
+                    this._readOnlyResource?.update({ contents: this._originalContent ?? '' });
+                });
+            }
+        }
+        return this._readOnlyResource;
+    }
+
     get readOnlyUri(): URI {
-        return ChangeSetFileElement.toReadOnlyUri(this.uri, this.elementProps.chatSessionId);
+        return this.readOnlyResource.uri;
+    }
+
+    protected get changeResource(): ConfigurableMutableReferenceResource {
+        if (!this._changeResource) {
+            this._changeResource = this.getInMemoryUri(createChangeSetFileUri(this.elementProps.chatSessionId, this.uri));
+            this._changeResource.update({ autosaveable: false });
+            this.toDispose.push(this._changeResource);
+        }
+        return this._changeResource;
     }
 
     get changedUri(): URI {
-        return createChangeSetFileUri(this.elementProps.chatSessionId, this.uri);
+        return this.changeResource.uri;
     }
 
     get name(): string {
@@ -172,15 +219,33 @@ export class ChangeSetFileElement implements ChangeSetElement {
         return this.elementProps.data;
     };
 
+    get originalContent(): string | undefined {
+        if (!this._initialized && this._initializationPromise) {
+            console.warn('Accessing originalContent before initialization is complete. Consider using async methods.');
+        }
+        return this._originalContent;
+    }
+
+    /**
+     * Gets the original content of the file asynchronously.
+     * Ensures initialization is complete before returning the content.
+     */
+    async getOriginalContent(): Promise<string | undefined> {
+        await this.ensureInitialized();
+        return this._originalContent;
+    }
+
     get targetState(): string {
         return this.elementProps.targetState ?? '';
     }
 
     async open(): Promise<void> {
+        await this.ensureInitialized();
         this.changeSetFileService.open(this);
     }
 
     async openChange(): Promise<void> {
+        await this.ensureInitialized();
         this.changeSetFileService.openDiff(
             this.readOnlyUri,
             this.changedUri
@@ -188,6 +253,7 @@ export class ChangeSetFileElement implements ChangeSetElement {
     }
 
     async apply(contents?: string): Promise<void> {
+        await this.ensureInitialized();
         if (!await this.confirm('Apply')) { return; }
         if (!(await this.changeSetFileService.trySave(this.changedUri))) {
             if (this.type === 'delete') {
@@ -205,13 +271,19 @@ export class ChangeSetFileElement implements ChangeSetElement {
         this.state = 'applied';
     }
 
+    onShow(): void {
+        // Ensure we have the latest state when showing
+        this.changeResource.update({ contents: this.targetState, onSave: content => this.writeChanges(content) });
+    }
+
     async revert(): Promise<void> {
+        await this.ensureInitialized();
         if (!await this.confirm('Revert')) { return; }
         this.state = 'pending';
         if (this.type === 'add') {
             await this.changeSetFileService.delete(this.uri);
-        } else if (this.originalContent) {
-            await this.changeSetFileService.write(this.uri, this.originalContent);
+        } else if (this._originalContent) {
+            await this.changeSetFileService.write(this.uri, this._originalContent);
         }
     }
 

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

@@ -42,7 +42,7 @@ 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) { return undefined; }
-        if (!context.model.changeSet?.getElements().length) {
+        if (!context.model.changeSet.getElements().length) {
             return {
                 variable: CHANGE_SET_SUMMARY_VARIABLE,
                 value: ''