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

package/src/browser/file-changeset-functions.ts

@@ -16,15 +16,24 @@
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { ToolProvider, ToolRequest, ToolRequestParameters, ToolRequestParametersProperties } from '@theia/ai-core';
 import { WorkspaceFunctionScope } from './workspace-functions';
-import { ChangeSetFileElement, ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
-import { ChangeSet, ChangeSetImpl, MutableChatRequestModel } from '@theia/ai-chat';
+import { ChangeSetElementArgs, ChangeSetFileElement, ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
+import { ChangeSet, MutableChatRequestModel } from '@theia/ai-chat';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { ContentReplacer, Replacement } from '@theia/core/lib/common/content-replacer';
 import { URI } from '@theia/core/lib/common/uri';
 
+import {
+    SUGGEST_FILE_CONTENT_ID,
+    WRITE_FILE_CONTENT_ID,
+    SUGGEST_FILE_REPLACEMENTS_ID,
+    WRITE_FILE_REPLACEMENTS_ID,
+    CLEAR_FILE_CHANGES_ID,
+    GET_PROPOSED_CHANGES_ID
+} from '../common/file-changeset-function-ids';
+
 @injectable()
-export class WriteChangeToFileProvider implements ToolProvider {
-    static ID = 'changeSet_writeChangeToFile';
+export class SuggestFileContent implements ToolProvider {
+    static ID = SUGGEST_FILE_CONTENT_ID;
 
     @inject(WorkspaceFunctionScope)
     protected readonly workspaceFunctionScope: WorkspaceFunctionScope;
@@ -37,8 +46,8 @@ export class WriteChangeToFileProvider implements ToolProvider {
 
     getTool(): ToolRequest {
         return {
-            id: WriteChangeToFileProvider.ID,
-            name: WriteChangeToFileProvider.ID,
+            id: SuggestFileContent.ID,
+            name: SuggestFileContent.ID,
             description: `Proposes writing content to a file. If the file exists, it will be overwritten with the provided content.\n
              If the file does not exist, it will be created. This tool will automatically create any directories needed to write the file.\n
              If the new content is empty, the file will be deleted. To move a file, delete it and re-create it at the new location.\n
@@ -61,35 +70,105 @@ export class WriteChangeToFileProvider implements ToolProvider {
             handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> => {
                 const { path, content } = JSON.parse(args);
                 const chatSessionId = ctx.session.id;
-                let changeSet = ctx.session.changeSet;
-                if (!changeSet) {
-                    changeSet = new ChangeSetImpl('Changes proposed by Coder');
-                    ctx.session.setChangeSet(changeSet);
-                }
                 const uri = await this.workspaceFunctionScope.resolveRelativePath(path);
-                let type = 'modify';
+                let type: ChangeSetElementArgs['type'] = 'modify';
                 if (content === '') {
                     type = 'delete';
                 }
                 if (!await this.fileService.exists(uri)) {
                     type = 'add';
                 }
-                changeSet.addElements(
+                ctx.session.changeSet.addElements(
                     this.fileChangeFactory({
                         uri: uri,
-                        type: type as 'modify' | 'add' | 'delete',
+                        type,
                         state: 'pending',
                         targetState: content,
-                        changeSet,
+                        requestId: ctx.id,
                         chatSessionId
                     })
                 );
+                ctx.session.changeSet.setTitle('Changes proposed by Coder');
                 return `Proposed writing to file ${path}. The user will review and potentially apply the changes`;
             }
         };
     }
 }
 
+@injectable()
+export class WriteFileContent implements ToolProvider {
+    static ID = WRITE_FILE_CONTENT_ID;
+
+    @inject(WorkspaceFunctionScope)
+    protected readonly workspaceFunctionScope: WorkspaceFunctionScope;
+
+    @inject(FileService)
+    fileService: FileService;
+
+    @inject(ChangeSetFileElementFactory)
+    protected readonly fileChangeFactory: ChangeSetFileElementFactory;
+
+    getTool(): ToolRequest {
+        return {
+            id: WriteFileContent.ID,
+            name: WriteFileContent.ID,
+            description: `Immediately writes content to a file. If the file exists, it will be overwritten with the provided content.\n
+             If the file does not exist, it will be created. This tool will automatically create any directories needed to write the file.\n
+             If the new content is empty, the file will be deleted. To move a file, delete it and re-create it at the new location.\n
+             Unlike suggestFileContent, this function applies the changes immediately without user confirmation.`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The path of the file to write to.'
+                    },
+                    content: {
+                        type: 'string',
+                        description: `The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions.\n
+                         You MUST include ALL parts of the file, even if they haven\'t been modified.`
+                    }
+                },
+                required: ['path', 'content']
+            },
+            handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> => {
+                const { path, content } = JSON.parse(args);
+                const chatSessionId = ctx.session.id;
+                const uri = await this.workspaceFunctionScope.resolveRelativePath(path);
+                let type = 'modify';
+                if (content === '') {
+                    type = 'delete';
+                }
+                if (!await this.fileService.exists(uri)) {
+                    type = 'add';
+                }
+
+                // Create the file change element
+                const fileElement = this.fileChangeFactory({
+                    uri: uri,
+                    type: type as 'modify' | 'add' | 'delete',
+                    state: 'pending',
+                    targetState: content,
+                    requestId: ctx.id,
+                    chatSessionId
+                });
+
+                ctx.session.changeSet.setTitle('Changes applied by Coder');
+                // Add the element to the change set
+                ctx.session.changeSet.addElements(fileElement);
+
+                try {
+                    // Immediately apply the change
+                    await fileElement.apply();
+                    return `Successfully wrote content to file ${path}.`;
+                } catch (error) {
+                    return `Failed to write content to file ${path}: ${error.message}`;
+                }
+            }
+        };
+    }
+}
+
 @injectable()
 export class ReplaceContentInFileFunctionHelper {
     @inject(WorkspaceFunctionScope)
@@ -107,7 +186,7 @@ export class ReplaceContentInFileFunctionHelper {
         this.replacer = new ContentReplacer();
     }
 
-    getToolMetadata(supportMultipleReplace: boolean = false): { description: string, parameters: ToolRequestParameters } {
+    getToolMetadata(supportMultipleReplace: boolean = false, immediateApplication: boolean = false): { description: string, parameters: ToolRequestParameters } {
         const replacementProperties: ToolRequestParametersProperties = {
             oldContent: {
                 type: 'string',
@@ -156,10 +235,14 @@ export class ReplaceContentInFileFunctionHelper {
             : 'A single occurrence of each old content in the tuples is expected to be replaced. If the number of occurrences in the file does not match the expectation,\
               the function will return an error. In that case try a different approach.';
 
+        const applicationText = immediateApplication
+            ? 'The changes will be applied immediately without user confirmation.'
+            : 'The proposed changes will be applied when the user accepts.';
+
         const replacementDescription = `Propose to replace sections of content in an existing file by providing a list of tuples with old content to be matched and replaced.
             ${replacementSentence}. For deletions, use an empty new content in the tuple.
-            Make sure you use the same line endings and whitespace as in the original file content. The proposed changes will be applied when the user accepts.
-            Multiple calls for the same file will merge replacements unless the reset parameter is set to true. Use the reset parameter to clear previous changes and start 
+            Make sure you use the same line endings and whitespace as in the original file content. ${applicationText}
+            Multiple calls for the same file will merge replacements unless the reset parameter is set to true. Use the reset parameter to clear previous changes and start
             fresh if needed.`;
 
         return {
@@ -171,82 +254,108 @@ export class ReplaceContentInFileFunctionHelper {
 
     async createChangesetFromToolCall(toolCallString: string, ctx: MutableChatRequestModel): Promise<string> {
         try {
-            const { path, replacements, reset } = JSON.parse(toolCallString) as { path: string, replacements: Replacement[], reset?: boolean };
-            const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
+            const result = await this.processReplacementsCommon(toolCallString, ctx, 'Changes proposed by Coder');
 
-            // Get the starting content - either original file or existing proposed state
-            let startingContent: string;
-            if (reset || !ctx.session.changeSet) {
-                // Start from original file content
-                startingContent = (await this.fileService.read(fileUri)).value.toString();
+            if (result.errors.length > 0) {
+                return `Errors encountered: ${result.errors.join('; ')}`;
+            }
+
+            if (result.fileElement) {
+                const action = result.reset ? 'reset and applied' : 'applied';
+                return `Proposed replacements ${action} to file ${result.path}. The user will review and potentially apply the changes.`;
             } else {
-                // Start from existing proposed state if available
-                const existingElement = this.findExistingChangeElement(ctx.session.changeSet, fileUri);
-                if (existingElement) {
-                    startingContent = existingElement.targetState || (await this.fileService.read(fileUri)).value.toString();
-                } else {
-                    startingContent = (await this.fileService.read(fileUri)).value.toString();
-                }
+                return `No changes needed for file ${result.path}. Content already matches the requested state.`;
             }
+        } catch (error) {
+            console.debug('Error processing replacements:', error.message);
+            return JSON.stringify({ error: error.message });
+        }
+    }
 
-            const { updatedContent, errors } = this.replacer.applyReplacements(startingContent, replacements);
+    async writeChangesetFromToolCall(toolCallString: string, ctx: MutableChatRequestModel): Promise<string> {
+        try {
+            const result = await this.processReplacementsCommon(toolCallString, ctx, 'Changes applied by Coder');
 
-            if (errors.length > 0) {
-                return `Errors encountered: ${errors.join('; ')}`;
+            if (result.errors.length > 0) {
+                return `Errors encountered: ${result.errors.join('; ')}`;
             }
 
-            // Only create/update changeset if content actually changed
-            const originalContent = (await this.fileService.read(fileUri)).value.toString();
-            if (updatedContent !== originalContent) {
-                let changeSet = ctx.session.changeSet;
-                if (!changeSet) {
-                    changeSet = new ChangeSetImpl('Changes proposed by Coder');
-                    ctx.session.setChangeSet(changeSet);
-                }
+            if (result.fileElement) {
+                // Immediately apply the change
+                await result.fileElement.apply();
 
-                changeSet.addElements(
-                    this.fileChangeFactory({
-                        uri: fileUri,
-                        type: 'modify',
-                        state: 'pending',
-                        targetState: updatedContent,
-                        changeSet,
-                        chatSessionId: ctx.session.id
-                    })
-                );
+                const action = result.reset ? 'reset and' : '';
+                return `Successfully ${action} applied replacements to file ${result.path}.`;
+            } else {
+                return `No changes needed for file ${result.path}. Content already matches the requested state.`;
             }
-
-            const action = reset ? 'reset and applied' : 'applied';
-            return `Proposed replacements ${action} to file ${path}. The user will review and potentially apply the changes.`;
         } catch (error) {
             console.debug('Error processing replacements:', error.message);
             return JSON.stringify({ error: error.message });
         }
     }
 
+    private async processReplacementsCommon(
+        toolCallString: string,
+        ctx: MutableChatRequestModel,
+        changeSetTitle: string
+    ): Promise<{ fileElement: ChangeSetFileElement | undefined, path: string, reset: boolean, errors: string[] }> {
+        const { path, replacements, reset } = JSON.parse(toolCallString) as { path: string, replacements: Replacement[], reset?: boolean };
+        const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
+
+        // Get the starting content - either original file or existing proposed state
+        let startingContent: string;
+        if (reset || !ctx.session.changeSet) {
+            // Start from original file content
+            startingContent = (await this.fileService.read(fileUri)).value.toString();
+        } else {
+            // Start from existing proposed state if available
+            const existingElement = this.findExistingChangeElement(ctx.session.changeSet, fileUri);
+            if (existingElement) {
+                startingContent = existingElement.targetState || (await this.fileService.read(fileUri)).value.toString();
+            } else {
+                startingContent = (await this.fileService.read(fileUri)).value.toString();
+            }
+        }
+
+        const { updatedContent, errors } = this.replacer.applyReplacements(startingContent, replacements);
+
+        if (errors.length > 0) {
+            return { fileElement: undefined, path, reset: reset || false, errors };
+        }
+
+        // Only create/update changeset if content actually changed
+        const originalContent = (await this.fileService.read(fileUri)).value.toString();
+        if (updatedContent !== originalContent) {
+            ctx.session.changeSet.setTitle(changeSetTitle);
+
+            const fileElement = this.fileChangeFactory({
+                uri: fileUri,
+                type: 'modify',
+                state: 'pending',
+                targetState: updatedContent,
+                requestId: ctx.id,
+                chatSessionId: ctx.session.id
+            });
+
+            ctx.session.changeSet.addElements(fileElement);
+
+            return { fileElement, path, reset: reset || false, errors: [] };
+        } else {
+            return { fileElement: undefined, path, reset: reset || false, errors: [] };
+        }
+    }
+
     private findExistingChangeElement(changeSet: ChangeSet, fileUri: URI): ChangeSetFileElement | undefined {
-        return changeSet.getElementByURI(fileUri) as ChangeSetFileElement;
+        const element = changeSet.getElementByURI(fileUri);
+        if (element instanceof ChangeSetFileElement) { return element; }
     }
 
     async clearFileChanges(path: string, ctx: MutableChatRequestModel): Promise<string> {
         try {
             const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
-
-            if (!ctx.session.changeSet) {
-                return `No pending changes found for file ${path}.`;
-            }
-
-            const elements = ctx.session.changeSet.getElements();
-            const indicesToRemove: number[] = [];
-            elements.forEach((element, index) => {
-                if (element.uri && element.uri.toString() === fileUri.toString()) {
-                    indicesToRemove.push(index);
-                }
-            });
-
-            if (indicesToRemove.length > 0) {
-                ctx.session.changeSet.removeElements(...indicesToRemove);
-                return `Cleared ${indicesToRemove.length} pending change(s) for file ${path}.`;
+            if (ctx.session.changeSet.removeElements(fileUri)) {
+                return `Cleared pending change(s) for file ${path}.`;
             } else {
                 return `No pending changes found for file ${path}.`;
             }
@@ -282,16 +391,16 @@ export class ReplaceContentInFileFunctionHelper {
 }
 
 @injectable()
-export class SimpleReplaceContentInFileProvider implements ToolProvider {
-    static ID = 'changeSet_replaceContentInFilev1';
+export class SimpleSuggestFileReplacements implements ToolProvider {
+    static ID = 'simpleSuggestFileReplacements';
     @inject(ReplaceContentInFileFunctionHelper)
     protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
 
     getTool(): ToolRequest {
         const metadata = this.replaceContentInFileFunctionHelper.getToolMetadata();
         return {
-            id: SimpleReplaceContentInFileProvider.ID,
-            name: SimpleReplaceContentInFileProvider.ID,
+            id: SimpleSuggestFileReplacements.ID,
+            name: SimpleSuggestFileReplacements.ID,
             description: metadata.description,
             parameters: metadata.parameters,
             handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> =>
@@ -301,16 +410,35 @@ export class SimpleReplaceContentInFileProvider implements ToolProvider {
 }
 
 @injectable()
-export class ReplaceContentInFileProvider implements ToolProvider {
-    static ID = 'changeSet_replaceContentInFile';
+export class SimpleWriteFileReplacements implements ToolProvider {
+    static ID = 'simpleWriteFileReplacements';
+    @inject(ReplaceContentInFileFunctionHelper)
+    protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
+
+    getTool(): ToolRequest {
+        const metadata = this.replaceContentInFileFunctionHelper.getToolMetadata(false, true);
+        return {
+            id: SimpleWriteFileReplacements.ID,
+            name: SimpleWriteFileReplacements.ID,
+            description: metadata.description,
+            parameters: metadata.parameters,
+            handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> =>
+                this.replaceContentInFileFunctionHelper.writeChangesetFromToolCall(args, ctx)
+        };
+    }
+}
+
+@injectable()
+export class SuggestFileReplacements implements ToolProvider {
+    static ID = SUGGEST_FILE_REPLACEMENTS_ID;
     @inject(ReplaceContentInFileFunctionHelper)
     protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
 
     getTool(): ToolRequest {
         const metadata = this.replaceContentInFileFunctionHelper.getToolMetadata(true);
         return {
-            id: ReplaceContentInFileProvider.ID,
-            name: ReplaceContentInFileProvider.ID,
+            id: SuggestFileReplacements.ID,
+            name: SuggestFileReplacements.ID,
             description: metadata.description,
             parameters: metadata.parameters,
             handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> =>
@@ -320,15 +448,34 @@ export class ReplaceContentInFileProvider implements ToolProvider {
 }
 
 @injectable()
-export class ClearFileChangesProvider implements ToolProvider {
-    static ID = 'changeSet_clearFileChanges';
+export class WriteFileReplacements implements ToolProvider {
+    static ID = WRITE_FILE_REPLACEMENTS_ID;
+    @inject(ReplaceContentInFileFunctionHelper)
+    protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
+
+    getTool(): ToolRequest {
+        const metadata = this.replaceContentInFileFunctionHelper.getToolMetadata(true, true);
+        return {
+            id: WriteFileReplacements.ID,
+            name: WriteFileReplacements.ID,
+            description: metadata.description,
+            parameters: metadata.parameters,
+            handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> =>
+                this.replaceContentInFileFunctionHelper.writeChangesetFromToolCall(args, ctx)
+        };
+    }
+}
+
+@injectable()
+export class ClearFileChanges implements ToolProvider {
+    static ID = CLEAR_FILE_CHANGES_ID;
     @inject(ReplaceContentInFileFunctionHelper)
     protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
 
     getTool(): ToolRequest {
         return {
-            id: ClearFileChangesProvider.ID,
-            name: ClearFileChangesProvider.ID,
+            id: ClearFileChanges.ID,
+            name: ClearFileChanges.ID,
             description: 'Clears all pending changes for a specific file, allowing you to start fresh with new modifications.',
             parameters: {
                 type: 'object',
@@ -349,15 +496,15 @@ export class ClearFileChangesProvider implements ToolProvider {
 }
 
 @injectable()
-export class GetProposedFileStateProvider implements ToolProvider {
-    static ID = 'changeSet_getProposedFileState';
+export class GetProposedFileState implements ToolProvider {
+    static ID = GET_PROPOSED_CHANGES_ID;
     @inject(ReplaceContentInFileFunctionHelper)
     protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
 
     getTool(): ToolRequest {
         return {
-            id: GetProposedFileStateProvider.ID,
-            name: GetProposedFileStateProvider.ID,
+            id: GET_PROPOSED_CHANGES_ID,
+            name: GET_PROPOSED_CHANGES_ID,
             description: 'Returns the current proposed state of a file, including all pending changes that have been proposed ' +
                 'but not yet applied. This allows you to inspect the current state before making additional changes.',
             parameters: {

package/src/browser/frontend-module.ts

@@ -14,6 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import '../../src/browser/style/index.css';
+
 import { ContainerModule } from '@theia/core/shared/inversify';
 import { ChatAgent, DefaultChatAgentId, FallbackChatAgentId } from '@theia/ai-chat/lib/common';
 import { Agent, AIVariableContribution, bindToolProvider } from '@theia/ai-core/lib/common';
@@ -26,15 +28,19 @@ import { FrontendApplicationContribution, PreferenceContribution, WidgetFactory,
 import { TaskListProvider, TaskRunnerProvider } from './workspace-task-provider';
 import { WorkspacePreferencesSchema } from './workspace-preferences';
 import {
-    ClearFileChangesProvider,
-    GetProposedFileStateProvider,
+    ClearFileChanges,
+    GetProposedFileState,
     ReplaceContentInFileFunctionHelper,
-    ReplaceContentInFileProvider,
-    SimpleReplaceContentInFileProvider,
-    WriteChangeToFileProvider
+    SuggestFileReplacements,
+    SimpleSuggestFileReplacements,
+    SuggestFileContent,
+    WriteFileContent,
+    WriteFileReplacements,
+    SimpleWriteFileReplacements
 } from './file-changeset-functions';
 import { OrchestratorChatAgent, OrchestratorChatAgentId } from '../common/orchestrator-chat-agent';
 import { UniversalChatAgent, UniversalChatAgentId } from '../common/universal-chat-agent';
+import { AppTesterChatAgent } from './app-tester-chat-agent';
 import { CommandChatAgent } from '../common/command-chat-agents';
 import { ListChatContext, ResolveChatContext, AddFileToChatContext } from './context-functions';
 import { AIAgentConfigurationWidget } from './ai-configuration/agent-configuration-widget';
@@ -43,6 +49,7 @@ import { AIAgentConfigurationViewContribution } from './ai-configuration/ai-conf
 import { AIConfigurationContainerWidget } from './ai-configuration/ai-configuration-widget';
 import { AIVariableConfigurationWidget } from './ai-configuration/variable-configuration-widget';
 import { ContextFilesVariableContribution } from '../common/context-files-variable';
+import { AIToolsConfigurationWidget } from './ai-configuration/tools-configuration-widget';
 import { TabBarToolbarContribution } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { AiConfigurationPreferences } from './ai-configuration/ai-configuration-preferences';
 import { TemplatePreferenceContribution } from './template-preference-contribution';
@@ -75,6 +82,10 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(Agent).toService(UniversalChatAgent);
     bind(ChatAgent).toService(UniversalChatAgent);
 
+    bind(AppTesterChatAgent).toSelf().inSingletonScope();
+    bind(Agent).toService(AppTesterChatAgent);
+    bind(ChatAgent).toService(AppTesterChatAgent);
+
     bind(CommandChatAgent).toSelf().inSingletonScope();
     bind(Agent).toService(CommandChatAgent);
     bind(ChatAgent).toService(CommandChatAgent);
@@ -91,11 +102,13 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(WorkspaceFunctionScope).toSelf().inSingletonScope();
     bindToolProvider(WorkspaceSearchProvider, bind);
 
-    bindToolProvider(WriteChangeToFileProvider, bind);
+    bindToolProvider(SuggestFileContent, bind);
+    bindToolProvider(WriteFileContent, bind);
     bindToolProvider(TaskListProvider, bind);
     bindToolProvider(TaskRunnerProvider, bind);
     bind(ReplaceContentInFileFunctionHelper).toSelf().inSingletonScope();
-    bindToolProvider(ReplaceContentInFileProvider, bind);
+    bindToolProvider(SuggestFileReplacements, bind);
+    bindToolProvider(WriteFileReplacements, bind);
     bindToolProvider(ListChatContext, bind);
     bindToolProvider(ResolveChatContext, bind);
     bind(AIConfigurationSelectionService).toSelf().inSingletonScope();
@@ -126,10 +139,20 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
         }))
         .inSingletonScope();
 
-    bindToolProvider(SimpleReplaceContentInFileProvider, bind);
-    bindToolProvider(ClearFileChangesProvider, bind);
-    bindToolProvider(GetProposedFileStateProvider, bind);
+    bindToolProvider(SimpleSuggestFileReplacements, bind);
+    bindToolProvider(SimpleWriteFileReplacements, bind);
+    bindToolProvider(ClearFileChanges, bind);
+    bindToolProvider(GetProposedFileState, bind);
     bindToolProvider(AddFileToChatContext, bind);
+
+    bind(AIToolsConfigurationWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AIToolsConfigurationWidget.ID,
+            createWidget: () => ctx.container.get(AIToolsConfigurationWidget)
+        }))
+        .inSingletonScope();
+
     bind(AIVariableContribution).to(ContextFilesVariableContribution).inSingletonScope();
     bind(PreferenceContribution).toConstantValue({ schema: AiConfigurationPreferences });