@theia/ai-chat 1.63.0-next.24 → 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,7 +26,9 @@ 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';
@@ -54,6 +56,8 @@ 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);
@@ -83,6 +87,13 @@ 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
@@ -131,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

@@ -76,7 +76,9 @@ export class ChangeSetFileElement implements ChangeSetElement {
     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;
@@ -85,12 +87,36 @@ export class ChangeSetFileElement implements ChangeSetElement {
 
     @postConstruct()
     init(): void {
+        this._initializationPromise = this.initializeAsync();
         this.toDispose.push(this.onDidChangeEmitter);
     }
 
+    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;
+    }
+
+    /**
+     * 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);
-        this.readOnlyResource.update({ contents: this.originalContent ?? '' });
+        this._originalContent = await this.changeSetFileService.read(this.uri);
+        if (this._readOnlyResource) {
+            this.readOnlyResource.update({ contents: this._originalContent ?? '' });
+        }
     }
 
     protected getInMemoryUri(uri: URI): ConfigurableMutableReferenceResource {
@@ -100,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';
@@ -120,10 +150,19 @@ export class ChangeSetFileElement implements ChangeSetElement {
     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 });
+            this._readOnlyResource.update({
+                autosaveable: false,
+                readOnly: true,
+                contents: this._originalContent ?? ''
+            });
             this.toDispose.push(this._readOnlyResource);
-            this.obtainOriginalContent();
-            this.listenForOriginalFileChanges();
+
+            // 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;
     }
@@ -180,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
@@ -196,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') {
@@ -214,16 +272,18 @@ export class ChangeSetFileElement implements ChangeSetElement {
     }
 
     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/chat-tool-preferences.ts

@@ -29,7 +29,7 @@ import {
  * Enum for tool confirmation modes
  */
 export enum ToolConfirmationMode {
-    YOLO = 'yolo',
+    ALWAYS_ALLOW = 'always_allow',
     CONFIRM = 'confirm',
     DISABLED = 'disabled'
 }
@@ -43,7 +43,7 @@ export const chatToolPreferences: PreferenceSchema = {
             type: 'object',
             additionalProperties: {
                 type: 'string',
-                enum: [ToolConfirmationMode.YOLO, ToolConfirmationMode.CONFIRM, ToolConfirmationMode.DISABLED],
+                enum: [ToolConfirmationMode.ALWAYS_ALLOW, ToolConfirmationMode.CONFIRM, ToolConfirmationMode.DISABLED],
                 enumDescriptions: [
                     nls.localize('theia/ai/chat/toolConfirmation/yolo/description', 'Execute tools automatically without confirmation'),
                     nls.localize('theia/ai/chat/toolConfirmation/confirm/description', 'Ask for confirmation before executing tools'),
@@ -110,7 +110,7 @@ export class ToolConfirmationManager {
         if (toolConfirmation['*']) {
             return toolConfirmation['*'];
         }
-        return ToolConfirmationMode.YOLO; // Default to YOLO
+        return ToolConfirmationMode.ALWAYS_ALLOW; // Default to Always Allow
     }
 
     /**
@@ -121,7 +121,7 @@ export class ToolConfirmationManager {
         // Determine the global default (star entry), or fallback to schema default
         let starMode = current['*'];
         if (starMode === undefined) {
-            starMode = ToolConfirmationMode.YOLO;
+            starMode = ToolConfirmationMode.ALWAYS_ALLOW;
         }
         if (mode === starMode) {
             // Remove the toolId entry if it exists

package/src/browser/chat-tool-request-service.ts

@@ -42,7 +42,7 @@ export class FrontendChatToolRequestService extends ChatToolRequestService {
                     case ToolConfirmationMode.DISABLED:
                         return { denied: true, message: `Tool ${toolRequest.id} is disabled` };
 
-                    case ToolConfirmationMode.YOLO:
+                    case ToolConfirmationMode.ALWAYS_ALLOW:
                         // Execute immediately without confirmation
                         return toolRequest.handler(arg_string, request);
 

package/src/browser/delegation-response-content.ts

@@ -0,0 +1,55 @@
+// *****************************************************************************
+// 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 { isObject } from '@theia/core';
+import { ChatRequestInvocation, ChatResponseContent } from '../common';
+
+/**
+ * Response Content created when an Agent delegates a prompt to another agent.
+ * Contains agent id, delegated prompt, and the response.
+ */
+export class DelegationResponseContent implements ChatResponseContent {
+    kind = 'AgentDelegation';
+
+    /**
+     * @param agentId The id of the agent to whom the task was delegated
+     * @param prompt The prompt that was delegated
+     * @param response The response from the delegated agent
+     */
+    constructor(
+        public agentId: string,
+        public prompt: string,
+        public response: ChatRequestInvocation
+    ) {
+        // Empty
+    }
+
+    asString(): string {
+        const json = {
+            agentId: this.agentId,
+            prompt: this.prompt
+        };
+        return JSON.stringify(json);
+    }
+}
+
+export function isDelegationResponseContent(
+    value: unknown
+): value is DelegationResponseContent {
+    return (
+        isObject<DelegationResponseContent>(value) &&
+        value.kind === 'AgentDelegation'
+    );
+}