Merge branch 'main' into new_unified

.changeset/tiny-snakes-chew.md

@@ -0,0 +1,5 @@
+---
+"roo-cline": patch
+---
+
+Improvements to fuzzy search in mentions, history, and model lists

.clinerules

@@ -4,21 +4,7 @@
    - Before attempting completion, always make sure that any code changes have test coverage
    - Ensure all tests pass before submitting changes
 
-2. Git Commits:
+2. Lint Rules:
-   - When finishing a task, always output a git commit command
-   - Include a descriptive commit message that follows conventional commit format
-
-3. Documentation:
-   - Update README.md when making significant changes, such as:
-     * Adding new features or settings
-     * Changing existing functionality
-     * Updating system requirements
-     * Adding new dependencies
-   - Include clear descriptions of new features and how to use them
-   - Keep the documentation in sync with the codebase
-   - Add examples where appropriate
-
-4. Lint Rules:
    - Never disable any lint rules without explicit user approval
    - If a lint rule needs to be disabled, ask the user first and explain why
    - Prefer fixing the underlying issue over disabling the lint rule
@@ -26,143 +12,4 @@
 
 # Adding a New Setting
 
-To add a new setting that persists its state, follow these steps:
+To add a new setting that persists its state, follow the steps in cline_docs/settings.md
-
-## For All Settings
-
-1. Add the setting to ExtensionMessage.ts:
-   - Add the setting to the ExtensionState interface
-   - Make it required if it has a default value, optional if it can be undefined
-   - Example: `preferredLanguage: string`
-
-2. Add test coverage:
-   - Add the setting to mockState in ClineProvider.test.ts
-   - Add test cases for setting persistence and state updates
-   - Ensure all tests pass before submitting changes
-
-## For Checkbox Settings
-
-1. Add the message type to WebviewMessage.ts:
-   - Add the setting name to the WebviewMessage type's type union
-   - Example: `| "multisearchDiffEnabled"`
-
-2. Add the setting to ExtensionStateContext.tsx:
-   - Add the setting to the ExtensionStateContextType interface
-   - Add the setter function to the interface
-   - Add the setting to the initial state in useState
-   - Add the setting to the contextValue object
-   - Example:
-     ```typescript
-     interface ExtensionStateContextType {
-       multisearchDiffEnabled: boolean;
-       setMultisearchDiffEnabled: (value: boolean) => void;
-     }
-     ```
-
-3. Add the setting to ClineProvider.ts:
-   - Add the setting name to the GlobalStateKey type union
-   - Add the setting to the Promise.all array in getState
-   - Add the setting to the return value in getState with a default value
-   - Add the setting to the destructured variables in getStateToPostToWebview
-   - Add the setting to the return value in getStateToPostToWebview
-   - Add a case in setWebviewMessageListener to handle the setting's message type
-   - Example:
-     ```typescript
-     case "multisearchDiffEnabled":
-       await this.updateGlobalState("multisearchDiffEnabled", message.bool)
-       await this.postStateToWebview()
-       break
-     ```
-
-4. Add the checkbox UI to SettingsView.tsx:
-   - Import the setting and its setter from ExtensionStateContext
-   - Add the VSCodeCheckbox component with the setting's state and onChange handler
-   - Add appropriate labels and description text
-   - Example:
-     ```typescript
-     <VSCodeCheckbox 
-       checked={multisearchDiffEnabled} 
-       onChange={(e: any) => setMultisearchDiffEnabled(e.target.checked)}
-     >
-       <span style={{ fontWeight: "500" }}>Enable multi-search diff matching</span>
-     </VSCodeCheckbox>
-     ```
-
-5. Add the setting to handleSubmit in SettingsView.tsx:
-   - Add a vscode.postMessage call to send the setting's value when clicking Done
-   - Example:
-     ```typescript
-     vscode.postMessage({ type: "multisearchDiffEnabled", bool: multisearchDiffEnabled })
-     ```
-
-## For Select/Dropdown Settings
-
-1. Add the message type to WebviewMessage.ts:
-   - Add the setting name to the WebviewMessage type's type union
-   - Example: `| "preferredLanguage"`
-
-2. Add the setting to ExtensionStateContext.tsx:
-   - Add the setting to the ExtensionStateContextType interface
-   - Add the setter function to the interface
-   - Add the setting to the initial state in useState with a default value
-   - Add the setting to the contextValue object
-   - Example:
-     ```typescript
-     interface ExtensionStateContextType {
-       preferredLanguage: string;
-       setPreferredLanguage: (value: string) => void;
-     }
-     ```
-
-3. Add the setting to ClineProvider.ts:
-   - Add the setting name to the GlobalStateKey type union
-   - Add the setting to the Promise.all array in getState
-   - Add the setting to the return value in getState with a default value
-   - Add the setting to the destructured variables in getStateToPostToWebview
-   - Add the setting to the return value in getStateToPostToWebview
-   - Add a case in setWebviewMessageListener to handle the setting's message type
-   - Example:
-     ```typescript
-     case "preferredLanguage":
-       await this.updateGlobalState("preferredLanguage", message.text)
-       await this.postStateToWebview()
-       break
-     ```
-
-4. Add the select UI to SettingsView.tsx:
-   - Import the setting and its setter from ExtensionStateContext
-   - Add the select element with appropriate styling to match VSCode's theme
-   - Add options for the dropdown
-   - Add appropriate labels and description text
-   - Example:
-     ```typescript
-     <select
-       value={preferredLanguage}
-       onChange={(e) => setPreferredLanguage(e.target.value)}
-       style={{
-         width: "100%",
-         padding: "4px 8px",
-         backgroundColor: "var(--vscode-input-background)",
-         color: "var(--vscode-input-foreground)",
-         border: "1px solid var(--vscode-input-border)",
-         borderRadius: "2px"
-       }}>
-       <option value="English">English</option>
-       <option value="Spanish">Spanish</option>
-       ...
-     </select>
-     ```
-
-5. Add the setting to handleSubmit in SettingsView.tsx:
-   - Add a vscode.postMessage call to send the setting's value when clicking Done
-   - Example:
-     ```typescript
-     vscode.postMessage({ type: "preferredLanguage", text: preferredLanguage })
-     ```
-
-These steps ensure that:
-- The setting's state is properly typed throughout the application
-- The setting persists between sessions
-- The setting's value is properly synchronized between the webview and extension
-- The setting has a proper UI representation in the settings view
-- Test coverage is maintained for the new setting

.github/workflows/marketplace-publish.yml

@@ -36,7 +36,9 @@ jobs:
       - name: Package and Publish Extension
         env:
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
         run: |
           current_package_version=$(node -p "require('./package.json').version")
           npm run publish:marketplace
           echo "Successfully published version $current_package_version to VS Code Marketplace"
+

.gitignore

@@ -1,7 +1,7 @@
 out
 dist
 node_modules
-.vscode-test/
+coverage/
 
 .DS_Store
 
@@ -14,3 +14,4 @@ roo-cline-*.vsix
 
 # Test environment
 .test_env
+.vscode-test/

CHANGELOG.md

@@ -1,5 +1,38 @@
 # Roo Cline Changelog
 
+## [3.1.1]
+
+-   Visual fixes to chat input and settings for the light+ themes
+
+## [3.1.0]
+
+-   You can now customize the role definition and instructions for each chat mode (Code, Architect, and Ask), either through the new Prompts tab in the top menu or mode-specific .clinerules-mode files. Prompt Enhancements have also been revamped: the "Enhance Prompt" button now works with any provider and API configuration, giving you the ability to craft messages with fully customizable prompts for even better results.
+-   Add a button to copy markdown out of the chat
+
+## [3.0.3]
+
+-   Update required vscode engine to ^1.84.0 to match cline
+
+## [3.0.2]
+
+-   A couple more tiny tweaks to the button alignment in the chat input
+
+## [3.0.1]
+
+-   Fix the reddit link and a small visual glitch in the chat input
+
+## [3.0.0]
+
+-   This release adds chat modes! Now you can ask Roo Cline questions about system architecture or the codebase without immediately jumping into writing code. You can even assign different API configuration profiles to each mode if you prefer to use different models for thinking vs coding. Would love feedback in the new Roo Cline Reddit! https://www.reddit.com/r/roocline
+
+## [2.2.46]
+
+-   Only parse @-mentions in user input (not in files)
+
+## [2.2.45]
+
+-   Save different API configurations to quickly switch between providers and settings (thanks @samhvw8!)
+
 ## [2.2.44]
 
 -   Automatically retry failed API requests with a configurable delay (thanks @RaySinner!)

README.md

@@ -1,16 +1,56 @@
-# Roo-Cline
+# Roo Cline
 
 A fork of Cline, an autonomous coding agent, with some additional experimental features. It’s been mainly writing itself recently, with a light touch of human guidance here and there.
 
+## New in 3.1: Chat Mode Prompt Customization & Prompt Enhancements
+
+Hot off the heels of **v3.0** introducing Code, Architect, and Ask chat modes, one of the most requested features has arrived: **customizable prompts for each mode**! 🎉
+
+You can now tailor the **role definition** and **custom instructions** for every chat mode to perfectly fit your workflow. Want to adjust Architect mode to focus more on system scalability? Or tweak Ask mode for deeper research queries? Done. Plus, you can define these via **mode-specific `.clinerules-[mode]` files**. You’ll find all of this in the new **Prompts** tab in the top menu.
+
+The second big feature in this release is a complete revamp of **prompt enhancements**. This feature helps you craft messages to get even better results from Cline. Here’s what’s new:  
+- Works with **any provider** and API configuration, not just OpenRouter.  
+- Fully customizable prompts to match your unique needs.  
+- Same simple workflow: just hit the ✨ **Enhance Prompt** button in the chat input to try it out.
+
+Whether you’re using GPT-4, other APIs, or switching configurations, this gives you total control over how your prompts are optimized.
+
+As always, we’d love to hear your thoughts and ideas! What features do you want to see in **v3.2**? Drop by https://www.reddit.com/r/roocline and join the discussion - we're building Roo Cline together. 🚀  
+
+## New in 3.0 - Chat Modes!
+
+You can now choose between different prompts for Roo Cline to better suit your workflow. Here’s what’s available:
+
+- **Code:** (existing behavior): The default mode where Cline helps you write code and execute tasks.
+
+- **Architect:** "You are Cline, a software architecture expert..." Ideal for thinking through high-level technical design and system architecture. Can’t write code or run commands.
+
+- **Ask:** "You are Cline, a knowledgeable technical assistant..." Perfect for asking questions about the codebase or digging into concepts. Also can’t write code or run commands.
+
+**Switching Modes:**
+It’s super simple! There’s a dropdown in the bottom left of the chat input to switch modes. Right next to it, you’ll find a way to switch between the API configuration profiles associated with the current mode (configured on the settings screen).
+
+**Why Add This?**
+- It keeps Cline from being overly eager to jump into solving problems when you just want to think or ask questions.
+- Each mode remembers the API configuration you last used with it. For example, you can use more thoughtful models like OpenAI o1 for Architect and Ask, while sticking with Sonnet or DeepSeek for coding tasks.
+- It builds on research suggesting better results when separating "thinking" from "coding," explained well in this very thoughtful [article](https://aider.chat/2024/09/26/architect.html) from aider.
+
+Right now, switching modes is a manual process. In the future, we’d love to give Cline the ability to suggest mode switches based on context. For now, we’d really appreciate your feedback on this feature.
+
+Give it a try and let us know what you think in the reddit: https://www.reddit.com/r/roocline 🚀
+
 ## Experimental Features
 
+- Different chat modes for coding, architecting code, and asking questions about the codebase
 - Drag and drop images into chats
 - Delete messages from chats
 - @-mention Git commits to include their context in the chat
+- Save different API configurations to quickly switch between providers and settings
 - "Enhance prompt" button (OpenRouter models only for now)
 - Sound effects for feedback
 - Option to use browsers of different sizes and adjust screenshot quality
 - Quick prompt copying from history
+- Copy markdown from chat messages
 - OpenRouter compression support
 - Includes current time in the system prompt
 - Uses a file system watcher to more reliably watch for file system changes
@@ -39,7 +79,7 @@ Here's an example of Roo-Cline autonomously creating a snake game with "Always a
 https://github.com/user-attachments/assets/c2bb31dc-e9b2-4d73-885d-17f1471a4987
 
 ## Contributing
-To contribute to the project, start by exploring [open issues](https://github.com/RooVetGit/Roo-Cline/issues) or checking our [feature request board](https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop). We'd also love to have you join our [Discord](https://discord.gg/cline) to share ideas and connect with other contributors.
+To contribute to the project, start by exploring [open issues](https://github.com/RooVetGit/Roo-Cline/issues) or checking our [feature request board](https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop). We'd also love to have you join the [Roo Cline Reddit](https://www.reddit.com/r/roocline/) and the [Cline Discord](https://discord.gg/cline) to share ideas and connect with other contributors.
 
 <details>
 <summary>Local Setup</summary>

cline_docs/settings.md

@@ -0,0 +1,139 @@
+
+## For All Settings
+
+1. Add the setting to ExtensionMessage.ts:
+   - Add the setting to the ExtensionState interface
+   - Make it required if it has a default value, optional if it can be undefined
+   - Example: `preferredLanguage: string`
+
+2. Add test coverage:
+   - Add the setting to mockState in ClineProvider.test.ts
+   - Add test cases for setting persistence and state updates
+   - Ensure all tests pass before submitting changes
+
+## For Checkbox Settings
+
+1. Add the message type to WebviewMessage.ts:
+   - Add the setting name to the WebviewMessage type's type union
+   - Example: `| "multisearchDiffEnabled"`
+
+2. Add the setting to ExtensionStateContext.tsx:
+   - Add the setting to the ExtensionStateContextType interface
+   - Add the setter function to the interface
+   - Add the setting to the initial state in useState
+   - Add the setting to the contextValue object
+   - Example:
+     ```typescript
+     interface ExtensionStateContextType {
+       multisearchDiffEnabled: boolean;
+       setMultisearchDiffEnabled: (value: boolean) => void;
+     }
+     ```
+
+3. Add the setting to ClineProvider.ts:
+   - Add the setting name to the GlobalStateKey type union
+   - Add the setting to the Promise.all array in getState
+   - Add the setting to the return value in getState with a default value
+   - Add the setting to the destructured variables in getStateToPostToWebview
+   - Add the setting to the return value in getStateToPostToWebview
+   - Add a case in setWebviewMessageListener to handle the setting's message type
+   - Example:
+     ```typescript
+     case "multisearchDiffEnabled":
+       await this.updateGlobalState("multisearchDiffEnabled", message.bool)
+       await this.postStateToWebview()
+       break
+     ```
+
+4. Add the checkbox UI to SettingsView.tsx:
+   - Import the setting and its setter from ExtensionStateContext
+   - Add the VSCodeCheckbox component with the setting's state and onChange handler
+   - Add appropriate labels and description text
+   - Example:
+     ```typescript
+     <VSCodeCheckbox 
+       checked={multisearchDiffEnabled} 
+       onChange={(e: any) => setMultisearchDiffEnabled(e.target.checked)}
+     >
+       <span style={{ fontWeight: "500" }}>Enable multi-search diff matching</span>
+     </VSCodeCheckbox>
+     ```
+
+5. Add the setting to handleSubmit in SettingsView.tsx:
+   - Add a vscode.postMessage call to send the setting's value when clicking Done
+   - Example:
+     ```typescript
+     vscode.postMessage({ type: "multisearchDiffEnabled", bool: multisearchDiffEnabled })
+     ```
+
+## For Select/Dropdown Settings
+
+1. Add the message type to WebviewMessage.ts:
+   - Add the setting name to the WebviewMessage type's type union
+   - Example: `| "preferredLanguage"`
+
+2. Add the setting to ExtensionStateContext.tsx:
+   - Add the setting to the ExtensionStateContextType interface
+   - Add the setter function to the interface
+   - Add the setting to the initial state in useState with a default value
+   - Add the setting to the contextValue object
+   - Example:
+     ```typescript
+     interface ExtensionStateContextType {
+       preferredLanguage: string;
+       setPreferredLanguage: (value: string) => void;
+     }
+     ```
+
+3. Add the setting to ClineProvider.ts:
+   - Add the setting name to the GlobalStateKey type union
+   - Add the setting to the Promise.all array in getState
+   - Add the setting to the return value in getState with a default value
+   - Add the setting to the destructured variables in getStateToPostToWebview
+   - Add the setting to the return value in getStateToPostToWebview
+   - Add a case in setWebviewMessageListener to handle the setting's message type
+   - Example:
+     ```typescript
+     case "preferredLanguage":
+       await this.updateGlobalState("preferredLanguage", message.text)
+       await this.postStateToWebview()
+       break
+     ```
+
+4. Add the select UI to SettingsView.tsx:
+   - Import the setting and its setter from ExtensionStateContext
+   - Add the select element with appropriate styling to match VSCode's theme
+   - Add options for the dropdown
+   - Add appropriate labels and description text
+   - Example:
+     ```typescript
+     <select
+       value={preferredLanguage}
+       onChange={(e) => setPreferredLanguage(e.target.value)}
+       style={{
+         width: "100%",
+         padding: "4px 8px",
+         backgroundColor: "var(--vscode-input-background)",
+         color: "var(--vscode-input-foreground)",
+         border: "1px solid var(--vscode-input-border)",
+         borderRadius: "2px"
+       }}>
+       <option value="English">English</option>
+       <option value="Spanish">Spanish</option>
+       ...
+     </select>
+     ```
+
+5. Add the setting to handleSubmit in SettingsView.tsx:
+   - Add a vscode.postMessage call to send the setting's value when clicking Done
+   - Example:
+     ```typescript
+     vscode.postMessage({ type: "preferredLanguage", text: preferredLanguage })
+     ```
+
+These steps ensure that:
+- The setting's state is properly typed throughout the application
+- The setting persists between sessions
+- The setting's value is properly synchronized between the webview and extension
+- The setting has a proper UI representation in the settings view
+- Test coverage is maintained for the new setting

jest.config.js

@@ -10,7 +10,9 @@ module.exports = {
                 "moduleResolution": "node",
                 "esModuleInterop": true,
                 "allowJs": true
-            }
+            },
+            diagnostics: false,
+            isolatedModules: true
         }]
     },
     testMatch: ['**/__tests__/**/*.test.ts'],
@@ -32,11 +34,8 @@ module.exports = {
     modulePathIgnorePatterns: [
         '.vscode-test'
     ],
-    setupFiles: [],
+    reporters: [
-    globals: {
+        ["jest-simple-dot-reporter", {}]
-        'ts-jest': {
+    ],
-            diagnostics: false,
+    setupFiles: []
-            isolatedModules: true
+}
-        }
-    }
-};

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "roo-cline",
-  "version": "2.2.44",
+  "version": "3.1.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "roo-cline",
-      "version": "2.2.44",
+      "version": "3.1.1",
       "dependencies": {
         "@anthropic-ai/bedrock-sdk": "^0.10.2",
         "@anthropic-ai/sdk": "^0.26.0",
@@ -69,13 +69,14 @@
         "eslint": "^8.57.0",
         "husky": "^9.1.7",
         "jest": "^29.7.0",
+        "jest-simple-dot-reporter": "^1.0.5",
         "lint-staged": "^15.2.11",
         "npm-run-all": "^4.1.5",
         "ts-jest": "^29.2.5",
         "typescript": "^5.4.5"
       },
       "engines": {
-        "vscode": "^1.93.1"
+        "vscode": "^1.84.0"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -10964,6 +10965,12 @@
         "node": ">=8"
       }
     },
+    "node_modules/jest-simple-dot-reporter": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/jest-simple-dot-reporter/-/jest-simple-dot-reporter-1.0.5.tgz",
+      "integrity": "sha512-cZLFG/C7k0+WYoIGGuGXKm0vmJiXlWG/m3uCZ4RaMPYxt8lxjdXMLHYkxXaQ7gVWaSPe7uAPCEUcRxthC5xskg==",
+      "dev": true
+    },
     "node_modules/jest-snapshot": {
       "version": "29.7.0",
       "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.7.0.tgz",

package.json

@@ -3,14 +3,14 @@
   "displayName": "Roo Cline",
   "description": "A fork of Cline, an autonomous coding agent, with some added experimental configuration and automation features.",
   "publisher": "RooVeterinaryInc",
-  "version": "2.2.44",
+  "version": "3.1.1",
   "icon": "assets/icons/rocket.png",
   "galleryBanner": {
     "color": "#617A91",
     "theme": "dark"
   },
   "engines": {
-    "vscode": "^1.93.1"
+    "vscode": "^1.84.0"
   },
   "author": {
     "name": "Roo Vet"
@@ -74,6 +74,11 @@
         "title": "MCP Servers",
         "icon": "$(server)"
       },
+      {
+        "command": "roo-cline.promptsButtonClicked",
+        "title": "Prompts",
+        "icon": "$(notebook)"
+      },
       {
         "command": "roo-cline.historyButtonClicked",
         "title": "History",
@@ -103,24 +108,29 @@
           "when": "view == roo-cline.SidebarProvider"
         },
         {
-          "command": "roo-cline.mcpButtonClicked",
+          "command": "roo-cline.promptsButtonClicked",
           "group": "navigation@2",
           "when": "view == roo-cline.SidebarProvider"
         },
         {
-          "command": "roo-cline.historyButtonClicked",
+          "command": "roo-cline.mcpButtonClicked",
           "group": "navigation@3",
           "when": "view == roo-cline.SidebarProvider"
         },
         {
-          "command": "roo-cline.popoutButtonClicked",
+          "command": "roo-cline.historyButtonClicked",
           "group": "navigation@4",
           "when": "view == roo-cline.SidebarProvider"
         },
         {
-          "command": "roo-cline.settingsButtonClicked",
+          "command": "roo-cline.popoutButtonClicked",
           "group": "navigation@5",
           "when": "view == roo-cline.SidebarProvider"
+        },
+        {
+          "command": "roo-cline.settingsButtonClicked",
+          "group": "navigation@6",
+          "when": "view == roo-cline.SidebarProvider"
         }
       ]
     },
@@ -161,7 +171,7 @@
     "test:webview": "cd webview-ui && npm run test",
     "test:extension": "vscode-test",
     "prepare": "husky",
-    "publish:marketplace": "vsce publish",
+    "publish:marketplace": "vsce publish && ovsx publish",
     "publish": "npm run build && changeset publish && npm install --package-lock-only",
     "version-packages": "changeset version && npm install --package-lock-only",
     "vscode:prepublish": "npm run package",
@@ -189,6 +199,7 @@
     "eslint": "^8.57.0",
     "husky": "^9.1.7",
     "jest": "^29.7.0",
+    "jest-simple-dot-reporter": "^1.0.5",
     "lint-staged": "^15.2.11",
     "npm-run-all": "^4.1.5",
     "ts-jest": "^29.2.5",

src/api/providers/__tests__/anthropic.test.ts

@@ -0,0 +1,239 @@
+import { AnthropicHandler } from '../anthropic';
+import { ApiHandlerOptions } from '../../../shared/api';
+import { ApiStream } from '../../transform/stream';
+import { Anthropic } from '@anthropic-ai/sdk';
+
+// Mock Anthropic client
+const mockBetaCreate = jest.fn();
+const mockCreate = jest.fn();
+jest.mock('@anthropic-ai/sdk', () => {
+    return {
+        Anthropic: jest.fn().mockImplementation(() => ({
+            beta: {
+                promptCaching: {
+                    messages: {
+                        create: mockBetaCreate.mockImplementation(async () => ({
+                            async *[Symbol.asyncIterator]() {
+                                yield {
+                                    type: 'message_start',
+                                    message: {
+                                        usage: {
+                                            input_tokens: 100,
+                                            output_tokens: 50,
+                                            cache_creation_input_tokens: 20,
+                                            cache_read_input_tokens: 10
+                                        }
+                                    }
+                                };
+                                yield {
+                                    type: 'content_block_start',
+                                    index: 0,
+                                    content_block: {
+                                        type: 'text',
+                                        text: 'Hello'
+                                    }
+                                };
+                                yield {
+                                    type: 'content_block_delta',
+                                    delta: {
+                                        type: 'text_delta',
+                                        text: ' world'
+                                    }
+                                };
+                            }
+                        }))
+                    }
+                }
+            },
+            messages: {
+                create: mockCreate.mockImplementation(async (options) => {
+                    if (!options.stream) {
+                        return {
+                            id: 'test-completion',
+                            content: [
+                                { type: 'text', text: 'Test response' }
+                            ],
+                            role: 'assistant',
+                            model: options.model,
+                            usage: {
+                                input_tokens: 10,
+                                output_tokens: 5
+                            }
+                        }
+                    }
+                    return {
+                        async *[Symbol.asyncIterator]() {
+                            yield {
+                                type: 'message_start',
+                                message: {
+                                    usage: {
+                                        input_tokens: 10,
+                                        output_tokens: 5
+                                    }
+                                }
+                            }
+                            yield {
+                                type: 'content_block_start',
+                                content_block: {
+                                    type: 'text',
+                                    text: 'Test response'
+                                }
+                            }
+                        }
+                    }
+                })
+            }
+        }))
+    };
+});
+
+describe('AnthropicHandler', () => {
+    let handler: AnthropicHandler;
+    let mockOptions: ApiHandlerOptions;
+
+    beforeEach(() => {
+        mockOptions = {
+            apiKey: 'test-api-key',
+            apiModelId: 'claude-3-5-sonnet-20241022'
+        };
+        handler = new AnthropicHandler(mockOptions);
+        mockBetaCreate.mockClear();
+        mockCreate.mockClear();
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(handler).toBeInstanceOf(AnthropicHandler);
+            expect(handler.getModel().id).toBe(mockOptions.apiModelId);
+        });
+
+        it('should initialize with undefined API key', () => {
+            // The SDK will handle API key validation, so we just verify it initializes
+            const handlerWithoutKey = new AnthropicHandler({
+                ...mockOptions,
+                apiKey: undefined
+            });
+            expect(handlerWithoutKey).toBeInstanceOf(AnthropicHandler);
+        });
+
+        it('should use custom base URL if provided', () => {
+            const customBaseUrl = 'https://custom.anthropic.com';
+            const handlerWithCustomUrl = new AnthropicHandler({
+                ...mockOptions,
+                anthropicBaseUrl: customBaseUrl
+            });
+            expect(handlerWithCustomUrl).toBeInstanceOf(AnthropicHandler);
+        });
+    });
+
+    describe('createMessage', () => {
+        const systemPrompt = 'You are a helpful assistant.';
+        const messages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: [{ 
+                    type: 'text' as const,
+                    text: 'Hello!'
+                }]
+            }
+        ];
+
+        it('should handle prompt caching for supported models', async () => {
+            const stream = handler.createMessage(systemPrompt, [
+                {
+                    role: 'user',
+                    content: [{ type: 'text' as const, text: 'First message' }]
+                },
+                {
+                    role: 'assistant',
+                    content: [{ type: 'text' as const, text: 'Response' }]
+                },
+                {
+                    role: 'user',
+                    content: [{ type: 'text' as const, text: 'Second message' }]
+                }
+            ]);
+
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            // Verify usage information
+            const usageChunk = chunks.find(chunk => chunk.type === 'usage');
+            expect(usageChunk).toBeDefined();
+            expect(usageChunk?.inputTokens).toBe(100);
+            expect(usageChunk?.outputTokens).toBe(50);
+            expect(usageChunk?.cacheWriteTokens).toBe(20);
+            expect(usageChunk?.cacheReadTokens).toBe(10);
+
+            // Verify text content
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
+            expect(textChunks).toHaveLength(2);
+            expect(textChunks[0].text).toBe('Hello');
+            expect(textChunks[1].text).toBe(' world');
+
+            // Verify beta API was used
+            expect(mockBetaCreate).toHaveBeenCalled();
+            expect(mockCreate).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: mockOptions.apiModelId,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                max_tokens: 8192,
+                temperature: 0,
+                stream: false
+            });
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Anthropic completion error: API Error');
+        });
+
+        it('should handle non-text content', async () => {
+            mockCreate.mockImplementationOnce(async () => ({
+                content: [{ type: 'image' }]
+            }));
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+
+        it('should handle empty response', async () => {
+            mockCreate.mockImplementationOnce(async () => ({
+                content: [{ type: 'text', text: '' }]
+            }));
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return default model if no model ID is provided', () => {
+            const handlerWithoutModel = new AnthropicHandler({
+                ...mockOptions,
+                apiModelId: undefined
+            });
+            const model = handlerWithoutModel.getModel();
+            expect(model.id).toBeDefined();
+            expect(model.info).toBeDefined();
+        });
+
+        it('should return specified model if valid model ID is provided', () => {
+            const model = handler.getModel();
+            expect(model.id).toBe(mockOptions.apiModelId);
+            expect(model.info).toBeDefined();
+            expect(model.info.maxTokens).toBe(8192);
+            expect(model.info.contextWindow).toBe(200_000);
+            expect(model.info.supportsImages).toBe(true);
+            expect(model.info.supportsPromptCache).toBe(true);
+        });
+    });
+});

src/api/providers/__tests__/bedrock.test.ts

@@ -1,191 +1,246 @@
-import { AwsBedrockHandler } from '../bedrock'
+import { AwsBedrockHandler } from '../bedrock';
-import { ApiHandlerOptions, ModelInfo } from '../../../shared/api'
+import { MessageContent } from '../../../shared/api';
-import { Anthropic } from '@anthropic-ai/sdk'
+import { BedrockRuntimeClient } from '@aws-sdk/client-bedrock-runtime';
-import { StreamEvent } from '../bedrock'
+import { Anthropic } from '@anthropic-ai/sdk';
-
-// Simplified mock for BedrockRuntimeClient
-class MockBedrockRuntimeClient {
-    private _region: string
-    private mockStream: StreamEvent[] = []
-
-    constructor(config: { region: string }) {
-        this._region = config.region
-    }
-
-    async send(command: any): Promise<{ stream: AsyncIterableIterator<StreamEvent> }> {
-        return {
-            stream: this.createMockStream()
-        }
-    }
-
-    private createMockStream(): AsyncIterableIterator<StreamEvent> {
-        const self = this;
-        return {
-            async *[Symbol.asyncIterator]() {
-                for (const event of self.mockStream) {
-                    yield event;
-                }
-            },
-            next: async () => {
-                const value = this.mockStream.shift();
-                return value ? { value, done: false } : { value: undefined, done: true };
-            },
-            return: async () => ({ value: undefined, done: true }),
-            throw: async (e) => { throw e; }
-        };
-    }
-
-    setMockStream(stream: StreamEvent[]) {
-        this.mockStream = stream;
-    }
-
-    get config() {
-        return { region: this._region };
-    }
-}
 
 describe('AwsBedrockHandler', () => {
-    const mockOptions: ApiHandlerOptions = {
+    let handler: AwsBedrockHandler;
-        awsRegion: 'us-east-1',
-        awsAccessKey: 'mock-access-key',
-        awsSecretKey: 'mock-secret-key',
-        apiModelId: 'anthropic.claude-v2',
-    }
 
-    // Override the BedrockRuntimeClient creation in the constructor
+    beforeEach(() => {
-    class TestAwsBedrockHandler extends AwsBedrockHandler {
+        handler = new AwsBedrockHandler({
-        constructor(options: ApiHandlerOptions, mockClient?: MockBedrockRuntimeClient) {
+            apiModelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-            super(options)
+            awsAccessKey: 'test-access-key',
-            if (mockClient) {
+            awsSecretKey: 'test-secret-key',
-                // Force type casting to bypass strict type checking
+            awsRegion: 'us-east-1'
-                (this as any)['client'] = mockClient
+        });
-            }
+    });
-        }
-    }
 
-    test('constructor initializes with correct AWS credentials', () => {
+    describe('constructor', () => {
-        const mockClient = new MockBedrockRuntimeClient({
+        it('should initialize with provided config', () => {
-            region: 'us-east-1'
+            expect(handler['options'].awsAccessKey).toBe('test-access-key');
-        })
+            expect(handler['options'].awsSecretKey).toBe('test-secret-key');
+            expect(handler['options'].awsRegion).toBe('us-east-1');
+            expect(handler['options'].apiModelId).toBe('anthropic.claude-3-5-sonnet-20241022-v2:0');
+        });
 
-        const handler = new TestAwsBedrockHandler(mockOptions, mockClient)
+        it('should initialize with missing AWS credentials', () => {
+            const handlerWithoutCreds = new AwsBedrockHandler({
+                apiModelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+                awsRegion: 'us-east-1'
+            });
+            expect(handlerWithoutCreds).toBeInstanceOf(AwsBedrockHandler);
+        });
+    });
 
-        // Verify that the client is created with the correct configuration
+    describe('createMessage', () => {
-        expect(handler['client']).toBeDefined()
+        const mockMessages: Anthropic.Messages.MessageParam[] = [
-        expect(handler['client'].config.region).toBe('us-east-1')
-    })
-
-    test('getModel returns correct model info', () => {
-        const mockClient = new MockBedrockRuntimeClient({
-            region: 'us-east-1'
-        })
-
-        const handler = new TestAwsBedrockHandler(mockOptions, mockClient)
-        const result = handler.getModel()
-        
-        expect(result).toEqual({
-            id: 'anthropic.claude-v2',
-            info: {
-                maxTokens: 5000,
-                contextWindow: 128_000,
-                supportsPromptCache: false
-            }
-        })
-    })
-
-    test('createMessage handles successful stream events', async () => {
-        const mockClient = new MockBedrockRuntimeClient({
-            region: 'us-east-1'
-        })
-        
-        // Mock stream events
-        const mockStreamEvents: StreamEvent[] = [
             {
-                metadata: {
+                role: 'user',
-                    usage: {
+                content: 'Hello'
-                        inputTokens: 50,
-                        outputTokens: 100
-                    }
-                }
             },
             {
-                contentBlockStart: {
+                role: 'assistant',
-                    start: {
+                content: 'Hi there!'
-                        text: 'Hello'
-                    }
-                }
-            },
-            {
-                contentBlockDelta: {
-                    delta: {
-                        text: ' world'
-                    }
-                }
-            },
-            {
-                messageStop: {
-                    stopReason: 'end_turn'
-                }
             }
-        ]
+        ];
 
-        mockClient.setMockStream(mockStreamEvents)
+        const systemPrompt = 'You are a helpful assistant';
 
-        const handler = new TestAwsBedrockHandler(mockOptions, mockClient)
+        it('should handle text messages correctly', async () => {
+            const mockResponse = {
+                messages: [{
+                    role: 'assistant',
+                    content: [{ type: 'text', text: 'Hello! How can I help you?' }]
+                }],
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 5
+                }
+            };
 
-        const systemPrompt = 'You are a helpful assistant'
+            // Mock AWS SDK invoke
-        const messages: Anthropic.Messages.MessageParam[] = [
+            const mockStream = {
-            { role: 'user', content: 'Say hello' }
+                [Symbol.asyncIterator]: async function* () {
-        ]
+                    yield {
+                        metadata: {
+                            usage: {
+                                inputTokens: 10,
+                                outputTokens: 5
+                            }
+                        }
+                    };
+                }
+            };
 
-        const generator = handler.createMessage(systemPrompt, messages)
+            const mockInvoke = jest.fn().mockResolvedValue({
-        const chunks = []
+                stream: mockStream
+            });
 
-        for await (const chunk of generator) {
+            handler['client'] = {
-            chunks.push(chunk)
+                send: mockInvoke
-        }
+            } as unknown as BedrockRuntimeClient;
 
-        // Verify the chunks match expected stream events
+            const stream = handler.createMessage(systemPrompt, mockMessages);
-        expect(chunks).toHaveLength(3)
+            const chunks = [];
-        expect(chunks[0]).toEqual({
-            type: 'usage',
-            inputTokens: 50,
-            outputTokens: 100
-        })
-        expect(chunks[1]).toEqual({
-            type: 'text',
-            text: 'Hello'
-        })
-        expect(chunks[2]).toEqual({
-            type: 'text',
-            text: ' world'
-        })
-    })
             
-    test('createMessage handles error scenarios', async () => {
+            for await (const chunk of stream) {
-        const mockClient = new MockBedrockRuntimeClient({
+                chunks.push(chunk);
-            region: 'us-east-1'
-        })
-
-        // Simulate an error by overriding the send method
-        mockClient.send = () => {
-            throw new Error('API request failed')
-        }
-
-        const handler = new TestAwsBedrockHandler(mockOptions, mockClient)
-
-        const systemPrompt = 'You are a helpful assistant'
-        const messages: Anthropic.Messages.MessageParam[] = [
-            { role: 'user', content: 'Cause an error' }
-        ]
-
-        await expect(async () => {
-            const generator = handler.createMessage(systemPrompt, messages)
-            const chunks = []
-            
-            for await (const chunk of generator) {
-                chunks.push(chunk)
             }
-        }).rejects.toThrow('API request failed')
+
-    })
+            expect(chunks.length).toBeGreaterThan(0);
-})
+            expect(chunks[0]).toEqual({
+                type: 'usage',
+                inputTokens: 10,
+                outputTokens: 5
+            });
+
+            expect(mockInvoke).toHaveBeenCalledWith(expect.objectContaining({
+                input: expect.objectContaining({
+                    modelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0'
+                })
+            }));
+        });
+
+        it('should handle API errors', async () => {
+            // Mock AWS SDK invoke with error
+            const mockInvoke = jest.fn().mockRejectedValue(new Error('AWS Bedrock error'));
+
+            handler['client'] = {
+                send: mockInvoke
+            } as unknown as BedrockRuntimeClient;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should throw before yielding any chunks
+                }
+            }).rejects.toThrow('AWS Bedrock error');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const mockResponse = {
+                output: new TextEncoder().encode(JSON.stringify({
+                    content: 'Test response'
+                }))
+            };
+
+            const mockSend = jest.fn().mockResolvedValue(mockResponse);
+            handler['client'] = {
+                send: mockSend
+            } as unknown as BedrockRuntimeClient;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                input: expect.objectContaining({
+                    modelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+                    messages: expect.arrayContaining([
+                        expect.objectContaining({
+                            role: 'user',
+                            content: [{ text: 'Test prompt' }]
+                        })
+                    ]),
+                    inferenceConfig: expect.objectContaining({
+                        maxTokens: 5000,
+                        temperature: 0.3,
+                        topP: 0.1
+                    })
+                })
+            }));
+        });
+
+        it('should handle API errors', async () => {
+            const mockError = new Error('AWS Bedrock error');
+            const mockSend = jest.fn().mockRejectedValue(mockError);
+            handler['client'] = {
+                send: mockSend
+            } as unknown as BedrockRuntimeClient;
+
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Bedrock completion error: AWS Bedrock error');
+        });
+
+        it('should handle invalid response format', async () => {
+            const mockResponse = {
+                output: new TextEncoder().encode('invalid json')
+            };
+
+            const mockSend = jest.fn().mockResolvedValue(mockResponse);
+            handler['client'] = {
+                send: mockSend
+            } as unknown as BedrockRuntimeClient;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+
+        it('should handle empty response', async () => {
+            const mockResponse = {
+                output: new TextEncoder().encode(JSON.stringify({}))
+            };
+
+            const mockSend = jest.fn().mockResolvedValue(mockResponse);
+            handler['client'] = {
+                send: mockSend
+            } as unknown as BedrockRuntimeClient;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+
+        it('should handle cross-region inference', async () => {
+            handler = new AwsBedrockHandler({
+                apiModelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+                awsAccessKey: 'test-access-key',
+                awsSecretKey: 'test-secret-key',
+                awsRegion: 'us-east-1',
+                awsUseCrossRegionInference: true
+            });
+
+            const mockResponse = {
+                output: new TextEncoder().encode(JSON.stringify({
+                    content: 'Test response'
+                }))
+            };
+
+            const mockSend = jest.fn().mockResolvedValue(mockResponse);
+            handler['client'] = {
+                send: mockSend
+            } as unknown as BedrockRuntimeClient;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                input: expect.objectContaining({
+                    modelId: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0'
+                })
+            }));
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return correct model info in test environment', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe('anthropic.claude-3-5-sonnet-20241022-v2:0');
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(5000); // Test environment value
+            expect(modelInfo.info.contextWindow).toBe(128_000); // Test environment value
+        });
+
+        it('should return test model info for invalid model in test environment', () => {
+            const invalidHandler = new AwsBedrockHandler({
+                apiModelId: 'invalid-model',
+                awsAccessKey: 'test-access-key',
+                awsSecretKey: 'test-secret-key',
+                awsRegion: 'us-east-1'
+            });
+            const modelInfo = invalidHandler.getModel();
+            expect(modelInfo.id).toBe('invalid-model'); // In test env, returns whatever is passed
+            expect(modelInfo.info.maxTokens).toBe(5000);
+            expect(modelInfo.info.contextWindow).toBe(128_000);
+        });
+    });
+});

src/api/providers/__tests__/deepseek.test.ts

@@ -1,167 +1,203 @@
-import { DeepSeekHandler } from '../deepseek'
+import { DeepSeekHandler } from '../deepseek';
-import { ApiHandlerOptions } from '../../../shared/api'
+import { ApiHandlerOptions, deepSeekDefaultModelId } from '../../../shared/api';
-import OpenAI from 'openai'
+import OpenAI from 'openai';
-import { Anthropic } from '@anthropic-ai/sdk'
+import { Anthropic } from '@anthropic-ai/sdk';
 
-// Mock dependencies
+// Mock OpenAI client
-jest.mock('openai')
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate.mockImplementation(async (options) => {
+                        if (!options.stream) {
+                            return {
+                                id: 'test-completion',
+                                choices: [{
+                                    message: { role: 'assistant', content: 'Test response', refusal: null },
+                                    finish_reason: 'stop',
+                                    index: 0
+                                }],
+                                usage: {
+                                    prompt_tokens: 10,
+                                    completion_tokens: 5,
+                                    total_tokens: 15
+                                }
+                            };
+                        }
+                        
+                        // Return async iterator for streaming
+                        return {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+                    })
+                }
+            }
+        }))
+    };
+});
 
 describe('DeepSeekHandler', () => {
-
+    let handler: DeepSeekHandler;
-    const mockOptions: ApiHandlerOptions = {
+    let mockOptions: ApiHandlerOptions;
-        deepSeekApiKey: 'test-key',
-        deepSeekModelId: 'deepseek-chat',
-    }
 
     beforeEach(() => {
-        jest.clearAllMocks()
+        mockOptions = {
-    })
+            deepSeekApiKey: 'test-api-key',
+            deepSeekModelId: 'deepseek-chat',
+            deepSeekBaseUrl: 'https://api.deepseek.com/v1'
+        };
+        handler = new DeepSeekHandler(mockOptions);
+        mockCreate.mockClear();
+    });
 
-    test('constructor initializes with correct options', () => {
+    describe('constructor', () => {
-        const handler = new DeepSeekHandler(mockOptions)
+        it('should initialize with provided options', () => {
-        expect(handler).toBeInstanceOf(DeepSeekHandler)
+            expect(handler).toBeInstanceOf(DeepSeekHandler);
-        expect(OpenAI).toHaveBeenCalledWith({
+            expect(handler.getModel().id).toBe(mockOptions.deepSeekModelId);
-            baseURL: 'https://api.deepseek.com/v1',
+        });
-            apiKey: mockOptions.deepSeekApiKey,
-        })
-    })
 
-    test('getModel returns correct model info', () => {
+        it('should throw error if API key is missing', () => {
-        const handler = new DeepSeekHandler(mockOptions)
+            expect(() => {
-        const result = handler.getModel()
+                new DeepSeekHandler({
+                    ...mockOptions,
+                    deepSeekApiKey: undefined
+                });
+            }).toThrow('DeepSeek API key is required');
+        });
 
-        expect(result).toEqual({
+        it('should use default model ID if not provided', () => {
-            id: mockOptions.deepSeekModelId,
+            const handlerWithoutModel = new DeepSeekHandler({
-            info: expect.objectContaining({
+                ...mockOptions,
-                maxTokens: 8192,
+                deepSeekModelId: undefined
-                contextWindow: 64000,
+            });
-                supportsPromptCache: false,
+            expect(handlerWithoutModel.getModel().id).toBe(deepSeekDefaultModelId);
-                supportsImages: false,
+        });
-                inputPrice: 0.014,
-                outputPrice: 0.28,
-            })
-        })
-    })
 
-    test('getModel returns default model info when no model specified', () => {
+        it('should use default base URL if not provided', () => {
-        const handler = new DeepSeekHandler({ deepSeekApiKey: 'test-key' })
+            const handlerWithoutBaseUrl = new DeepSeekHandler({
-        const result = handler.getModel()
+                ...mockOptions,
+                deepSeekBaseUrl: undefined
+            });
+            expect(handlerWithoutBaseUrl).toBeInstanceOf(DeepSeekHandler);
+            // The base URL is passed to OpenAI client internally
+            expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
+                baseURL: 'https://api.deepseek.com/v1'
+            }));
+        });
 
-        expect(result.id).toBe('deepseek-chat')
+        it('should use custom base URL if provided', () => {
-        expect(result.info.maxTokens).toBe(8192)
+            const customBaseUrl = 'https://custom.deepseek.com/v1';
-    })
+            const handlerWithCustomUrl = new DeepSeekHandler({
+                ...mockOptions,
+                deepSeekBaseUrl: customBaseUrl
+            });
+            expect(handlerWithCustomUrl).toBeInstanceOf(DeepSeekHandler);
+            // The custom base URL is passed to OpenAI client
+            expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
+                baseURL: customBaseUrl
+            }));
+        });
 
-    test('createMessage handles string content correctly', async () => {
+        it('should set includeMaxTokens to true', () => {
-        const handler = new DeepSeekHandler(mockOptions)
+            // Create a new handler and verify OpenAI client was called with includeMaxTokens
-        const mockStream = {
+            new DeepSeekHandler(mockOptions);
-            async *[Symbol.asyncIterator]() {
+            expect(OpenAI).toHaveBeenCalledWith(expect.objectContaining({
-                yield {
+                apiKey: mockOptions.deepSeekApiKey
-                    choices: [{
+            }));
-                        delta: {
+        });
-                            content: 'test response'
+    });
-                        }
-                    }]
-                }
-            }
-        }
 
-        const mockCreate = jest.fn().mockResolvedValue(mockStream)
+    describe('getModel', () => {
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
+        it('should return model info for valid model ID', () => {
-            completions: { create: mockCreate }
+            const model = handler.getModel();
-        } as any
+            expect(model.id).toBe(mockOptions.deepSeekModelId);
+            expect(model.info).toBeDefined();
+            expect(model.info.maxTokens).toBe(8192);
+            expect(model.info.contextWindow).toBe(64_000);
+            expect(model.info.supportsImages).toBe(false);
+            expect(model.info.supportsPromptCache).toBe(false);
+        });
 
-        const systemPrompt = 'test system prompt'
+        it('should return provided model ID with default model info if model does not exist', () => {
-        const messages: Anthropic.Messages.MessageParam[] = [
+            const handlerWithInvalidModel = new DeepSeekHandler({
-            { role: 'user', content: 'test message' }
+                ...mockOptions,
-        ]
+                deepSeekModelId: 'invalid-model'
+            });
+            const model = handlerWithInvalidModel.getModel();
+            expect(model.id).toBe('invalid-model'); // Returns provided ID
+            expect(model.info).toBeDefined();
+            expect(model.info).toBe(handler.getModel().info); // But uses default model info
+        });
 
-        const generator = handler.createMessage(systemPrompt, messages)
+        it('should return default model if no model ID is provided', () => {
-        const chunks = []
+            const handlerWithoutModel = new DeepSeekHandler({
+                ...mockOptions,
+                deepSeekModelId: undefined
+            });
+            const model = handlerWithoutModel.getModel();
+            expect(model.id).toBe(deepSeekDefaultModelId);
+            expect(model.info).toBeDefined();
+        });
+    });
 
-        for await (const chunk of generator) {
+    describe('createMessage', () => {
-            chunks.push(chunk)
+        const systemPrompt = 'You are a helpful assistant.';
-        }
-
-        expect(chunks).toHaveLength(1)
-        expect(chunks[0]).toEqual({
-            type: 'text',
-            text: 'test response'
-        })
-
-        expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
-            model: mockOptions.deepSeekModelId,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: 'test message' }
-            ],
-            temperature: 0,
-            stream: true,
-            max_tokens: 8192,
-            stream_options: { include_usage: true }
-        }))
-    })
-
-    test('createMessage handles complex content correctly', async () => {
-        const handler = new DeepSeekHandler(mockOptions)
-        const mockStream = {
-            async *[Symbol.asyncIterator]() {
-                yield {
-                    choices: [{
-                        delta: {
-                            content: 'test response'
-                        }
-                    }]
-                }
-            }
-        }
-
-        const mockCreate = jest.fn().mockResolvedValue(mockStream)
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
-            completions: { create: mockCreate }
-        } as any
-
-        const systemPrompt = 'test system prompt'
         const messages: Anthropic.Messages.MessageParam[] = [
             {
                 role: 'user',
-                content: [
+                content: [{ 
-                    { type: 'text', text: 'part 1' },
+                    type: 'text' as const,
-                    { type: 'text', text: 'part 2' }
+                    text: 'Hello!'
-                ]
+                }]
             }
-        ]
+        ];
 
-        const generator = handler.createMessage(systemPrompt, messages)
+        it('should handle streaming responses', async () => {
-        await generator.next()
+            const stream = handler.createMessage(systemPrompt, messages);
-
+            const chunks: any[] = [];
-        expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+            for await (const chunk of stream) {
-            messages: [
+                chunks.push(chunk);
-                { role: 'system', content: systemPrompt },
-                {
-                    role: 'user',
-                    content: [
-                        { type: 'text', text: 'part 1' },
-                        { type: 'text', text: 'part 2' }
-                    ]
-                }
-            ]
-        }))
-    })
-
-    test('createMessage handles API errors', async () => {
-        const handler = new DeepSeekHandler(mockOptions)
-        const mockStream = {
-            async *[Symbol.asyncIterator]() {
-                throw new Error('API Error')
             }
-        }
 
-        const mockCreate = jest.fn().mockResolvedValue(mockStream)
+            expect(chunks.length).toBeGreaterThan(0);
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
-            completions: { create: mockCreate }
+            expect(textChunks).toHaveLength(1);
-        } as any
+            expect(textChunks[0].text).toBe('Test response');
+        });
 
-        const generator = handler.createMessage('test', [])
+        it('should include usage information', async () => {
-        await expect(generator.next()).rejects.toThrow('API Error')
+            const stream = handler.createMessage(systemPrompt, messages);
-    })
+            const chunks: any[] = [];
-})
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            const usageChunks = chunks.filter(chunk => chunk.type === 'usage');
+            expect(usageChunks.length).toBeGreaterThan(0);
+            expect(usageChunks[0].inputTokens).toBe(10);
+            expect(usageChunks[0].outputTokens).toBe(5);
+        });
+    });
+});

src/api/providers/__tests__/gemini.test.ts

@@ -0,0 +1,212 @@
+import { GeminiHandler } from '../gemini';
+import { Anthropic } from '@anthropic-ai/sdk';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+// Mock the Google Generative AI SDK
+jest.mock('@google/generative-ai', () => ({
+    GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
+        getGenerativeModel: jest.fn().mockReturnValue({
+            generateContentStream: jest.fn(),
+            generateContent: jest.fn().mockResolvedValue({
+                response: {
+                    text: () => 'Test response'
+                }
+            })
+        })
+    }))
+}));
+
+describe('GeminiHandler', () => {
+    let handler: GeminiHandler;
+
+    beforeEach(() => {
+        handler = new GeminiHandler({
+            apiKey: 'test-key',
+            apiModelId: 'gemini-2.0-flash-thinking-exp-1219',
+            geminiApiKey: 'test-key'
+        });
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided config', () => {
+            expect(handler['options'].geminiApiKey).toBe('test-key');
+            expect(handler['options'].apiModelId).toBe('gemini-2.0-flash-thinking-exp-1219');
+        });
+
+        it('should throw if API key is missing', () => {
+            expect(() => {
+                new GeminiHandler({
+                    apiModelId: 'gemini-2.0-flash-thinking-exp-1219',
+                    geminiApiKey: ''
+                });
+            }).toThrow('API key is required for Google Gemini');
+        });
+    });
+
+    describe('createMessage', () => {
+        const mockMessages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello'
+            },
+            {
+                role: 'assistant',
+                content: 'Hi there!'
+            }
+        ];
+
+        const systemPrompt = 'You are a helpful assistant';
+
+        it('should handle text messages correctly', async () => {
+            // Mock the stream response
+            const mockStream = {
+                stream: [
+                    { text: () => 'Hello' },
+                    { text: () => ' world!' }
+                ],
+                response: {
+                    usageMetadata: {
+                        promptTokenCount: 10,
+                        candidatesTokenCount: 5
+                    }
+                }
+            };
+
+            // Setup the mock implementation
+            const mockGenerateContentStream = jest.fn().mockResolvedValue(mockStream);
+            const mockGetGenerativeModel = jest.fn().mockReturnValue({
+                generateContentStream: mockGenerateContentStream
+            });
+
+            (handler['client'] as any).getGenerativeModel = mockGetGenerativeModel;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+            const chunks = [];
+            
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            // Should have 3 chunks: 'Hello', ' world!', and usage info
+            expect(chunks.length).toBe(3);
+            expect(chunks[0]).toEqual({
+                type: 'text',
+                text: 'Hello'
+            });
+            expect(chunks[1]).toEqual({
+                type: 'text',
+                text: ' world!'
+            });
+            expect(chunks[2]).toEqual({
+                type: 'usage',
+                inputTokens: 10,
+                outputTokens: 5
+            });
+
+            // Verify the model configuration
+            expect(mockGetGenerativeModel).toHaveBeenCalledWith({
+                model: 'gemini-2.0-flash-thinking-exp-1219',
+                systemInstruction: systemPrompt
+            });
+
+            // Verify generation config
+            expect(mockGenerateContentStream).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    generationConfig: {
+                        temperature: 0
+                    }
+                })
+            );
+        });
+
+        it('should handle API errors', async () => {
+            const mockError = new Error('Gemini API error');
+            const mockGenerateContentStream = jest.fn().mockRejectedValue(mockError);
+            const mockGetGenerativeModel = jest.fn().mockReturnValue({
+                generateContentStream: mockGenerateContentStream
+            });
+
+            (handler['client'] as any).getGenerativeModel = mockGetGenerativeModel;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should throw before yielding any chunks
+                }
+            }).rejects.toThrow('Gemini API error');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const mockGenerateContent = jest.fn().mockResolvedValue({
+                response: {
+                    text: () => 'Test response'
+                }
+            });
+            const mockGetGenerativeModel = jest.fn().mockReturnValue({
+                generateContent: mockGenerateContent
+            });
+            (handler['client'] as any).getGenerativeModel = mockGetGenerativeModel;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockGetGenerativeModel).toHaveBeenCalledWith({
+                model: 'gemini-2.0-flash-thinking-exp-1219'
+            });
+            expect(mockGenerateContent).toHaveBeenCalledWith({
+                contents: [{ role: 'user', parts: [{ text: 'Test prompt' }] }],
+                generationConfig: {
+                    temperature: 0
+                }
+            });
+        });
+
+        it('should handle API errors', async () => {
+            const mockError = new Error('Gemini API error');
+            const mockGenerateContent = jest.fn().mockRejectedValue(mockError);
+            const mockGetGenerativeModel = jest.fn().mockReturnValue({
+                generateContent: mockGenerateContent
+            });
+            (handler['client'] as any).getGenerativeModel = mockGetGenerativeModel;
+
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Gemini completion error: Gemini API error');
+        });
+
+        it('should handle empty response', async () => {
+            const mockGenerateContent = jest.fn().mockResolvedValue({
+                response: {
+                    text: () => ''
+                }
+            });
+            const mockGetGenerativeModel = jest.fn().mockReturnValue({
+                generateContent: mockGenerateContent
+            });
+            (handler['client'] as any).getGenerativeModel = mockGetGenerativeModel;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return correct model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe('gemini-2.0-flash-thinking-exp-1219');
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(8192);
+            expect(modelInfo.info.contextWindow).toBe(32_767);
+        });
+
+        it('should return default model if invalid model specified', () => {
+            const invalidHandler = new GeminiHandler({
+                apiModelId: 'invalid-model',
+                geminiApiKey: 'test-key'
+            });
+            const modelInfo = invalidHandler.getModel();
+            expect(modelInfo.id).toBe('gemini-2.0-flash-thinking-exp-1219'); // Default model
+        });
+    });
+});

src/api/providers/__tests__/glama.test.ts

@@ -0,0 +1,226 @@
+import { GlamaHandler } from '../glama';
+import { ApiHandlerOptions } from '../../../shared/api';
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
+import axios from 'axios';
+
+// Mock OpenAI client
+const mockCreate = jest.fn();
+const mockWithResponse = jest.fn();
+
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: (...args: any[]) => {
+                        const stream = {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+
+                        const result = mockCreate(...args);
+                        if (args[0].stream) {
+                            mockWithResponse.mockReturnValue(Promise.resolve({
+                                data: stream,
+                                response: {
+                                    headers: {
+                                        get: (name: string) => name === 'x-completion-request-id' ? 'test-request-id' : null
+                                    }
+                                }
+                            }));
+                            result.withResponse = mockWithResponse;
+                        }
+                        return result;
+                    }
+                }
+            }
+        }))
+    };
+});
+
+describe('GlamaHandler', () => {
+    let handler: GlamaHandler;
+    let mockOptions: ApiHandlerOptions;
+
+    beforeEach(() => {
+        mockOptions = {
+            apiModelId: 'anthropic/claude-3-5-sonnet',
+            glamaModelId: 'anthropic/claude-3-5-sonnet',
+            glamaApiKey: 'test-api-key'
+        };
+        handler = new GlamaHandler(mockOptions);
+        mockCreate.mockClear();
+        mockWithResponse.mockClear();
+
+        // Default mock implementation for non-streaming responses
+        mockCreate.mockResolvedValue({
+            id: 'test-completion',
+            choices: [{
+                message: { role: 'assistant', content: 'Test response' },
+                finish_reason: 'stop',
+                index: 0
+            }],
+            usage: {
+                prompt_tokens: 10,
+                completion_tokens: 5,
+                total_tokens: 15
+            }
+        });
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(handler).toBeInstanceOf(GlamaHandler);
+            expect(handler.getModel().id).toBe(mockOptions.apiModelId);
+        });
+    });
+
+    describe('createMessage', () => {
+        const systemPrompt = 'You are a helpful assistant.';
+        const messages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello!'
+            }
+        ];
+
+        it('should handle streaming responses', async () => {
+            // Mock axios for token usage request
+            const mockAxios = jest.spyOn(axios, 'get').mockResolvedValueOnce({
+                data: {
+                    tokenUsage: {
+                        promptTokens: 10,
+                        completionTokens: 5,
+                        cacheCreationInputTokens: 0,
+                        cacheReadInputTokens: 0
+                    },
+                    totalCostUsd: "0.00"
+                }
+            });
+
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBe(2); // Text chunk and usage chunk
+            expect(chunks[0]).toEqual({
+                type: 'text',
+                text: 'Test response'
+            });
+            expect(chunks[1]).toEqual({
+                type: 'usage',
+                inputTokens: 10,
+                outputTokens: 5,
+                cacheWriteTokens: 0,
+                cacheReadTokens: 0,
+                totalCost: 0
+            });
+
+            mockAxios.mockRestore();
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockImplementationOnce(() => {
+                throw new Error('API Error');
+            });
+
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks = [];
+
+            try {
+                for await (const chunk of stream) {
+                    chunks.push(chunk);
+                }
+                fail('Expected error to be thrown');
+            } catch (error) {
+                expect(error).toBeInstanceOf(Error);
+                expect(error.message).toBe('API Error');
+            }
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                model: mockOptions.apiModelId,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0,
+                max_tokens: 8192
+            }));
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Glama completion error: API Error');
+        });
+
+        it('should handle empty response', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [{ message: { content: '' } }]
+            });
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+
+        it('should not set max_tokens for non-Anthropic models', async () => {
+            // Reset mock to clear any previous calls
+            mockCreate.mockClear();
+            
+            const nonAnthropicOptions = {
+                apiModelId: 'openai/gpt-4',
+                glamaModelId: 'openai/gpt-4',
+                glamaApiKey: 'test-key',
+                glamaModelInfo: {
+                    maxTokens: 4096,
+                    contextWindow: 8192,
+                    supportsImages: true,
+                    supportsPromptCache: false
+                }
+            };
+            const nonAnthropicHandler = new GlamaHandler(nonAnthropicOptions);
+
+            await nonAnthropicHandler.completePrompt('Test prompt');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'openai/gpt-4',
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0
+            }));
+            expect(mockCreate.mock.calls[0][0]).not.toHaveProperty('max_tokens');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe(mockOptions.apiModelId);
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(8192);
+            expect(modelInfo.info.contextWindow).toBe(200_000);
+        });
+    });
+});

src/api/providers/__tests__/lmstudio.test.ts

@@ -0,0 +1,160 @@
+import { LmStudioHandler } from '../lmstudio';
+import { ApiHandlerOptions } from '../../../shared/api';
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
+
+// Mock OpenAI client
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate.mockImplementation(async (options) => {
+                        if (!options.stream) {
+                            return {
+                                id: 'test-completion',
+                                choices: [{
+                                    message: { role: 'assistant', content: 'Test response' },
+                                    finish_reason: 'stop',
+                                    index: 0
+                                }],
+                                usage: {
+                                    prompt_tokens: 10,
+                                    completion_tokens: 5,
+                                    total_tokens: 15
+                                }
+                            };
+                        }
+                        
+                        return {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+                    })
+                }
+            }
+        }))
+    };
+});
+
+describe('LmStudioHandler', () => {
+    let handler: LmStudioHandler;
+    let mockOptions: ApiHandlerOptions;
+
+    beforeEach(() => {
+        mockOptions = {
+            apiModelId: 'local-model',
+            lmStudioModelId: 'local-model',
+            lmStudioBaseUrl: 'http://localhost:1234/v1'
+        };
+        handler = new LmStudioHandler(mockOptions);
+        mockCreate.mockClear();
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(handler).toBeInstanceOf(LmStudioHandler);
+            expect(handler.getModel().id).toBe(mockOptions.lmStudioModelId);
+        });
+
+        it('should use default base URL if not provided', () => {
+            const handlerWithoutUrl = new LmStudioHandler({
+                apiModelId: 'local-model',
+                lmStudioModelId: 'local-model'
+            });
+            expect(handlerWithoutUrl).toBeInstanceOf(LmStudioHandler);
+        });
+    });
+
+    describe('createMessage', () => {
+        const systemPrompt = 'You are a helpful assistant.';
+        const messages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello!'
+            }
+        ];
+
+        it('should handle streaming responses', async () => {
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBeGreaterThan(0);
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
+            expect(textChunks).toHaveLength(1);
+            expect(textChunks[0].text).toBe('Test response');
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+
+            const stream = handler.createMessage(systemPrompt, messages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should not reach here
+                }
+            }).rejects.toThrow('Please check the LM Studio developer logs to debug what went wrong');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: mockOptions.lmStudioModelId,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0,
+                stream: false
+            });
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Please check the LM Studio developer logs to debug what went wrong');
+        });
+
+        it('should handle empty response', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [{ message: { content: '' } }]
+            });
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe(mockOptions.lmStudioModelId);
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(-1);
+            expect(modelInfo.info.contextWindow).toBe(128_000);
+        });
+    });
+});

src/api/providers/__tests__/ollama.test.ts

@@ -0,0 +1,160 @@
+import { OllamaHandler } from '../ollama';
+import { ApiHandlerOptions } from '../../../shared/api';
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
+
+// Mock OpenAI client
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate.mockImplementation(async (options) => {
+                        if (!options.stream) {
+                            return {
+                                id: 'test-completion',
+                                choices: [{
+                                    message: { role: 'assistant', content: 'Test response' },
+                                    finish_reason: 'stop',
+                                    index: 0
+                                }],
+                                usage: {
+                                    prompt_tokens: 10,
+                                    completion_tokens: 5,
+                                    total_tokens: 15
+                                }
+                            };
+                        }
+                        
+                        return {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+                    })
+                }
+            }
+        }))
+    };
+});
+
+describe('OllamaHandler', () => {
+    let handler: OllamaHandler;
+    let mockOptions: ApiHandlerOptions;
+
+    beforeEach(() => {
+        mockOptions = {
+            apiModelId: 'llama2',
+            ollamaModelId: 'llama2',
+            ollamaBaseUrl: 'http://localhost:11434/v1'
+        };
+        handler = new OllamaHandler(mockOptions);
+        mockCreate.mockClear();
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(handler).toBeInstanceOf(OllamaHandler);
+            expect(handler.getModel().id).toBe(mockOptions.ollamaModelId);
+        });
+
+        it('should use default base URL if not provided', () => {
+            const handlerWithoutUrl = new OllamaHandler({
+                apiModelId: 'llama2',
+                ollamaModelId: 'llama2'
+            });
+            expect(handlerWithoutUrl).toBeInstanceOf(OllamaHandler);
+        });
+    });
+
+    describe('createMessage', () => {
+        const systemPrompt = 'You are a helpful assistant.';
+        const messages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello!'
+            }
+        ];
+
+        it('should handle streaming responses', async () => {
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBeGreaterThan(0);
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
+            expect(textChunks).toHaveLength(1);
+            expect(textChunks[0].text).toBe('Test response');
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+
+            const stream = handler.createMessage(systemPrompt, messages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should not reach here
+                }
+            }).rejects.toThrow('API Error');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: mockOptions.ollamaModelId,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0,
+                stream: false
+            });
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Ollama completion error: API Error');
+        });
+
+        it('should handle empty response', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [{ message: { content: '' } }]
+            });
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe(mockOptions.ollamaModelId);
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(-1);
+            expect(modelInfo.info.contextWindow).toBe(128_000);
+        });
+    });
+});

src/api/providers/__tests__/openai-native.test.ts

@@ -0,0 +1,209 @@
+import { OpenAiNativeHandler } from '../openai-native';
+import { ApiHandlerOptions } from '../../../shared/api';
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
+
+// Mock OpenAI client
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate.mockImplementation(async (options) => {
+                        if (!options.stream) {
+                            return {
+                                id: 'test-completion',
+                                choices: [{
+                                    message: { role: 'assistant', content: 'Test response' },
+                                    finish_reason: 'stop',
+                                    index: 0
+                                }],
+                                usage: {
+                                    prompt_tokens: 10,
+                                    completion_tokens: 5,
+                                    total_tokens: 15
+                                }
+                            };
+                        }
+                        
+                        return {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+                    })
+                }
+            }
+        }))
+    };
+});
+
+describe('OpenAiNativeHandler', () => {
+    let handler: OpenAiNativeHandler;
+    let mockOptions: ApiHandlerOptions;
+
+    beforeEach(() => {
+        mockOptions = {
+            apiModelId: 'gpt-4o',
+            openAiNativeApiKey: 'test-api-key'
+        };
+        handler = new OpenAiNativeHandler(mockOptions);
+        mockCreate.mockClear();
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided options', () => {
+            expect(handler).toBeInstanceOf(OpenAiNativeHandler);
+            expect(handler.getModel().id).toBe(mockOptions.apiModelId);
+        });
+
+        it('should initialize with empty API key', () => {
+            const handlerWithoutKey = new OpenAiNativeHandler({
+                apiModelId: 'gpt-4o',
+                openAiNativeApiKey: ''
+            });
+            expect(handlerWithoutKey).toBeInstanceOf(OpenAiNativeHandler);
+        });
+    });
+
+    describe('createMessage', () => {
+        const systemPrompt = 'You are a helpful assistant.';
+        const messages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello!'
+            }
+        ];
+
+        it('should handle streaming responses', async () => {
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBeGreaterThan(0);
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
+            expect(textChunks).toHaveLength(1);
+            expect(textChunks[0].text).toBe('Test response');
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+
+            const stream = handler.createMessage(systemPrompt, messages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should not reach here
+                }
+            }).rejects.toThrow('API Error');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully with gpt-4o model', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'gpt-4o',
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0
+            });
+        });
+
+        it('should complete prompt successfully with o1 model', async () => {
+            handler = new OpenAiNativeHandler({
+                apiModelId: 'o1',
+                openAiNativeApiKey: 'test-api-key'
+            });
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'o1',
+                messages: [{ role: 'user', content: 'Test prompt' }]
+            });
+        });
+
+        it('should complete prompt successfully with o1-preview model', async () => {
+            handler = new OpenAiNativeHandler({
+                apiModelId: 'o1-preview',
+                openAiNativeApiKey: 'test-api-key'
+            });
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'o1-preview',
+                messages: [{ role: 'user', content: 'Test prompt' }]
+            });
+        });
+
+        it('should complete prompt successfully with o1-mini model', async () => {
+            handler = new OpenAiNativeHandler({
+                apiModelId: 'o1-mini',
+                openAiNativeApiKey: 'test-api-key'
+            });
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'o1-mini',
+                messages: [{ role: 'user', content: 'Test prompt' }]
+            });
+        });
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('OpenAI Native completion error: API Error');
+        });
+
+        it('should handle empty response', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [{ message: { content: '' } }]
+            });
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe(mockOptions.apiModelId);
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(4096);
+            expect(modelInfo.info.contextWindow).toBe(128_000);
+        });
+
+        it('should handle undefined model ID', () => {
+            const handlerWithoutModel = new OpenAiNativeHandler({
+                openAiNativeApiKey: 'test-api-key'
+            });
+            const modelInfo = handlerWithoutModel.getModel();
+            expect(modelInfo.id).toBe('gpt-4o'); // Default model
+            expect(modelInfo.info).toBeDefined();
+        });
+    });
+});

src/api/providers/__tests__/openai.test.ts

@@ -1,192 +1,224 @@
-import { OpenAiHandler } from '../openai'
+import { OpenAiHandler } from '../openai';
-import { ApiHandlerOptions, openAiModelInfoSaneDefaults } from '../../../shared/api'
+import { ApiHandlerOptions } from '../../../shared/api';
-import OpenAI, { AzureOpenAI } from 'openai'
+import { ApiStream } from '../../transform/stream';
-import { Anthropic } from '@anthropic-ai/sdk'
+import OpenAI from 'openai';
+import { Anthropic } from '@anthropic-ai/sdk';
 
-// Mock dependencies
+// Mock OpenAI client
-jest.mock('openai')
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate.mockImplementation(async (options) => {
+                        if (!options.stream) {
+                            return {
+                                id: 'test-completion',
+                                choices: [{
+                                    message: { role: 'assistant', content: 'Test response', refusal: null },
+                                    finish_reason: 'stop',
+                                    index: 0
+                                }],
+                                usage: {
+                                    prompt_tokens: 10,
+                                    completion_tokens: 5,
+                                    total_tokens: 15
+                                }
+                            };
+                        }
+                        
+                        return {
+                            [Symbol.asyncIterator]: async function* () {
+                                yield {
+                                    choices: [{
+                                        delta: { content: 'Test response' },
+                                        index: 0
+                                    }],
+                                    usage: null
+                                };
+                                yield {
+                                    choices: [{
+                                        delta: {},
+                                        index: 0
+                                    }],
+                                    usage: {
+                                        prompt_tokens: 10,
+                                        completion_tokens: 5,
+                                        total_tokens: 15
+                                    }
+                                };
+                            }
+                        };
+                    })
+                }
+            }
+        }))
+    };
+});
 
 describe('OpenAiHandler', () => {
-    const mockOptions: ApiHandlerOptions = {
+    let handler: OpenAiHandler;
-        openAiApiKey: 'test-key',
+    let mockOptions: ApiHandlerOptions;
-        openAiModelId: 'gpt-4',
-        openAiStreamingEnabled: true,
-        openAiBaseUrl: 'https://api.openai.com/v1'
-    }
 
     beforeEach(() => {
-        jest.clearAllMocks()
+        mockOptions = {
-    })
+            openAiApiKey: 'test-api-key',
+            openAiModelId: 'gpt-4',
+            openAiBaseUrl: 'https://api.openai.com/v1'
+        };
+        handler = new OpenAiHandler(mockOptions);
+        mockCreate.mockClear();
+    });
 
-    test('constructor initializes with correct options', () => {
+    describe('constructor', () => {
-        const handler = new OpenAiHandler(mockOptions)
+        it('should initialize with provided options', () => {
-        expect(handler).toBeInstanceOf(OpenAiHandler)
+            expect(handler).toBeInstanceOf(OpenAiHandler);
-        expect(OpenAI).toHaveBeenCalledWith({
+            expect(handler.getModel().id).toBe(mockOptions.openAiModelId);
-            apiKey: mockOptions.openAiApiKey,
+        });
-            baseURL: mockOptions.openAiBaseUrl
-        })
-    })
 
-    test('constructor initializes Azure client when Azure URL is provided', () => {
+        it('should use custom base URL if provided', () => {
-        const azureOptions: ApiHandlerOptions = {
+            const customBaseUrl = 'https://custom.openai.com/v1';
-            ...mockOptions,
+            const handlerWithCustomUrl = new OpenAiHandler({
-            openAiBaseUrl: 'https://example.azure.com',
+                ...mockOptions,
-            azureApiVersion: '2023-05-15'
+                openAiBaseUrl: customBaseUrl
-        }
+            });
-        const handler = new OpenAiHandler(azureOptions)
+            expect(handlerWithCustomUrl).toBeInstanceOf(OpenAiHandler);
-        expect(handler).toBeInstanceOf(OpenAiHandler)
+        });
-        expect(AzureOpenAI).toHaveBeenCalledWith({
+    });
-            baseURL: azureOptions.openAiBaseUrl,
-            apiKey: azureOptions.openAiApiKey,
-            apiVersion: azureOptions.azureApiVersion
-        })
-    })
 
-    test('getModel returns correct model info', () => {
+    describe('createMessage', () => {
-        const handler = new OpenAiHandler(mockOptions)
+        const systemPrompt = 'You are a helpful assistant.';
-        const result = handler.getModel()
-        
-        expect(result).toEqual({
-            id: mockOptions.openAiModelId,
-            info: openAiModelInfoSaneDefaults
-        })
-    })
-
-    test('createMessage handles streaming correctly when enabled', async () => {
-        const handler = new OpenAiHandler({
-            ...mockOptions,
-            openAiStreamingEnabled: true,
-            includeMaxTokens: true
-        })
-        
-        const mockStream = {
-            async *[Symbol.asyncIterator]() {
-                yield {
-                    choices: [{
-                        delta: {
-                            content: 'test response'
-                        }
-                    }],
-                    usage: {
-                        prompt_tokens: 10,
-                        completion_tokens: 5
-                    }
-                }
-            }
-        }
-
-        const mockCreate = jest.fn().mockResolvedValue(mockStream)
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
-            completions: { create: mockCreate }
-        } as any
-
-        const systemPrompt = 'test system prompt'
         const messages: Anthropic.Messages.MessageParam[] = [
-            { role: 'user', content: 'test message' }
-        ]
-
-        const generator = handler.createMessage(systemPrompt, messages)
-        const chunks = []
-        
-        for await (const chunk of generator) {
-            chunks.push(chunk)
-        }
-
-        expect(chunks).toEqual([
             {
-                type: 'text',
+                role: 'user',
-                text: 'test response'
+                content: [{ 
-            },
+                    type: 'text' as const,
-            {
+                    text: 'Hello!'
-                type: 'usage',
+                }]
-                inputTokens: 10,
-                outputTokens: 5
             }
-        ])
+        ];
 
-        expect(mockCreate).toHaveBeenCalledWith({
+        it('should handle non-streaming mode', async () => {
-            model: mockOptions.openAiModelId,
+            const handler = new OpenAiHandler({
-            messages: [
+                ...mockOptions,
-                { role: 'system', content: systemPrompt },
+                openAiStreamingEnabled: false
-                { role: 'user', content: 'test message' }
+            });
-            ],
-            temperature: 0,
-            stream: true,
-            stream_options: { include_usage: true },
-            max_tokens: openAiModelInfoSaneDefaults.maxTokens
-        })
-    })
 
-    test('createMessage handles non-streaming correctly when disabled', async () => {
+            const stream = handler.createMessage(systemPrompt, messages);
-        const handler = new OpenAiHandler({
+            const chunks: any[] = [];
-            ...mockOptions,
+            for await (const chunk of stream) {
-            openAiStreamingEnabled: false
+                chunks.push(chunk);
-        })
+            }
 
-        const mockResponse = {
+            expect(chunks.length).toBeGreaterThan(0);
-            choices: [{
+            const textChunk = chunks.find(chunk => chunk.type === 'text');
-                message: {
+            const usageChunk = chunks.find(chunk => chunk.type === 'usage');
-                    content: 'test response'
+            
+            expect(textChunk).toBeDefined();
+            expect(textChunk?.text).toBe('Test response');
+            expect(usageChunk).toBeDefined();
+            expect(usageChunk?.inputTokens).toBe(10);
+            expect(usageChunk?.outputTokens).toBe(5);
+        });
+
+        it('should handle streaming responses', async () => {
+            const stream = handler.createMessage(systemPrompt, messages);
+            const chunks: any[] = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBeGreaterThan(0);
+            const textChunks = chunks.filter(chunk => chunk.type === 'text');
+            expect(textChunks).toHaveLength(1);
+            expect(textChunks[0].text).toBe('Test response');
+        });
+    });
+
+    describe('error handling', () => {
+        const testMessages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: [{ 
+                    type: 'text' as const,
+                    text: 'Hello'
+                }]
+            }
+        ];
+
+        it('should handle API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+
+            const stream = handler.createMessage('system prompt', testMessages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should not reach here
                 }
-            }],
+            }).rejects.toThrow('API Error');
-            usage: {
+        });
-                prompt_tokens: 10,
-                completion_tokens: 5
-            }
-        }
 
-        const mockCreate = jest.fn().mockResolvedValue(mockResponse)
+        it('should handle rate limiting', async () => {
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
+            const rateLimitError = new Error('Rate limit exceeded');
-            completions: { create: mockCreate }
+            rateLimitError.name = 'Error';
-        } as any
+            (rateLimitError as any).status = 429;
+            mockCreate.mockRejectedValueOnce(rateLimitError);
 
-        const systemPrompt = 'test system prompt'
+            const stream = handler.createMessage('system prompt', testMessages);
-        const messages: Anthropic.Messages.MessageParam[] = [
-            { role: 'user', content: 'test message' }
-        ]
 
-        const generator = handler.createMessage(systemPrompt, messages)
+            await expect(async () => {
-        const chunks = []
+                for await (const chunk of stream) {
+                    // Should not reach here
+                }
+            }).rejects.toThrow('Rate limit exceeded');
+        });
+    });
 
-        for await (const chunk of generator) {
+    describe('completePrompt', () => {
-            chunks.push(chunk)
+        it('should complete prompt successfully', async () => {
-        }
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: mockOptions.openAiModelId,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                temperature: 0
+            });
+        });
 
-        expect(chunks).toEqual([
+        it('should handle API errors', async () => {
-            {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
-                type: 'text',
+            await expect(handler.completePrompt('Test prompt'))
-                text: 'test response'
+                .rejects.toThrow('OpenAI completion error: API Error');
-            },
+        });
-            {
-                type: 'usage',
-                inputTokens: 10,
-                outputTokens: 5
-            }
-        ])
 
-        expect(mockCreate).toHaveBeenCalledWith({
+        it('should handle empty response', async () => {
-            model: mockOptions.openAiModelId,
+            mockCreate.mockImplementationOnce(() => ({
-            messages: [
+                choices: [{ message: { content: '' } }]
-                { role: 'user', content: systemPrompt },
+            }));
-                { role: 'user', content: 'test message' }
+            const result = await handler.completePrompt('Test prompt');
-            ]
+            expect(result).toBe('');
-        })
+        });
-    })
+    });
 
-    test('createMessage handles API errors', async () => {
+    describe('getModel', () => {
-        const handler = new OpenAiHandler(mockOptions)
+        it('should return model info with sane defaults', () => {
-        const mockStream = {
+            const model = handler.getModel();
-            async *[Symbol.asyncIterator]() {
+            expect(model.id).toBe(mockOptions.openAiModelId);
-                throw new Error('API Error')
+            expect(model.info).toBeDefined();
-            }
+            expect(model.info.contextWindow).toBe(128_000);
-        }
+            expect(model.info.supportsImages).toBe(true);
+        });
 
-        const mockCreate = jest.fn().mockResolvedValue(mockStream)
+        it('should handle undefined model ID', () => {
-        ;(OpenAI as jest.MockedClass<typeof OpenAI>).prototype.chat = {
+            const handlerWithoutModel = new OpenAiHandler({
-            completions: { create: mockCreate }
+                ...mockOptions,
-        } as any
+                openAiModelId: undefined
-
+            });
-        const generator = handler.createMessage('test', [])
+            const model = handlerWithoutModel.getModel();
-        await expect(generator.next()).rejects.toThrow('API Error')
+            expect(model.id).toBe('');
-    })
+            expect(model.info).toBeDefined();
-})
+        });
+    });
+});

src/api/providers/__tests__/vertex.test.ts

@@ -0,0 +1,296 @@
+import { VertexHandler } from '../vertex';
+import { Anthropic } from '@anthropic-ai/sdk';
+import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
+
+// Mock Vertex SDK
+jest.mock('@anthropic-ai/vertex-sdk', () => ({
+    AnthropicVertex: jest.fn().mockImplementation(() => ({
+        messages: {
+            create: jest.fn().mockImplementation(async (options) => {
+                if (!options.stream) {
+                    return {
+                        id: 'test-completion',
+                        content: [
+                            { type: 'text', text: 'Test response' }
+                        ],
+                        role: 'assistant',
+                        model: options.model,
+                        usage: {
+                            input_tokens: 10,
+                            output_tokens: 5
+                        }
+                    }
+                }
+                return {
+                    async *[Symbol.asyncIterator]() {
+                        yield {
+                            type: 'message_start',
+                            message: {
+                                usage: {
+                                    input_tokens: 10,
+                                    output_tokens: 5
+                                }
+                            }
+                        }
+                        yield {
+                            type: 'content_block_start',
+                            content_block: {
+                                type: 'text',
+                                text: 'Test response'
+                            }
+                        }
+                    }
+                }
+            })
+        }
+    }))
+}));
+
+describe('VertexHandler', () => {
+    let handler: VertexHandler;
+
+    beforeEach(() => {
+        handler = new VertexHandler({
+            apiModelId: 'claude-3-5-sonnet-v2@20241022',
+            vertexProjectId: 'test-project',
+            vertexRegion: 'us-central1'
+        });
+    });
+
+    describe('constructor', () => {
+        it('should initialize with provided config', () => {
+            expect(AnthropicVertex).toHaveBeenCalledWith({
+                projectId: 'test-project',
+                region: 'us-central1'
+            });
+        });
+    });
+
+    describe('createMessage', () => {
+        const mockMessages: Anthropic.Messages.MessageParam[] = [
+            {
+                role: 'user',
+                content: 'Hello'
+            },
+            {
+                role: 'assistant',
+                content: 'Hi there!'
+            }
+        ];
+
+        const systemPrompt = 'You are a helpful assistant';
+
+        it('should handle streaming responses correctly', async () => {
+            const mockStream = [
+                {
+                    type: 'message_start',
+                    message: {
+                        usage: {
+                            input_tokens: 10,
+                            output_tokens: 0
+                        }
+                    }
+                },
+                {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'text',
+                        text: 'Hello'
+                    }
+                },
+                {
+                    type: 'content_block_delta',
+                    delta: {
+                        type: 'text_delta',
+                        text: ' world!'
+                    }
+                },
+                {
+                    type: 'message_delta',
+                    usage: {
+                        output_tokens: 5
+                    }
+                }
+            ];
+
+            // Setup async iterator for mock stream
+            const asyncIterator = {
+                async *[Symbol.asyncIterator]() {
+                    for (const chunk of mockStream) {
+                        yield chunk;
+                    }
+                }
+            };
+
+            const mockCreate = jest.fn().mockResolvedValue(asyncIterator);
+            (handler['client'].messages as any).create = mockCreate;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+            const chunks = [];
+            
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBe(4);
+            expect(chunks[0]).toEqual({
+                type: 'usage',
+                inputTokens: 10,
+                outputTokens: 0
+            });
+            expect(chunks[1]).toEqual({
+                type: 'text',
+                text: 'Hello'
+            });
+            expect(chunks[2]).toEqual({
+                type: 'text',
+                text: ' world!'
+            });
+            expect(chunks[3]).toEqual({
+                type: 'usage',
+                inputTokens: 0,
+                outputTokens: 5
+            });
+
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'claude-3-5-sonnet-v2@20241022',
+                max_tokens: 8192,
+                temperature: 0,
+                system: systemPrompt,
+                messages: mockMessages,
+                stream: true
+            });
+        });
+
+        it('should handle multiple content blocks with line breaks', async () => {
+            const mockStream = [
+                {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'text',
+                        text: 'First line'
+                    }
+                },
+                {
+                    type: 'content_block_start',
+                    index: 1,
+                    content_block: {
+                        type: 'text',
+                        text: 'Second line'
+                    }
+                }
+            ];
+
+            const asyncIterator = {
+                async *[Symbol.asyncIterator]() {
+                    for (const chunk of mockStream) {
+                        yield chunk;
+                    }
+                }
+            };
+
+            const mockCreate = jest.fn().mockResolvedValue(asyncIterator);
+            (handler['client'].messages as any).create = mockCreate;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+            const chunks = [];
+            
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+
+            expect(chunks.length).toBe(3);
+            expect(chunks[0]).toEqual({
+                type: 'text',
+                text: 'First line'
+            });
+            expect(chunks[1]).toEqual({
+                type: 'text',
+                text: '\n'
+            });
+            expect(chunks[2]).toEqual({
+                type: 'text',
+                text: 'Second line'
+            });
+        });
+
+        it('should handle API errors', async () => {
+            const mockError = new Error('Vertex API error');
+            const mockCreate = jest.fn().mockRejectedValue(mockError);
+            (handler['client'].messages as any).create = mockCreate;
+
+            const stream = handler.createMessage(systemPrompt, mockMessages);
+
+            await expect(async () => {
+                for await (const chunk of stream) {
+                    // Should throw before yielding any chunks
+                }
+            }).rejects.toThrow('Vertex API error');
+        });
+    });
+
+    describe('completePrompt', () => {
+        it('should complete prompt successfully', async () => {
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('Test response');
+            expect(handler['client'].messages.create).toHaveBeenCalledWith({
+                model: 'claude-3-5-sonnet-v2@20241022',
+                max_tokens: 8192,
+                temperature: 0,
+                messages: [{ role: 'user', content: 'Test prompt' }],
+                stream: false
+            });
+        });
+
+        it('should handle API errors', async () => {
+            const mockError = new Error('Vertex API error');
+            const mockCreate = jest.fn().mockRejectedValue(mockError);
+            (handler['client'].messages as any).create = mockCreate;
+
+            await expect(handler.completePrompt('Test prompt'))
+                .rejects.toThrow('Vertex completion error: Vertex API error');
+        });
+
+        it('should handle non-text content', async () => {
+            const mockCreate = jest.fn().mockResolvedValue({
+                content: [{ type: 'image' }]
+            });
+            (handler['client'].messages as any).create = mockCreate;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+
+        it('should handle empty response', async () => {
+            const mockCreate = jest.fn().mockResolvedValue({
+                content: [{ type: 'text', text: '' }]
+            });
+            (handler['client'].messages as any).create = mockCreate;
+
+            const result = await handler.completePrompt('Test prompt');
+            expect(result).toBe('');
+        });
+    });
+
+    describe('getModel', () => {
+        it('should return correct model info', () => {
+            const modelInfo = handler.getModel();
+            expect(modelInfo.id).toBe('claude-3-5-sonnet-v2@20241022');
+            expect(modelInfo.info).toBeDefined();
+            expect(modelInfo.info.maxTokens).toBe(8192);
+            expect(modelInfo.info.contextWindow).toBe(200_000);
+        });
+
+        it('should return default model if invalid model specified', () => {
+            const invalidHandler = new VertexHandler({
+                apiModelId: 'invalid-model',
+                vertexProjectId: 'test-project',
+                vertexRegion: 'us-central1'
+            });
+            const modelInfo = invalidHandler.getModel();
+            expect(modelInfo.id).toBe('claude-3-5-sonnet-v2@20241022'); // Default model
+        });
+    });
+});

src/api/providers/anthropic.ts

@@ -7,10 +7,10 @@ import {
 	ApiHandlerOptions,
 	ModelInfo,
 } from "../../shared/api"
-import { ApiHandler } from "../index"
+import { ApiHandler, SingleCompletionHandler } from "../index"
 import { ApiStream } from "../transform/stream"
 
-export class AnthropicHandler implements ApiHandler {
+export class AnthropicHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: Anthropic
 
@@ -173,4 +173,27 @@ export class AnthropicHandler implements ApiHandler {
 		}
 		return { id: anthropicDefaultModelId, info: anthropicModels[anthropicDefaultModelId] }
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const response = await this.client.messages.create({
+				model: this.getModel().id,
+				max_tokens: this.getModel().info.maxTokens || 8192,
+				temperature: 0,
+				messages: [{ role: "user", content: prompt }],
+				stream: false
+			})
+
+			const content = response.content[0]
+			if (content.type === 'text') {
+				return content.text
+			}
+			return ''
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`Anthropic completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/bedrock.ts

@@ -1,6 +1,6 @@
-import { BedrockRuntimeClient, ConverseStreamCommand, BedrockRuntimeClientConfig } from "@aws-sdk/client-bedrock-runtime"
+import { BedrockRuntimeClient, ConverseStreamCommand, ConverseCommand, BedrockRuntimeClientConfig } from "@aws-sdk/client-bedrock-runtime"
 import { Anthropic } from "@anthropic-ai/sdk"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, BedrockModelId, ModelInfo, bedrockDefaultModelId, bedrockModels } from "../../shared/api"
 import { ApiStream } from "../transform/stream"
 import { convertToBedrockConverseMessages, convertToAnthropicMessage } from "../transform/bedrock-converse-format"
@@ -38,7 +38,7 @@ export interface StreamEvent {
     };
 }
 
-export class AwsBedrockHandler implements ApiHandler {
+export class AwsBedrockHandler implements ApiHandler, SingleCompletionHandler {
     private options: ApiHandlerOptions
     private client: BedrockRuntimeClient
 
@@ -219,4 +219,63 @@ export class AwsBedrockHandler implements ApiHandler {
             info: bedrockModels[bedrockDefaultModelId]
         }
     }
+
+    async completePrompt(prompt: string): Promise<string> {
+        try {
+            const modelConfig = this.getModel()
+            
+            // Handle cross-region inference
+            let modelId: string
+            if (this.options.awsUseCrossRegionInference) {
+                let regionPrefix = (this.options.awsRegion || "").slice(0, 3)
+                switch (regionPrefix) {
+                    case "us-":
+                        modelId = `us.${modelConfig.id}`
+                        break
+                    case "eu-":
+                        modelId = `eu.${modelConfig.id}`
+                        break
+                    default:
+                        modelId = modelConfig.id
+                        break
+                }
+            } else {
+                modelId = modelConfig.id
+            }
+
+            const payload = {
+                modelId,
+                messages: convertToBedrockConverseMessages([{
+                    role: "user",
+                    content: prompt
+                }]),
+                inferenceConfig: {
+                    maxTokens: modelConfig.info.maxTokens || 5000,
+                    temperature: 0.3,
+                    topP: 0.1
+                }
+            }
+
+            const command = new ConverseCommand(payload)
+            const response = await this.client.send(command)
+
+            if (response.output && response.output instanceof Uint8Array) {
+                try {
+                    const outputStr = new TextDecoder().decode(response.output)
+                    const output = JSON.parse(outputStr)
+                    if (output.content) {
+                        return output.content
+                    }
+                } catch (parseError) {
+                    console.error('Failed to parse Bedrock response:', parseError)
+                }
+            }
+            return ''
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Bedrock completion error: ${error.message}`)
+            }
+            throw error
+        }
+    }
 }

src/api/providers/gemini.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { GoogleGenerativeAI } from "@google/generative-ai"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "../../shared/api"
 import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
 import { ApiStream } from "../transform/stream"
 
-export class GeminiHandler implements ApiHandler {
+export class GeminiHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: GoogleGenerativeAI
 
@@ -53,4 +53,26 @@ export class GeminiHandler implements ApiHandler {
 		}
 		return { id: geminiDefaultModelId, info: geminiModels[geminiDefaultModelId] }
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const model = this.client.getGenerativeModel({
+				model: this.getModel().id,
+			})
+
+			const result = await model.generateContent({
+				contents: [{ role: "user", parts: [{ text: prompt }] }],
+				generationConfig: {
+					temperature: 0,
+				},
+			})
+
+			return result.response.text()
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`Gemini completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/glama.ts

@@ -1,13 +1,13 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import axios from "axios"
 import OpenAI from "openai"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, glamaDefaultModelId, glamaDefaultModelInfo } from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import delay from "delay"
 
-export class GlamaHandler implements ApiHandler {
+export class GlamaHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: OpenAI
 
@@ -129,4 +129,26 @@ export class GlamaHandler implements ApiHandler {
 		
 		return { id: glamaDefaultModelId, info: glamaDefaultModelInfo }
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
+				model: this.getModel().id,
+				messages: [{ role: "user", content: prompt }],
+				temperature: 0,
+			}
+
+			if (this.getModel().id.startsWith("anthropic/")) {
+				requestOptions.max_tokens = 8192
+			}
+			
+			const response = await this.client.chat.completions.create(requestOptions)
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`Glama completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/lmstudio.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 
-export class LmStudioHandler implements ApiHandler {
+export class LmStudioHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: OpenAI
 
@@ -53,4 +53,20 @@ export class LmStudioHandler implements ApiHandler {
 			info: openAiModelInfoSaneDefaults,
 		}
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const response = await this.client.chat.completions.create({
+				model: this.getModel().id,
+				messages: [{ role: "user", content: prompt }],
+				temperature: 0,
+				stream: false
+			})
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			throw new Error(
+				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Cline's prompts.",
+			)
+		}
+	}
 }

src/api/providers/ollama.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 
-export class OllamaHandler implements ApiHandler {
+export class OllamaHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: OpenAI
 
@@ -46,4 +46,21 @@ export class OllamaHandler implements ApiHandler {
 			info: openAiModelInfoSaneDefaults,
 		}
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const response = await this.client.chat.completions.create({
+				model: this.getModel().id,
+				messages: [{ role: "user", content: prompt }],
+				temperature: 0,
+				stream: false
+			})
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`Ollama completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/openai-native.ts

@@ -1,6 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import {
 	ApiHandlerOptions,
 	ModelInfo,
@@ -11,7 +11,7 @@ import {
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 
-export class OpenAiNativeHandler implements ApiHandler {
+export class OpenAiNativeHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: OpenAI
 
@@ -83,4 +83,37 @@ export class OpenAiNativeHandler implements ApiHandler {
 		}
 		return { id: openAiNativeDefaultModelId, info: openAiNativeModels[openAiNativeDefaultModelId] }
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const modelId = this.getModel().id
+			let requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
+
+			switch (modelId) {
+				case "o1":
+				case "o1-preview":
+				case "o1-mini":
+					// o1 doesn't support non-1 temp or system prompt
+					requestOptions = {
+						model: modelId,
+						messages: [{ role: "user", content: prompt }]
+					}
+					break
+				default:
+					requestOptions = {
+						model: modelId,
+						messages: [{ role: "user", content: prompt }],
+						temperature: 0
+					}
+			}
+
+			const response = await this.client.chat.completions.create(requestOptions)
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`OpenAI Native completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/openai.ts

@@ -6,11 +6,11 @@ import {
 	ModelInfo,
 	openAiModelInfoSaneDefaults,
 } from "../../shared/api"
-import { ApiHandler } from "../index"
+import { ApiHandler, SingleCompletionHandler } from "../index"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 
-export class OpenAiHandler implements ApiHandler {
+export class OpenAiHandler implements ApiHandler, SingleCompletionHandler {
 	protected options: ApiHandlerOptions
 	private client: OpenAI
 
@@ -100,4 +100,22 @@ export class OpenAiHandler implements ApiHandler {
 			info: openAiModelInfoSaneDefaults,
 		}
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
+				model: this.getModel().id,
+				messages: [{ role: "user", content: prompt }],
+				temperature: 0,
+			}
+			
+			const response = await this.client.chat.completions.create(requestOptions)
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`OpenAI completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/providers/vertex.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk"
-import { ApiHandler } from "../"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, vertexDefaultModelId, VertexModelId, vertexModels } from "../../shared/api"
 import { ApiStream } from "../transform/stream"
 
 // https://docs.anthropic.com/en/api/claude-on-vertex-ai
-export class VertexHandler implements ApiHandler {
+export class VertexHandler implements ApiHandler, SingleCompletionHandler {
 	private options: ApiHandlerOptions
 	private client: AnthropicVertex
 
@@ -83,4 +83,27 @@ export class VertexHandler implements ApiHandler {
 		}
 		return { id: vertexDefaultModelId, info: vertexModels[vertexDefaultModelId] }
 	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		try {
+			const response = await this.client.messages.create({
+				model: this.getModel().id,
+				max_tokens: this.getModel().info.maxTokens || 8192,
+				temperature: 0,
+				messages: [{ role: "user", content: prompt }],
+				stream: false
+			})
+
+			const content = response.content[0]
+			if (content.type === 'text') {
+				return content.text
+			}
+			return ''
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`Vertex completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
 }

src/api/transform/__tests__/openai-format.test.ts

@@ -0,0 +1,257 @@
+import { convertToOpenAiMessages, convertToAnthropicMessage } from '../openai-format';
+import { Anthropic } from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+
+type PartialChatCompletion = Omit<OpenAI.Chat.Completions.ChatCompletion, 'choices'> & {
+    choices: Array<Partial<OpenAI.Chat.Completions.ChatCompletion.Choice> & {
+        message: OpenAI.Chat.Completions.ChatCompletion.Choice['message'];
+        finish_reason: string;
+        index: number;
+    }>;
+};
+
+describe('OpenAI Format Transformations', () => {
+    describe('convertToOpenAiMessages', () => {
+        it('should convert simple text messages', () => {
+            const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+                {
+                    role: 'user',
+                    content: 'Hello'
+                },
+                {
+                    role: 'assistant',
+                    content: 'Hi there!'
+                }
+            ];
+
+            const openAiMessages = convertToOpenAiMessages(anthropicMessages);
+            expect(openAiMessages).toHaveLength(2);
+            expect(openAiMessages[0]).toEqual({
+                role: 'user',
+                content: 'Hello'
+            });
+            expect(openAiMessages[1]).toEqual({
+                role: 'assistant',
+                content: 'Hi there!'
+            });
+        });
+
+        it('should handle messages with image content', () => {
+            const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+                {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'What is in this image?'
+                        },
+                        {
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: 'image/jpeg',
+                                data: 'base64data'
+                            }
+                        }
+                    ]
+                }
+            ];
+
+            const openAiMessages = convertToOpenAiMessages(anthropicMessages);
+            expect(openAiMessages).toHaveLength(1);
+            expect(openAiMessages[0].role).toBe('user');
+            
+            const content = openAiMessages[0].content as Array<{
+                type: string;
+                text?: string;
+                image_url?: { url: string };
+            }>;
+            
+            expect(Array.isArray(content)).toBe(true);
+            expect(content).toHaveLength(2);
+            expect(content[0]).toEqual({ type: 'text', text: 'What is in this image?' });
+            expect(content[1]).toEqual({
+                type: 'image_url',
+                image_url: { url: 'data:image/jpeg;base64,base64data' }
+            });
+        });
+
+        it('should handle assistant messages with tool use', () => {
+            const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+                {
+                    role: 'assistant',
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Let me check the weather.'
+                        },
+                        {
+                            type: 'tool_use',
+                            id: 'weather-123',
+                            name: 'get_weather',
+                            input: { city: 'London' }
+                        }
+                    ]
+                }
+            ];
+
+            const openAiMessages = convertToOpenAiMessages(anthropicMessages);
+            expect(openAiMessages).toHaveLength(1);
+            
+            const assistantMessage = openAiMessages[0] as OpenAI.Chat.ChatCompletionAssistantMessageParam;
+            expect(assistantMessage.role).toBe('assistant');
+            expect(assistantMessage.content).toBe('Let me check the weather.');
+            expect(assistantMessage.tool_calls).toHaveLength(1);
+            expect(assistantMessage.tool_calls![0]).toEqual({
+                id: 'weather-123',
+                type: 'function',
+                function: {
+                    name: 'get_weather',
+                    arguments: JSON.stringify({ city: 'London' })
+                }
+            });
+        });
+
+        it('should handle user messages with tool results', () => {
+            const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+                {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: 'weather-123',
+                            content: 'Current temperature in London: 20°C'
+                        }
+                    ]
+                }
+            ];
+
+            const openAiMessages = convertToOpenAiMessages(anthropicMessages);
+            expect(openAiMessages).toHaveLength(1);
+            
+            const toolMessage = openAiMessages[0] as OpenAI.Chat.ChatCompletionToolMessageParam;
+            expect(toolMessage.role).toBe('tool');
+            expect(toolMessage.tool_call_id).toBe('weather-123');
+            expect(toolMessage.content).toBe('Current temperature in London: 20°C');
+        });
+    });
+
+    describe('convertToAnthropicMessage', () => {
+        it('should convert simple completion', () => {
+            const openAiCompletion: PartialChatCompletion = {
+                id: 'completion-123',
+                model: 'gpt-4',
+                choices: [{
+                    message: {
+                        role: 'assistant',
+                        content: 'Hello there!',
+                        refusal: null
+                    },
+                    finish_reason: 'stop',
+                    index: 0
+                }],
+                usage: {
+                    prompt_tokens: 10,
+                    completion_tokens: 5,
+                    total_tokens: 15
+                },
+                created: 123456789,
+                object: 'chat.completion'
+            };
+
+            const anthropicMessage = convertToAnthropicMessage(openAiCompletion as OpenAI.Chat.Completions.ChatCompletion);
+            expect(anthropicMessage.id).toBe('completion-123');
+            expect(anthropicMessage.role).toBe('assistant');
+            expect(anthropicMessage.content).toHaveLength(1);
+            expect(anthropicMessage.content[0]).toEqual({
+                type: 'text',
+                text: 'Hello there!'
+            });
+            expect(anthropicMessage.stop_reason).toBe('end_turn');
+            expect(anthropicMessage.usage).toEqual({
+                input_tokens: 10,
+                output_tokens: 5
+            });
+        });
+
+        it('should handle tool calls in completion', () => {
+            const openAiCompletion: PartialChatCompletion = {
+                id: 'completion-123',
+                model: 'gpt-4',
+                choices: [{
+                    message: {
+                        role: 'assistant',
+                        content: 'Let me check the weather.',
+                        tool_calls: [{
+                            id: 'weather-123',
+                            type: 'function',
+                            function: {
+                                name: 'get_weather',
+                                arguments: '{"city":"London"}'
+                            }
+                        }],
+                        refusal: null
+                    },
+                    finish_reason: 'tool_calls',
+                    index: 0
+                }],
+                usage: {
+                    prompt_tokens: 15,
+                    completion_tokens: 8,
+                    total_tokens: 23
+                },
+                created: 123456789,
+                object: 'chat.completion'
+            };
+
+            const anthropicMessage = convertToAnthropicMessage(openAiCompletion as OpenAI.Chat.Completions.ChatCompletion);
+            expect(anthropicMessage.content).toHaveLength(2);
+            expect(anthropicMessage.content[0]).toEqual({
+                type: 'text',
+                text: 'Let me check the weather.'
+            });
+            expect(anthropicMessage.content[1]).toEqual({
+                type: 'tool_use',
+                id: 'weather-123',
+                name: 'get_weather',
+                input: { city: 'London' }
+            });
+            expect(anthropicMessage.stop_reason).toBe('tool_use');
+        });
+
+        it('should handle invalid tool call arguments', () => {
+            const openAiCompletion: PartialChatCompletion = {
+                id: 'completion-123',
+                model: 'gpt-4',
+                choices: [{
+                    message: {
+                        role: 'assistant',
+                        content: 'Testing invalid arguments',
+                        tool_calls: [{
+                            id: 'test-123',
+                            type: 'function',
+                            function: {
+                                name: 'test_function',
+                                arguments: 'invalid json'
+                            }
+                        }],
+                        refusal: null
+                    },
+                    finish_reason: 'tool_calls',
+                    index: 0
+                }],
+                created: 123456789,
+                object: 'chat.completion'
+            };
+
+            const anthropicMessage = convertToAnthropicMessage(openAiCompletion as OpenAI.Chat.Completions.ChatCompletion);
+            expect(anthropicMessage.content).toHaveLength(2);
+            expect(anthropicMessage.content[1]).toEqual({
+                type: 'tool_use',
+                id: 'test-123',
+                name: 'test_function',
+                input: {}  // Should default to empty object for invalid JSON
+            });
+        });
+    });
+});

src/api/transform/__tests__/stream.test.ts

@@ -0,0 +1,114 @@
+import { ApiStreamChunk } from '../stream';
+
+describe('API Stream Types', () => {
+    describe('ApiStreamChunk', () => {
+        it('should correctly handle text chunks', () => {
+            const textChunk: ApiStreamChunk = {
+                type: 'text',
+                text: 'Hello world'
+            };
+
+            expect(textChunk.type).toBe('text');
+            expect(textChunk.text).toBe('Hello world');
+        });
+
+        it('should correctly handle usage chunks with cache information', () => {
+            const usageChunk: ApiStreamChunk = {
+                type: 'usage',
+                inputTokens: 100,
+                outputTokens: 50,
+                cacheWriteTokens: 20,
+                cacheReadTokens: 10
+            };
+
+            expect(usageChunk.type).toBe('usage');
+            expect(usageChunk.inputTokens).toBe(100);
+            expect(usageChunk.outputTokens).toBe(50);
+            expect(usageChunk.cacheWriteTokens).toBe(20);
+            expect(usageChunk.cacheReadTokens).toBe(10);
+        });
+
+        it('should handle usage chunks without cache tokens', () => {
+            const usageChunk: ApiStreamChunk = {
+                type: 'usage',
+                inputTokens: 100,
+                outputTokens: 50
+            };
+
+            expect(usageChunk.type).toBe('usage');
+            expect(usageChunk.inputTokens).toBe(100);
+            expect(usageChunk.outputTokens).toBe(50);
+            expect(usageChunk.cacheWriteTokens).toBeUndefined();
+            expect(usageChunk.cacheReadTokens).toBeUndefined();
+        });
+
+        it('should handle text chunks with empty strings', () => {
+            const emptyTextChunk: ApiStreamChunk = {
+                type: 'text',
+                text: ''
+            };
+
+            expect(emptyTextChunk.type).toBe('text');
+            expect(emptyTextChunk.text).toBe('');
+        });
+
+        it('should handle usage chunks with zero tokens', () => {
+            const zeroUsageChunk: ApiStreamChunk = {
+                type: 'usage',
+                inputTokens: 0,
+                outputTokens: 0
+            };
+
+            expect(zeroUsageChunk.type).toBe('usage');
+            expect(zeroUsageChunk.inputTokens).toBe(0);
+            expect(zeroUsageChunk.outputTokens).toBe(0);
+        });
+
+        it('should handle usage chunks with large token counts', () => {
+            const largeUsageChunk: ApiStreamChunk = {
+                type: 'usage',
+                inputTokens: 1000000,
+                outputTokens: 500000,
+                cacheWriteTokens: 200000,
+                cacheReadTokens: 100000
+            };
+
+            expect(largeUsageChunk.type).toBe('usage');
+            expect(largeUsageChunk.inputTokens).toBe(1000000);
+            expect(largeUsageChunk.outputTokens).toBe(500000);
+            expect(largeUsageChunk.cacheWriteTokens).toBe(200000);
+            expect(largeUsageChunk.cacheReadTokens).toBe(100000);
+        });
+
+        it('should handle text chunks with special characters', () => {
+            const specialCharsChunk: ApiStreamChunk = {
+                type: 'text',
+                text: '!@#$%^&*()_+-=[]{}|;:,.<>?`~'
+            };
+
+            expect(specialCharsChunk.type).toBe('text');
+            expect(specialCharsChunk.text).toBe('!@#$%^&*()_+-=[]{}|;:,.<>?`~');
+        });
+
+        it('should handle text chunks with unicode characters', () => {
+            const unicodeChunk: ApiStreamChunk = {
+                type: 'text',
+                text: '你好世界👋🌍'
+            };
+
+            expect(unicodeChunk.type).toBe('text');
+            expect(unicodeChunk.text).toBe('你好世界👋🌍');
+        });
+
+        it('should handle text chunks with multiline content', () => {
+            const multilineChunk: ApiStreamChunk = {
+                type: 'text',
+                text: 'Line 1\nLine 2\nLine 3'
+            };
+
+            expect(multilineChunk.type).toBe('text');
+            expect(multilineChunk.text).toBe('Line 1\nLine 2\nLine 3');
+            expect(multilineChunk.text.split('\n')).toHaveLength(3);
+        });
+    });
+});

src/core/Cline.ts

@@ -1,6 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import cloneDeep from "clone-deep"
 import { DiffStrategy, getDiffStrategy, UnifiedDiffStrategy } from "./diff/DiffStrategy"
+import { validateToolUse, isToolAllowedForMode } from "./mode-validator"
 import delay from "delay"
 import fs from "fs/promises"
 import os from "os"
@@ -44,7 +45,7 @@ import { arePathsEqual, getReadablePath } from "../utils/path"
 import { parseMentions } from "./mentions"
 import { AssistantMessageContent, parseAssistantMessage, ToolParamName, ToolUseName } from "./assistant-message"
 import { formatResponse } from "./prompts/responses"
-import { addCustomInstructions, SYSTEM_PROMPT } from "./prompts/system"
+import { addCustomInstructions, codeMode, SYSTEM_PROMPT } from "./prompts/system"
 import { truncateHalfConversation } from "./sliding-window"
 import { ClineProvider, GlobalFileNames } from "./webview/ClineProvider"
 import { detectCodeOmission } from "../integrations/editor/detect-omission"
@@ -784,8 +785,24 @@ export class Cline {
 			})
 		}
 
-		const { browserViewportSize, preferredLanguage } = await this.providerRef.deref()?.getState() ?? {}
+		const { browserViewportSize, preferredLanguage, mode, customPrompts } = await this.providerRef.deref()?.getState() ?? {}
-		const systemPrompt = await SYSTEM_PROMPT(cwd, this.api.getModel().info.supportsComputerUse ?? false, mcpHub, this.diffStrategy, browserViewportSize) + await addCustomInstructions(this.customInstructions ?? '', cwd, preferredLanguage)
+		const systemPrompt = await SYSTEM_PROMPT(
+			cwd,
+			this.api.getModel().info.supportsComputerUse ?? false,
+			mcpHub,
+			this.diffStrategy,
+			browserViewportSize,
+			mode,
+			customPrompts
+		) + await addCustomInstructions(
+			{
+				customInstructions: this.customInstructions,
+				customPrompts,
+				preferredLanguage
+			},
+			cwd,
+			mode
+		)
 
 		// If the previous API request's total token usage is close to the context window, truncate the conversation history to free up space for the new request
 		if (previousApiReqIndex >= 0) {
@@ -804,8 +821,30 @@ export class Cline {
 			}
 		}
 
-		// Convert to Anthropic.MessageParam by spreading only the API-required properties
+		// Clean conversation history by:
-		const cleanConversationHistory = this.apiConversationHistory.map(({ role, content }) => ({ role, content }))
+		// 1. Converting to Anthropic.MessageParam by spreading only the API-required properties
+		// 2. Converting image blocks to text descriptions if model doesn't support images
+		const cleanConversationHistory = this.apiConversationHistory.map(({ role, content }) => {
+			// Handle array content (could contain image blocks)
+			if (Array.isArray(content)) {
+				if (!this.api.getModel().info.supportsImages) {
+					// Convert image blocks to text descriptions
+					content = content.map(block => {
+						if (block.type === 'image') {
+							// Convert image blocks to text descriptions
+							// Note: We can't access the actual image content/url due to API limitations,
+							// but we can indicate that an image was present in the conversation
+							return {
+								type: 'text',
+								text: '[Referenced image in conversation]'
+							};
+						}
+						return block;
+					});
+				}
+			}
+			return { role, content }
+		})
 		const stream = this.api.createMessage(systemPrompt, cleanConversationHistory)
 		const iterator = stream[Symbol.asyncIterator]()
 
@@ -816,15 +855,15 @@ export class Cline {
 		} catch (error) {
 			// note that this api_req_failed ask is unique in that we only present this option if the api hasn't streamed any content yet (ie it fails on the first chunk due), as it would allow them to hit a retry button. However if the api failed mid-stream, it could be in any arbitrary state where some tools may have executed, so that error is handled differently and requires cancelling the task entirely.
 			if (alwaysApproveResubmit) {
+				const errorMsg = error.message ?? "Unknown error"
 				const requestDelay = requestDelaySeconds || 5
 				// Automatically retry with delay
-				await this.say(
+				// Show countdown timer in error color
-					"error",
+				for (let i = requestDelay; i > 0; i--) {
-					`${error.message ?? "Unknown error"} ↺ Retrying in ${requestDelay} seconds...`,
+					await this.say("api_req_retry_delayed", `${errorMsg}\n\nRetrying in ${i} seconds...`, undefined, true)
-				)
+					await delay(1000)
-				await this.say("api_req_retry_delayed")
+				}
-				await delay(requestDelay * 1000)
+				await this.say("api_req_retry_delayed", `${errorMsg}\n\nRetrying now...`, undefined, false)
-				await this.say("api_req_retried")
 				// delegate generator output from the recursive call
 				yield* this.attemptApiRequest(previousApiReqIndex)
 				return
@@ -1069,6 +1108,16 @@ export class Cline {
 					await this.browserSession.closeBrowser()
 				}
 
+				// Validate tool use based on current mode
+				const { mode } = await this.providerRef.deref()?.getState() ?? {}
+				try {
+					validateToolUse(block.name, mode ?? codeMode)
+				} catch (error) {
+					this.consecutiveMistakeCount++
+					pushToolResult(formatResponse.toolError(error.message))
+					break
+				}
+
 				switch (block.name) {
 					case "write_to_file": {
 						const relPath: string | undefined = block.params.path
@@ -2344,22 +2393,30 @@ export class Cline {
 			// 2. ToolResultBlockParam's content/context text arrays if it contains "<feedback>" (see formatToolDeniedFeedback, attemptCompletion, executeCommand, and consecutiveMistakeCount >= 3) or "<answer>" (see askFollowupQuestion), we place all user generated content in these tags so they can effectively be used as markers for when we should parse mentions)
 			Promise.all(
 				userContent.map(async (block) => {
+					const shouldProcessMentions = (text: string) =>
+						text.includes("<task>") || text.includes("<feedback>");
+
 					if (block.type === "text") {
-						return {
+						if (shouldProcessMentions(block.text)) {
-							...block,
-							text: await parseMentions(block.text, cwd, this.urlContentFetcher),
-						}
-					} else if (block.type === "tool_result") {
-						const isUserMessage = (text: string) => text.includes("<feedback>") || text.includes("<answer>")
-						if (typeof block.content === "string" && isUserMessage(block.content)) {
 							return {
 								...block,
-								content: await parseMentions(block.content, cwd, this.urlContentFetcher),
+								text: await parseMentions(block.text, cwd, this.urlContentFetcher),
 							}
+						}
+						return block;
+					} else if (block.type === "tool_result") {
+						if (typeof block.content === "string") {
+							if (shouldProcessMentions(block.content)) {
+								return {
+									...block,
+									content: await parseMentions(block.content, cwd, this.urlContentFetcher),
+								}
+							}
+							return block;
 						} else if (Array.isArray(block.content)) {
 							const parsedContent = await Promise.all(
 								block.content.map(async (contentBlock) => {
-									if (contentBlock.type === "text" && isUserMessage(contentBlock.text)) {
+									if (contentBlock.type === "text" && shouldProcessMentions(contentBlock.text)) {
 										return {
 											...contentBlock,
 											text: await parseMentions(contentBlock.text, cwd, this.urlContentFetcher),
@@ -2373,6 +2430,7 @@ export class Cline {
 								content: parsedContent,
 							}
 						}
+						return block;
 					}
 					return block
 				}),
@@ -2511,6 +2569,16 @@ export class Cline {
 		const timeZoneOffsetStr = `${timeZoneOffset >= 0 ? '+' : ''}${timeZoneOffset}:00`
 		details += `\n\n# Current Time\n${formatter.format(now)} (${timeZone}, UTC${timeZoneOffsetStr})`
 
+		// Add current mode and any mode-specific warnings
+		const { mode } = await this.providerRef.deref()?.getState() ?? {}
+		const currentMode = mode ?? codeMode
+		details += `\n\n# Current Mode\n${currentMode}`
+		
+		// Add warning if not in code mode
+		if (!isToolAllowedForMode('write_to_file', currentMode) || !isToolAllowedForMode('execute_command', currentMode)) {
+			details += `\n\nNOTE: You are currently in '${currentMode}' mode which only allows read-only operations. To write files or execute commands, the user will need to switch to 'code' mode. Note that only the user can switch modes.`
+		}
+
 		if (includeFileDetails) {
 			details += `\n\n# Current Working Directory (${cwd.toPosix()}) Files\n`
 			const isDesktop = arePathsEqual(cwd, path.join(os.homedir(), "Desktop"))

src/core/__tests__/Cline.test.ts

@@ -1,7 +1,8 @@
 import { Cline } from '../Cline';
 import { ClineProvider } from '../webview/ClineProvider';
-import { ApiConfiguration } from '../../shared/api';
+import { ApiConfiguration, ModelInfo } from '../../shared/api';
 import { ApiStreamChunk } from '../../api/transform/stream';
+import { Anthropic } from '@anthropic-ai/sdk';
 import * as vscode from 'vscode';
 
 // Mock all MCP-related modules
@@ -252,7 +253,8 @@ describe('Cline', () => {
         // Setup mock API configuration
         mockApiConfig = {
             apiProvider: 'anthropic',
-            apiModelId: 'claude-3-5-sonnet-20241022'
+            apiModelId: 'claude-3-5-sonnet-20241022',
+            apiKey: 'test-api-key'  // Add API key to mock config
         };
 
         // Mock provider methods
@@ -498,6 +500,336 @@ describe('Cline', () => {
                 expect(passedMessage).not.toHaveProperty('ts');
                 expect(passedMessage).not.toHaveProperty('extraProp');
             });
+
+            it('should handle image blocks based on model capabilities', async () => {
+                // Create two configurations - one with image support, one without
+                const configWithImages = {
+                    ...mockApiConfig,
+                    apiModelId: 'claude-3-sonnet'
+                };
+                const configWithoutImages = {
+                    ...mockApiConfig,
+                    apiModelId: 'gpt-3.5-turbo'
+                };
+
+                // Create test conversation history with mixed content
+                const conversationHistory: (Anthropic.MessageParam & { ts?: number })[] = [
+                    {
+                        role: 'user' as const,
+                        content: [
+                            {
+                                type: 'text' as const,
+                                text: 'Here is an image'
+                            } satisfies Anthropic.TextBlockParam,
+                            {
+                                type: 'image' as const,
+                                source: {
+                                    type: 'base64' as const,
+                                    media_type: 'image/jpeg',
+                                    data: 'base64data'
+                                }
+                            } satisfies Anthropic.ImageBlockParam
+                        ]
+                    },
+                    {
+                        role: 'assistant' as const,
+                        content: [{
+                            type: 'text' as const,
+                            text: 'I see the image'
+                        } satisfies Anthropic.TextBlockParam]
+                    }
+                ];
+
+                // Test with model that supports images
+                const clineWithImages = new Cline(
+                    mockProvider,
+                    configWithImages,
+                    undefined,
+                    false,
+                    undefined,
+                    'test task'
+                );
+                // Mock the model info to indicate image support
+                jest.spyOn(clineWithImages.api, 'getModel').mockReturnValue({
+                    id: 'claude-3-sonnet',
+                    info: {
+                        supportsImages: true,
+                        supportsPromptCache: true,
+                        supportsComputerUse: true,
+                        contextWindow: 200000,
+                        maxTokens: 4096,
+                        inputPrice: 0.25,
+                        outputPrice: 0.75
+                    } as ModelInfo
+                });
+                clineWithImages.apiConversationHistory = conversationHistory;
+
+                // Test with model that doesn't support images
+                const clineWithoutImages = new Cline(
+                    mockProvider,
+                    configWithoutImages,
+                    undefined,
+                    false,
+                    undefined,
+                    'test task'
+                );
+                // Mock the model info to indicate no image support
+                jest.spyOn(clineWithoutImages.api, 'getModel').mockReturnValue({
+                    id: 'gpt-3.5-turbo',
+                    info: {
+                        supportsImages: false,
+                        supportsPromptCache: false,
+                        supportsComputerUse: false,
+                        contextWindow: 16000,
+                        maxTokens: 2048,
+                        inputPrice: 0.1,
+                        outputPrice: 0.2
+                    } as ModelInfo
+                });
+                clineWithoutImages.apiConversationHistory = conversationHistory;
+
+                // Create message spy for both instances
+                const createMessageSpyWithImages = jest.fn();
+                const createMessageSpyWithoutImages = jest.fn();
+                const mockStream = {
+                    async *[Symbol.asyncIterator]() {
+                        yield { type: 'text', text: '' };
+                    }
+                } as AsyncGenerator<ApiStreamChunk>;
+
+                jest.spyOn(clineWithImages.api, 'createMessage').mockImplementation((...args) => {
+                    createMessageSpyWithImages(...args);
+                    return mockStream;
+                });
+                jest.spyOn(clineWithoutImages.api, 'createMessage').mockImplementation((...args) => {
+                    createMessageSpyWithoutImages(...args);
+                    return mockStream;
+                });
+
+                // Trigger API requests for both instances
+                await clineWithImages.recursivelyMakeClineRequests([{ type: 'text', text: 'test' }]);
+                await clineWithoutImages.recursivelyMakeClineRequests([{ type: 'text', text: 'test' }]);
+
+                // Verify model with image support preserves image blocks
+                const callsWithImages = createMessageSpyWithImages.mock.calls;
+                const historyWithImages = callsWithImages[0][1][0];
+                expect(historyWithImages.content).toHaveLength(2);
+                expect(historyWithImages.content[0]).toEqual({ type: 'text', text: 'Here is an image' });
+                expect(historyWithImages.content[1]).toHaveProperty('type', 'image');
+
+                // Verify model without image support converts image blocks to text
+                const callsWithoutImages = createMessageSpyWithoutImages.mock.calls;
+                const historyWithoutImages = callsWithoutImages[0][1][0];
+                expect(historyWithoutImages.content).toHaveLength(2);
+                expect(historyWithoutImages.content[0]).toEqual({ type: 'text', text: 'Here is an image' });
+                expect(historyWithoutImages.content[1]).toEqual({
+                    type: 'text',
+                    text: '[Referenced image in conversation]'
+                });
+            });
+        
+            it('should handle API retry with countdown', async () => {
+                const cline = new Cline(
+                    mockProvider,
+                    mockApiConfig,
+                    undefined,
+                    false,
+                    undefined,
+                    'test task'
+                );
+
+                // Mock delay to track countdown timing
+                const mockDelay = jest.fn().mockResolvedValue(undefined);
+                jest.spyOn(require('delay'), 'default').mockImplementation(mockDelay);
+
+                // Mock say to track messages
+                const saySpy = jest.spyOn(cline, 'say');
+
+                // Create a stream that fails on first chunk
+                const mockError = new Error('API Error');
+                const mockFailedStream = {
+                    async *[Symbol.asyncIterator]() {
+                        throw mockError;
+                    },
+                    async next() {
+                        throw mockError;
+                    },
+                    async return() {
+                        return { done: true, value: undefined };
+                    },
+                    async throw(e: any) {
+                        throw e;
+                    },
+                    async [Symbol.asyncDispose]() {
+                        // Cleanup
+                    }
+                } as AsyncGenerator<ApiStreamChunk>;
+
+                // Create a successful stream for retry
+                const mockSuccessStream = {
+                    async *[Symbol.asyncIterator]() {
+                        yield { type: 'text', text: 'Success' };
+                    },
+                    async next() {
+                        return { done: true, value: { type: 'text', text: 'Success' } };
+                    },
+                    async return() {
+                        return { done: true, value: undefined };
+                    },
+                    async throw(e: any) {
+                        throw e;
+                    },
+                    async [Symbol.asyncDispose]() {
+                        // Cleanup
+                    }
+                } as AsyncGenerator<ApiStreamChunk>;
+
+                // Mock createMessage to fail first then succeed
+                let firstAttempt = true;
+                jest.spyOn(cline.api, 'createMessage').mockImplementation(() => {
+                    if (firstAttempt) {
+                        firstAttempt = false;
+                        return mockFailedStream;
+                    }
+                    return mockSuccessStream;
+                });
+
+                // Set alwaysApproveResubmit and requestDelaySeconds
+                mockProvider.getState = jest.fn().mockResolvedValue({
+                    alwaysApproveResubmit: true,
+                    requestDelaySeconds: 3
+                });
+
+                // Mock previous API request message
+                cline.clineMessages = [{
+                    ts: Date.now(),
+                    type: 'say',
+                    say: 'api_req_started',
+                    text: JSON.stringify({
+                        tokensIn: 100,
+                        tokensOut: 50,
+                        cacheWrites: 0,
+                        cacheReads: 0,
+                        request: 'test request'
+                    })
+                }];
+
+                // Trigger API request
+                const iterator = cline.attemptApiRequest(0);
+                await iterator.next();
+
+                // Verify countdown messages
+                expect(saySpy).toHaveBeenCalledWith(
+                    'api_req_retry_delayed',
+                    expect.stringContaining('Retrying in 3 seconds'),
+                    undefined,
+                    true
+                );
+                expect(saySpy).toHaveBeenCalledWith(
+                    'api_req_retry_delayed',
+                    expect.stringContaining('Retrying in 2 seconds'),
+                    undefined,
+                    true
+                );
+                expect(saySpy).toHaveBeenCalledWith(
+                    'api_req_retry_delayed',
+                    expect.stringContaining('Retrying in 1 seconds'),
+                    undefined,
+                    true
+                );
+                expect(saySpy).toHaveBeenCalledWith(
+                    'api_req_retry_delayed',
+                    expect.stringContaining('Retrying now'),
+                    undefined,
+                    false
+                );
+
+                // Verify delay was called correctly
+                expect(mockDelay).toHaveBeenCalledTimes(3);
+                expect(mockDelay).toHaveBeenCalledWith(1000);
+
+                // Verify error message content
+                const errorMessage = saySpy.mock.calls.find(
+                    call => call[1]?.includes(mockError.message)
+                )?.[1];
+                expect(errorMessage).toBe(`${mockError.message}\n\nRetrying in 3 seconds...`);
+            });
+
+            describe('loadContext', () => {
+                it('should process mentions in task and feedback tags', async () => {
+                    const cline = new Cline(
+                        mockProvider,
+                        mockApiConfig,
+                        undefined,
+                        false,
+                        undefined,
+                        'test task'
+                    );
+        
+                    // Mock parseMentions to track calls
+                    const mockParseMentions = jest.fn().mockImplementation(text => `processed: ${text}`);
+                    jest.spyOn(require('../../core/mentions'), 'parseMentions').mockImplementation(mockParseMentions);
+        
+                    const userContent = [
+                        {
+                            type: 'text',
+                            text: 'Regular text with @/some/path'
+                        } as const,
+                        {
+                            type: 'text',
+                            text: '<task>Text with @/some/path in task tags</task>'
+                        } as const,
+                        {
+                            type: 'tool_result',
+                            tool_use_id: 'test-id',
+                            content: [{
+                                type: 'text',
+                                text: '<feedback>Check @/some/path</feedback>'
+                            }]
+                        } as Anthropic.ToolResultBlockParam,
+                        {
+                            type: 'tool_result',
+                            tool_use_id: 'test-id-2',
+                            content: [{
+                                type: 'text',
+                                text: 'Regular tool result with @/path'
+                            }]
+                        } as Anthropic.ToolResultBlockParam
+                    ];
+        
+                    // Process the content
+                    const [processedContent] = await cline['loadContext'](userContent);
+        
+                    // Regular text should not be processed
+                    expect((processedContent[0] as Anthropic.TextBlockParam).text)
+                        .toBe('Regular text with @/some/path');
+        
+                    // Text within task tags should be processed
+                    expect((processedContent[1] as Anthropic.TextBlockParam).text)
+                        .toContain('processed:');
+                    expect(mockParseMentions).toHaveBeenCalledWith(
+                        '<task>Text with @/some/path in task tags</task>',
+                        expect.any(String),
+                        expect.any(Object)
+                    );
+        
+                    // Feedback tag content should be processed
+                    const toolResult1 = processedContent[2] as Anthropic.ToolResultBlockParam;
+                    const content1 = Array.isArray(toolResult1.content) ? toolResult1.content[0] : toolResult1.content;
+                    expect((content1 as Anthropic.TextBlockParam).text).toContain('processed:');
+                    expect(mockParseMentions).toHaveBeenCalledWith(
+                        '<feedback>Check @/some/path</feedback>',
+                        expect.any(String),
+                        expect.any(Object)
+                    );
+        
+                    // Regular tool result should not be processed
+                    const toolResult2 = processedContent[3] as Anthropic.ToolResultBlockParam;
+                    const content2 = Array.isArray(toolResult2.content) ? toolResult2.content[0] : toolResult2.content;
+                    expect((content2 as Anthropic.TextBlockParam).text)
+                        .toBe('Regular tool result with @/path');
+                });
+            });
         });
     });
 });

src/core/__tests__/mode-validator.test.ts

@@ -0,0 +1,88 @@
+import { isToolAllowedForMode, validateToolUse } from '../mode-validator'
+import { codeMode, architectMode, askMode } from '../prompts/system'
+import { CODE_ALLOWED_TOOLS, READONLY_ALLOWED_TOOLS, ToolName } from '../tool-lists'
+
+// For testing purposes, we need to handle the 'unknown_tool' case
+type TestToolName = ToolName | 'unknown_tool';
+
+// Helper function to safely cast string to TestToolName for testing
+function asTestTool(str: string): TestToolName {
+    return str as TestToolName;
+}
+
+describe('mode-validator', () => {
+    describe('isToolAllowedForMode', () => {
+        describe('code mode', () => {
+            it('allows all code mode tools', () => {
+                CODE_ALLOWED_TOOLS.forEach(tool => {
+                    expect(isToolAllowedForMode(tool, codeMode)).toBe(true)
+                })
+            })
+
+            it('disallows unknown tools', () => {
+                expect(isToolAllowedForMode(asTestTool('unknown_tool'), codeMode)).toBe(false)
+            })
+        })
+
+        describe('architect mode', () => {
+            it('allows only read-only and MCP tools', () => {
+                // Test allowed tools
+                READONLY_ALLOWED_TOOLS.forEach(tool => {
+                    expect(isToolAllowedForMode(tool, architectMode)).toBe(true)
+                })
+
+                // Test specific disallowed tools that we know are in CODE_ALLOWED_TOOLS but not in READONLY_ALLOWED_TOOLS
+                const disallowedTools = ['execute_command', 'write_to_file', 'apply_diff'] as const;
+                disallowedTools.forEach(tool => {
+                    expect(isToolAllowedForMode(tool as ToolName, architectMode)).toBe(false)
+                })
+            })
+        })
+
+        describe('ask mode', () => {
+            it('allows only read-only and MCP tools', () => {
+                // Test allowed tools
+                READONLY_ALLOWED_TOOLS.forEach(tool => {
+                    expect(isToolAllowedForMode(tool, askMode)).toBe(true)
+                })
+
+                // Test specific disallowed tools that we know are in CODE_ALLOWED_TOOLS but not in READONLY_ALLOWED_TOOLS
+                const disallowedTools = ['execute_command', 'write_to_file', 'apply_diff'] as const;
+                disallowedTools.forEach(tool => {
+                    expect(isToolAllowedForMode(tool as ToolName, askMode)).toBe(false)
+                })
+            })
+        })
+    })
+
+    describe('validateToolUse', () => {
+        it('throws error for disallowed tools in architect mode', () => {
+            expect(() => validateToolUse('write_to_file' as ToolName, architectMode)).toThrow(
+                'Tool "write_to_file" is not allowed in architect mode.'
+            )
+        })
+
+        it('throws error for disallowed tools in ask mode', () => {
+            expect(() => validateToolUse('execute_command' as ToolName, askMode)).toThrow(
+                'Tool "execute_command" is not allowed in ask mode.'
+            )
+        })
+
+        it('throws error for unknown tools in code mode', () => {
+            expect(() => validateToolUse(asTestTool('unknown_tool'), codeMode)).toThrow(
+                'Tool "unknown_tool" is not allowed in code mode.'
+            )
+        })
+
+        it('does not throw for allowed tools', () => {
+            // Code mode
+            expect(() => validateToolUse('write_to_file' as ToolName, codeMode)).not.toThrow()
+
+            // Architect mode
+            expect(() => validateToolUse('read_file' as ToolName, architectMode)).not.toThrow()
+
+            // Ask mode
+            expect(() => validateToolUse('browser_action' as ToolName, askMode)).not.toThrow()
+        })
+    })
+})

src/core/config/ConfigManager.ts

@@ -0,0 +1,221 @@
+import { ExtensionContext } from 'vscode'
+import { ApiConfiguration } from '../../shared/api'
+import { Mode } from '../prompts/types'
+import { ApiConfigMeta } from '../../shared/ExtensionMessage'
+
+export interface ApiConfigData {
+  currentApiConfigName: string
+  apiConfigs: {
+    [key: string]: ApiConfiguration
+  }
+  modeApiConfigs?: Partial<Record<Mode, string>>
+}
+
+export class ConfigManager {
+  private readonly defaultConfig: ApiConfigData = {
+    currentApiConfigName: 'default',
+    apiConfigs: {
+      default: {
+        id: this.generateId()
+      }
+    }
+  }
+
+  private readonly SCOPE_PREFIX = "roo_cline_config_"
+  private readonly context: ExtensionContext
+
+  constructor(context: ExtensionContext) {
+    this.context = context
+    this.initConfig().catch(console.error)
+  }
+
+  private generateId(): string {
+    return Math.random().toString(36).substring(2, 15)
+  }
+
+  /**
+   * Initialize config if it doesn't exist
+   */
+  async initConfig(): Promise<void> {
+    try {
+      const config = await this.readConfig()
+      if (!config) {
+        await this.writeConfig(this.defaultConfig)
+        return
+      }
+
+      // Migrate: ensure all configs have IDs
+      let needsMigration = false
+      for (const [name, apiConfig] of Object.entries(config.apiConfigs)) {
+        if (!apiConfig.id) {
+          apiConfig.id = this.generateId()
+          needsMigration = true
+        }
+      }
+
+      if (needsMigration) {
+        await this.writeConfig(config)
+      }
+    } catch (error) {
+      throw new Error(`Failed to initialize config: ${error}`)
+    }
+  }
+
+  /**
+   * List all available configs with metadata
+   */
+  async ListConfig(): Promise<ApiConfigMeta[]> {
+    try {
+      const config = await this.readConfig()
+      return Object.entries(config.apiConfigs).map(([name, apiConfig]) => ({
+        name,
+        id: apiConfig.id || '',
+        apiProvider: apiConfig.apiProvider,
+      }))
+    } catch (error) {
+      throw new Error(`Failed to list configs: ${error}`)
+    }
+  }
+
+  /**
+   * Save a config with the given name
+   */
+  async SaveConfig(name: string, config: ApiConfiguration): Promise<void> {
+    try {
+      const currentConfig = await this.readConfig()
+      const existingConfig = currentConfig.apiConfigs[name]
+      currentConfig.apiConfigs[name] = {
+        ...config,
+        id: existingConfig?.id || this.generateId()
+      }
+      await this.writeConfig(currentConfig)
+    } catch (error) {
+      throw new Error(`Failed to save config: ${error}`)
+    }
+  }
+
+  /**
+   * Load a config by name
+   */
+  async LoadConfig(name: string): Promise<ApiConfiguration> {
+    try {
+      const config = await this.readConfig()
+      const apiConfig = config.apiConfigs[name]
+      
+      if (!apiConfig) {
+        throw new Error(`Config '${name}' not found`)
+      }
+      
+      config.currentApiConfigName = name;
+      await this.writeConfig(config)
+      
+      return apiConfig
+    } catch (error) {
+      throw new Error(`Failed to load config: ${error}`)
+    }
+  }
+
+  /**
+   * Delete a config by name
+   */
+  async DeleteConfig(name: string): Promise<void> {
+    try {
+      const currentConfig = await this.readConfig()
+      if (!currentConfig.apiConfigs[name]) {
+        throw new Error(`Config '${name}' not found`)
+      }
+
+      // Don't allow deleting the default config
+      if (Object.keys(currentConfig.apiConfigs).length === 1) {
+        throw new Error(`Cannot delete the last remaining configuration.`)
+      }
+
+      delete currentConfig.apiConfigs[name]
+      await this.writeConfig(currentConfig)
+    } catch (error) {
+      throw new Error(`Failed to delete config: ${error}`)
+    }
+  }
+
+  /**
+   * Set the current active API configuration
+   */
+  async SetCurrentConfig(name: string): Promise<void> {
+    try {
+      const currentConfig = await this.readConfig()
+      if (!currentConfig.apiConfigs[name]) {
+        throw new Error(`Config '${name}' not found`)
+      }
+
+      currentConfig.currentApiConfigName = name
+      await this.writeConfig(currentConfig)
+    } catch (error) {
+      throw new Error(`Failed to set current config: ${error}`)
+    }
+  }
+
+  /**
+   * Check if a config exists by name
+   */
+  async HasConfig(name: string): Promise<boolean> {
+    try {
+      const config = await this.readConfig()
+      return name in config.apiConfigs
+    } catch (error) {
+      throw new Error(`Failed to check config existence: ${error}`)
+    }
+  }
+
+  /**
+   * Set the API config for a specific mode
+   */
+  async SetModeConfig(mode: Mode, configId: string): Promise<void> {
+    try {
+      const currentConfig = await this.readConfig()
+      if (!currentConfig.modeApiConfigs) {
+        currentConfig.modeApiConfigs = {}
+      }
+      currentConfig.modeApiConfigs[mode] = configId
+      await this.writeConfig(currentConfig)
+    } catch (error) {
+      throw new Error(`Failed to set mode config: ${error}`)
+    }
+  }
+
+  /**
+   * Get the API config ID for a specific mode
+   */
+  async GetModeConfigId(mode: Mode): Promise<string | undefined> {
+    try {
+      const config = await this.readConfig()
+      return config.modeApiConfigs?.[mode]
+    } catch (error) {
+      throw new Error(`Failed to get mode config: ${error}`)
+    }
+  }
+
+  private async readConfig(): Promise<ApiConfigData> {
+    try {
+      const configKey = `${this.SCOPE_PREFIX}api_config`
+      const content = await this.context.secrets.get(configKey)
+      
+      if (!content) {
+        return this.defaultConfig
+      }
+
+      return JSON.parse(content)
+    } catch (error) {
+      throw new Error(`Failed to read config from secrets: ${error}`)
+    }
+  }
+
+  private async writeConfig(config: ApiConfigData): Promise<void> {
+    try {
+      const configKey = `${this.SCOPE_PREFIX}api_config`
+      const content = JSON.stringify(config, null, 2)
+      await this.context.secrets.store(configKey, content)
+    } catch (error) {
+      throw new Error(`Failed to write config to secrets: ${error}`)
+    }
+  }
+}

src/core/config/__tests__/ConfigManager.test.ts

@@ -0,0 +1,452 @@
+import { ExtensionContext } from 'vscode'
+import { ConfigManager, ApiConfigData } from '../ConfigManager'
+import { ApiConfiguration } from '../../../shared/api'
+
+// Mock VSCode ExtensionContext
+const mockSecrets = {
+  get: jest.fn(),
+  store: jest.fn(),
+  delete: jest.fn()
+}
+
+const mockContext = {
+  secrets: mockSecrets
+} as unknown as ExtensionContext
+
+describe('ConfigManager', () => {
+  let configManager: ConfigManager
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    configManager = new ConfigManager(mockContext)
+  })
+
+  describe('initConfig', () => {
+    it('should not write to storage when secrets.get returns null', async () => {
+      // Mock readConfig to return null
+      mockSecrets.get.mockResolvedValueOnce(null)
+
+      await configManager.initConfig()
+
+      // Should not write to storage because readConfig returns defaultConfig
+      expect(mockSecrets.store).not.toHaveBeenCalled()
+    })
+
+    it('should not initialize config if it exists', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            config: {},
+            id: 'default'
+          }
+        }
+      }))
+
+      await configManager.initConfig()
+
+      expect(mockSecrets.store).not.toHaveBeenCalled()
+    })
+
+    it('should generate IDs for configs that lack them', async () => {
+      // Mock a config with missing IDs
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            config: {}
+          },
+          test: {
+            apiProvider: 'anthropic'
+          }
+        }
+      }))
+
+      await configManager.initConfig()
+
+      // Should have written the config with new IDs
+      expect(mockSecrets.store).toHaveBeenCalled()
+      const storedConfig = JSON.parse(mockSecrets.store.mock.calls[0][1])
+      expect(storedConfig.apiConfigs.default.id).toBeTruthy()
+      expect(storedConfig.apiConfigs.test.id).toBeTruthy()
+    })
+
+    it('should throw error if secrets storage fails', async () => {
+      mockSecrets.get.mockRejectedValue(new Error('Storage failed'))
+
+      await expect(configManager.initConfig()).rejects.toThrow(
+        'Failed to initialize config: Error: Failed to read config from secrets: Error: Storage failed'
+      )
+    })
+  })
+
+  describe('ListConfig', () => {
+    it('should list all available configs', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            id: 'default'
+          },
+          test: {
+            apiProvider: 'anthropic',
+            id: 'test-id'
+          }
+        },
+        modeApiConfigs: {
+          code: 'default',
+          architect: 'default',
+          ask: 'default'
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      const configs = await configManager.ListConfig()
+      expect(configs).toEqual([
+        { name: 'default', id: 'default', apiProvider: undefined },
+        { name: 'test', id: 'test-id', apiProvider: 'anthropic' }
+      ])
+    })
+
+    it('should handle empty config file', async () => {
+      const emptyConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {},
+        modeApiConfigs: {
+          code: 'default',
+          architect: 'default',
+          ask: 'default'
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(emptyConfig))
+
+      const configs = await configManager.ListConfig()
+      expect(configs).toEqual([])
+    })
+
+    it('should throw error if reading from secrets fails', async () => {
+      mockSecrets.get.mockRejectedValue(new Error('Read failed'))
+
+      await expect(configManager.ListConfig()).rejects.toThrow(
+        'Failed to list configs: Error: Failed to read config from secrets: Error: Read failed'
+      )
+    })
+  })
+
+  describe('SaveConfig', () => {
+    it('should save new config', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {}
+        },
+        modeApiConfigs: {
+          code: 'default',
+          architect: 'default',
+          ask: 'default'
+        }
+      }))
+
+      const newConfig: ApiConfiguration = {
+        apiProvider: 'anthropic',
+        apiKey: 'test-key'
+      }
+
+      await configManager.SaveConfig('test', newConfig)
+
+      // Get the actual stored config to check the generated ID
+      const storedConfig = JSON.parse(mockSecrets.store.mock.calls[0][1])
+      const testConfigId = storedConfig.apiConfigs.test.id
+
+      const expectedConfig = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {},
+          test: {
+            ...newConfig,
+            id: testConfigId
+          }
+        },
+        modeApiConfigs: {
+          code: 'default',
+          architect: 'default',
+          ask: 'default'
+        }
+      }
+
+      expect(mockSecrets.store).toHaveBeenCalledWith(
+        'roo_cline_config_api_config',
+        JSON.stringify(expectedConfig, null, 2)
+      )
+    })
+
+    it('should update existing config', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          test: {
+            apiProvider: 'anthropic',
+            apiKey: 'old-key',
+            id: 'test-id'
+          }
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      const updatedConfig: ApiConfiguration = {
+        apiProvider: 'anthropic',
+        apiKey: 'new-key'
+      }
+
+      await configManager.SaveConfig('test', updatedConfig)
+
+      const expectedConfig = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          test: {
+            apiProvider: 'anthropic',
+            apiKey: 'new-key',
+            id: 'test-id'
+          }
+        }
+      }
+
+      expect(mockSecrets.store).toHaveBeenCalledWith(
+        'roo_cline_config_api_config',
+        JSON.stringify(expectedConfig, null, 2)
+      )
+    })
+
+    it('should throw error if secrets storage fails', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: { default: {} }
+      }))
+      mockSecrets.store.mockRejectedValueOnce(new Error('Storage failed'))
+
+      await expect(configManager.SaveConfig('test', {})).rejects.toThrow(
+        'Failed to save config: Error: Failed to write config to secrets: Error: Storage failed'
+      )
+    })
+  })
+
+  describe('DeleteConfig', () => {
+    it('should delete existing config', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            id: 'default'
+          },
+          test: {
+            apiProvider: 'anthropic',
+            id: 'test-id'
+          }
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      await configManager.DeleteConfig('test')
+
+      // Get the stored config to check the ID
+      const storedConfig = JSON.parse(mockSecrets.store.mock.calls[0][1])
+      expect(storedConfig.currentApiConfigName).toBe('default')
+      expect(Object.keys(storedConfig.apiConfigs)).toEqual(['default'])
+      expect(storedConfig.apiConfigs.default.id).toBeTruthy()
+    })
+
+    it('should throw error when trying to delete non-existent config', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: { default: {} }
+      }))
+
+      await expect(configManager.DeleteConfig('nonexistent')).rejects.toThrow(
+        "Config 'nonexistent' not found"
+      )
+    })
+
+    it('should throw error when trying to delete last remaining config', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            id: 'default'
+          }
+        }
+      }))
+
+      await expect(configManager.DeleteConfig('default')).rejects.toThrow(
+        'Cannot delete the last remaining configuration.'
+      )
+    })
+  })
+
+  describe('LoadConfig', () => {
+    it('should load config and update current config name', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          test: {
+            apiProvider: 'anthropic',
+            apiKey: 'test-key',
+            id: 'test-id'
+          }
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      const config = await configManager.LoadConfig('test')
+
+      expect(config).toEqual({
+        apiProvider: 'anthropic',
+        apiKey: 'test-key',
+        id: 'test-id'
+      })
+
+      // Get the stored config to check the structure
+      const storedConfig = JSON.parse(mockSecrets.store.mock.calls[0][1])
+      expect(storedConfig.currentApiConfigName).toBe('test')
+      expect(storedConfig.apiConfigs.test).toEqual({
+        apiProvider: 'anthropic',
+        apiKey: 'test-key',
+        id: 'test-id'
+      })
+    })
+
+    it('should throw error when config does not exist', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            config: {},
+            id: 'default'
+          }
+        }
+      }))
+
+      await expect(configManager.LoadConfig('nonexistent')).rejects.toThrow(
+        "Config 'nonexistent' not found"
+      )
+    })
+
+    it('should throw error if secrets storage fails', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          test: {
+            config: {
+              apiProvider: 'anthropic'
+            },
+            id: 'test-id'
+          }
+        }
+      }))
+      mockSecrets.store.mockRejectedValueOnce(new Error('Storage failed'))
+
+      await expect(configManager.LoadConfig('test')).rejects.toThrow(
+        'Failed to load config: Error: Failed to write config to secrets: Error: Storage failed'
+      )
+    })
+  })
+
+  describe('SetCurrentConfig', () => {
+    it('should set current config', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            id: 'default'
+          },
+          test: {
+            apiProvider: 'anthropic',
+            id: 'test-id'
+          }
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      await configManager.SetCurrentConfig('test')
+
+      // Get the stored config to check the structure
+      const storedConfig = JSON.parse(mockSecrets.store.mock.calls[0][1])
+      expect(storedConfig.currentApiConfigName).toBe('test')
+      expect(storedConfig.apiConfigs.default.id).toBe('default')
+      expect(storedConfig.apiConfigs.test).toEqual({
+        apiProvider: 'anthropic',
+        id: 'test-id'
+      })
+    })
+
+    it('should throw error when config does not exist', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: { default: {} }
+      }))
+
+      await expect(configManager.SetCurrentConfig('nonexistent')).rejects.toThrow(
+        "Config 'nonexistent' not found"
+      )
+    })
+
+    it('should throw error if secrets storage fails', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          test: { apiProvider: 'anthropic' }
+        }
+      }))
+      mockSecrets.store.mockRejectedValueOnce(new Error('Storage failed'))
+
+      await expect(configManager.SetCurrentConfig('test')).rejects.toThrow(
+        'Failed to set current config: Error: Failed to write config to secrets: Error: Storage failed'
+      )
+    })
+  })
+
+  describe('HasConfig', () => {
+    it('should return true for existing config', async () => {
+      const existingConfig: ApiConfigData = {
+        currentApiConfigName: 'default',
+        apiConfigs: {
+          default: {
+            id: 'default'
+          },
+          test: {
+            apiProvider: 'anthropic',
+            id: 'test-id'
+          }
+        }
+      }
+
+      mockSecrets.get.mockResolvedValue(JSON.stringify(existingConfig))
+
+      const hasConfig = await configManager.HasConfig('test')
+      expect(hasConfig).toBe(true)
+    })
+
+    it('should return false for non-existent config', async () => {
+      mockSecrets.get.mockResolvedValue(JSON.stringify({
+        currentApiConfigName: 'default',
+        apiConfigs: { default: {} }
+      }))
+
+      const hasConfig = await configManager.HasConfig('nonexistent')
+      expect(hasConfig).toBe(false)
+    })
+
+    it('should throw error if secrets storage fails', async () => {
+      mockSecrets.get.mockRejectedValue(new Error('Storage failed'))
+
+      await expect(configManager.HasConfig('test')).rejects.toThrow(
+        'Failed to check config existence: Error: Failed to read config from secrets: Error: Storage failed'
+      )
+    })
+  })
+})

src/core/diff/strategies/search-replace.ts

@@ -73,6 +73,7 @@ The tool will maintain proper indentation and formatting while making changes.
 Only a single operation is allowed per tool use.
 The SEARCH section must exactly match existing content including whitespace and indentation.
 If you're not confident in the exact content to search for, use the read_file tool first to get the exact content.
+When applying the diffs, be extra careful to remember to change any closing brackets or other syntax that may be affected by the diff farther down in the file.
 
 Parameters:
 - path: (required) The path of the file to modify (relative to the current working directory ${cwd})

src/core/mentions/__tests__/index.test.ts

@@ -131,7 +131,7 @@ Detailed commit message with multiple lines
 			await openMention("/path/to/file")
 			expect(mockExecuteCommand).not.toHaveBeenCalled()
 			expect(mockOpenExternal).not.toHaveBeenCalled()
-			expect(mockShowErrorMessage).toHaveBeenCalledWith("Could not open file!")
+			expect(mockShowErrorMessage).toHaveBeenCalledWith("Could not open file: File does not exist")
 
 			await openMention("problems")
 			expect(mockExecuteCommand).toHaveBeenCalledWith("workbench.actions.view.problems")

src/core/mode-validator.ts

@@ -0,0 +1,32 @@
+import { Mode } from './prompts/types'
+import { codeMode } from './prompts/system'
+import { CODE_ALLOWED_TOOLS, READONLY_ALLOWED_TOOLS, ToolName, ReadOnlyToolName } from './tool-lists'
+
+// Extended tool type that includes 'unknown_tool' for testing
+export type TestToolName = ToolName | 'unknown_tool';
+
+// Type guard to check if a tool is a valid tool
+function isValidTool(tool: TestToolName): tool is ToolName {
+    return CODE_ALLOWED_TOOLS.includes(tool as ToolName);
+}
+
+// Type guard to check if a tool is a read-only tool
+function isReadOnlyTool(tool: TestToolName): tool is ReadOnlyToolName {
+    return READONLY_ALLOWED_TOOLS.includes(tool as ReadOnlyToolName);
+}
+
+export function isToolAllowedForMode(toolName: TestToolName, mode: Mode): boolean {
+    if (mode === codeMode) {
+        return isValidTool(toolName);
+    }
+    // Both architect and ask modes use the same read-only tools
+    return isReadOnlyTool(toolName);
+}
+
+export function validateToolUse(toolName: TestToolName, mode: Mode): void {
+    if (!isToolAllowedForMode(toolName, mode)) {
+        throw new Error(
+            `Tool "${toolName}" is not allowed in ${mode} mode.`
+        );
+    }
+}

src/core/prompts/__tests__/architect.test.ts

@@ -0,0 +1,139 @@
+import { ARCHITECT_PROMPT } from '../architect'
+import { McpHub } from '../../../services/mcp/McpHub'
+import { SearchReplaceDiffStrategy } from '../../../core/diff/strategies/search-replace'
+import fs from 'fs/promises'
+import os from 'os'
+// Import path utils to get access to toPosix string extension
+import '../../../utils/path'
+
+// Mock environment-specific values for consistent tests
+jest.mock('os', () => ({
+  ...jest.requireActual('os'),
+  homedir: () => '/home/user'
+}))
+
+jest.mock('default-shell', () => '/bin/bash')
+
+jest.mock('os-name', () => () => 'Linux')
+
+// Mock fs.readFile to return empty mcpServers config
+jest.mock('fs/promises', () => ({
+  ...jest.requireActual('fs/promises'),
+  readFile: jest.fn().mockImplementation(async (path: string) => {
+    if (path.endsWith('mcpSettings.json')) {
+      return '{"mcpServers": {}}'
+    }
+    if (path.endsWith('.clinerules')) {
+      return '# Test Rules\n1. First rule\n2. Second rule'
+    }
+    return ''
+  }),
+  writeFile: jest.fn().mockResolvedValue(undefined)
+}))
+
+// Instead of extending McpHub, create a mock that implements just what we need
+const createMockMcpHub = (): McpHub => ({
+  getServers: () => [],
+  getMcpServersPath: async () => '/mock/mcp/path',
+  getMcpSettingsFilePath: async () => '/mock/settings/path',
+  dispose: async () => {},
+  // Add other required public methods with no-op implementations
+  restartConnection: async () => {},
+  readResource: async () => ({ contents: [] }),
+  callTool: async () => ({ content: [] }),
+  toggleServerDisabled: async () => {},
+  toggleToolAlwaysAllow: async () => {},
+  isConnecting: false,
+  connections: []
+} as unknown as McpHub)
+
+describe('ARCHITECT_PROMPT', () => {
+  let mockMcpHub: McpHub
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  afterEach(async () => {
+    // Clean up any McpHub instances
+    if (mockMcpHub) {
+      await mockMcpHub.dispose()
+    }
+  })
+
+  it('should maintain consistent architect prompt', async () => {
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      false, // supportsComputerUse
+      undefined, // mcpHub
+      undefined, // diffStrategy
+      undefined // browserViewportSize
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include browser actions when supportsComputerUse is true', async () => {
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      true,
+      undefined,
+      undefined,
+      '1280x800'
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include MCP server info when mcpHub is provided', async () => {
+    mockMcpHub = createMockMcpHub()
+
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      false,
+      mockMcpHub
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should explicitly handle undefined mcpHub', async () => {
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      false,
+      undefined, // explicitly undefined mcpHub
+      undefined,
+      undefined
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should handle different browser viewport sizes', async () => {
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      true,
+      undefined,
+      undefined,
+      '900x600' // different viewport size
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include diff strategy tool description', async () => {
+    const prompt = await ARCHITECT_PROMPT(
+      '/test/path',
+      false,
+      undefined,
+      new SearchReplaceDiffStrategy(), // Use actual diff strategy from the codebase
+      undefined
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  afterAll(() => {
+    jest.restoreAllMocks()
+  })
+})

src/core/prompts/__tests__/ask.test.ts

@@ -0,0 +1,139 @@
+import { ASK_PROMPT } from '../ask'
+import { McpHub } from '../../../services/mcp/McpHub'
+import { SearchReplaceDiffStrategy } from '../../../core/diff/strategies/search-replace'
+import fs from 'fs/promises'
+import os from 'os'
+// Import path utils to get access to toPosix string extension
+import '../../../utils/path'
+
+// Mock environment-specific values for consistent tests
+jest.mock('os', () => ({
+  ...jest.requireActual('os'),
+  homedir: () => '/home/user'
+}))
+
+jest.mock('default-shell', () => '/bin/bash')
+
+jest.mock('os-name', () => () => 'Linux')
+
+// Mock fs.readFile to return empty mcpServers config
+jest.mock('fs/promises', () => ({
+  ...jest.requireActual('fs/promises'),
+  readFile: jest.fn().mockImplementation(async (path: string) => {
+    if (path.endsWith('mcpSettings.json')) {
+      return '{"mcpServers": {}}'
+    }
+    if (path.endsWith('.clinerules')) {
+      return '# Test Rules\n1. First rule\n2. Second rule'
+    }
+    return ''
+  }),
+  writeFile: jest.fn().mockResolvedValue(undefined)
+}))
+
+// Instead of extending McpHub, create a mock that implements just what we need
+const createMockMcpHub = (): McpHub => ({
+  getServers: () => [],
+  getMcpServersPath: async () => '/mock/mcp/path',
+  getMcpSettingsFilePath: async () => '/mock/settings/path',
+  dispose: async () => {},
+  // Add other required public methods with no-op implementations
+  restartConnection: async () => {},
+  readResource: async () => ({ contents: [] }),
+  callTool: async () => ({ content: [] }),
+  toggleServerDisabled: async () => {},
+  toggleToolAlwaysAllow: async () => {},
+  isConnecting: false,
+  connections: []
+} as unknown as McpHub)
+
+describe('ASK_PROMPT', () => {
+  let mockMcpHub: McpHub
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  afterEach(async () => {
+    // Clean up any McpHub instances
+    if (mockMcpHub) {
+      await mockMcpHub.dispose()
+    }
+  })
+
+  it('should maintain consistent ask prompt', async () => {
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      false, // supportsComputerUse
+      undefined, // mcpHub
+      undefined, // diffStrategy
+      undefined // browserViewportSize
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include browser actions when supportsComputerUse is true', async () => {
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      true,
+      undefined,
+      undefined,
+      '1280x800'
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include MCP server info when mcpHub is provided', async () => {
+    mockMcpHub = createMockMcpHub()
+
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      false,
+      mockMcpHub
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should explicitly handle undefined mcpHub', async () => {
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      false,
+      undefined, // explicitly undefined mcpHub
+      undefined,
+      undefined
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should handle different browser viewport sizes', async () => {
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      true,
+      undefined,
+      undefined,
+      '900x600' // different viewport size
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  it('should include diff strategy tool description', async () => {
+    const prompt = await ASK_PROMPT(
+      '/test/path',
+      false,
+      undefined,
+      new SearchReplaceDiffStrategy(), // Use actual diff strategy from the codebase
+      undefined
+    )
+    
+    expect(prompt).toMatchSnapshot()
+  })
+
+  afterAll(() => {
+    jest.restoreAllMocks()
+  })
+})

src/core/prompts/__tests__/system.test.ts

@@ -1,112 +1,320 @@
+import { SYSTEM_PROMPT, addCustomInstructions } from '../system'
+import { McpHub } from '../../../services/mcp/McpHub'
+import { McpServer } from '../../../shared/mcp'
+import { ClineProvider } from '../../../core/webview/ClineProvider'
+import { SearchReplaceDiffStrategy } from '../../../core/diff/strategies/search-replace'
 import fs from 'fs/promises'
-import path from 'path'
 import os from 'os'
-import { addCustomInstructions } from '../system'
+import { codeMode, askMode, architectMode } from '../modes'
+// Import path utils to get access to toPosix string extension
+import '../../../utils/path'
 
-// Mock external dependencies
+// Mock environment-specific values for consistent tests
-jest.mock('os-name', () => () => 'macOS')
-jest.mock('default-shell', () => '/bin/zsh')
 jest.mock('os', () => ({
-  homedir: () => '/Users/test',
+  ...jest.requireActual('os'),
-  ...jest.requireActual('os')
+  homedir: () => '/home/user'
 }))
 
-describe('system.ts', () => {
+jest.mock('default-shell', () => '/bin/bash')
-  let tempDir: string
 
-  beforeEach(async () => {
+jest.mock('os-name', () => () => 'Linux')
-    // Create a temporary directory for test files
+
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cline-test-'))
+// Mock fs.readFile to return empty mcpServers config and mock rules files
+jest.mock('fs/promises', () => ({
+  ...jest.requireActual('fs/promises'),
+  readFile: jest.fn().mockImplementation(async (path: string) => {
+    if (path.endsWith('mcpSettings.json')) {
+      return '{"mcpServers": {}}'
+    }
+    if (path.endsWith('.clinerules-code')) {
+      return '# Code Mode Rules\n1. Code specific rule'
+    }
+    if (path.endsWith('.clinerules-ask')) {
+      return '# Ask Mode Rules\n1. Ask specific rule'
+    }
+    if (path.endsWith('.clinerules-architect')) {
+      return '# Architect Mode Rules\n1. Architect specific rule'
+    }
+    if (path.endsWith('.clinerules')) {
+      return '# Test Rules\n1. First rule\n2. Second rule'
+    }
+    return ''
+  }),
+  writeFile: jest.fn().mockResolvedValue(undefined)
+}))
+
+// Create a minimal mock of ClineProvider
+const mockProvider = {
+  ensureMcpServersDirectoryExists: async () => '/mock/mcp/path',
+  ensureSettingsDirectoryExists: async () => '/mock/settings/path',
+  postMessageToWebview: async () => {},
+  context: {
+    extension: {
+      packageJSON: {
+        version: '1.0.0'
+      }
+    }
+  }
+} as unknown as ClineProvider
+
+// Instead of extending McpHub, create a mock that implements just what we need
+const createMockMcpHub = (): McpHub => ({
+  getServers: () => [],
+  getMcpServersPath: async () => '/mock/mcp/path',
+  getMcpSettingsFilePath: async () => '/mock/settings/path',
+  dispose: async () => {},
+  // Add other required public methods with no-op implementations
+  restartConnection: async () => {},
+  readResource: async () => ({ contents: [] }),
+  callTool: async () => ({ content: [] }),
+  toggleServerDisabled: async () => {},
+  toggleToolAlwaysAllow: async () => {},
+  isConnecting: false,
+  connections: []
+} as unknown as McpHub)
+
+describe('SYSTEM_PROMPT', () => {
+  let mockMcpHub: McpHub
+
+  beforeEach(() => {
+    jest.clearAllMocks()
   })
 
   afterEach(async () => {
-    // Clean up temporary directory after each test
+    // Clean up any McpHub instances
-    await fs.rm(tempDir, { recursive: true, force: true })
+    if (mockMcpHub) {
+      await mockMcpHub.dispose()
+    }
   })
 
-  describe('addCustomInstructions', () => {
+  it('should maintain consistent system prompt', async () => {
-    it('should include content from .clinerules and .cursorrules if present', async () => {
+    const prompt = await SYSTEM_PROMPT(
-      // Create test rule files
+      '/test/path',
-      await fs.writeFile(path.join(tempDir, '.clinerules'), 'Always write tests\nUse TypeScript')
+      false, // supportsComputerUse
-      await fs.writeFile(path.join(tempDir, '.cursorrules'), 'Format code before committing')
+      undefined, // mcpHub
+      undefined, // diffStrategy
+      undefined // browserViewportSize
+    )
     
-      const customInstructions = 'Base instructions'
+    expect(prompt).toMatchSnapshot()
-      const result = await addCustomInstructions(customInstructions, tempDir)
+  })
 
-      // Verify all instructions are included
+  it('should include browser actions when supportsComputerUse is true', async () => {
-      expect(result).toContain('Base instructions')
+    const prompt = await SYSTEM_PROMPT(
-      expect(result).toContain('Always write tests')
+      '/test/path',
-      expect(result).toContain('Use TypeScript')
+      true,
-      expect(result).toContain('Format code before committing')
+      undefined,
-      expect(result).toContain('Rules from .clinerules:')
+      undefined,
-      expect(result).toContain('Rules from .cursorrules:')
+      '1280x800'
-    })
+    )
     
-    it('should handle missing rule files gracefully', async () => {
+    expect(prompt).toMatchSnapshot()
-      const customInstructions = 'Base instructions'
+  })
-      const result = await addCustomInstructions(customInstructions, tempDir)
 
-      // Should only contain base instructions
+  it('should include MCP server info when mcpHub is provided', async () => {
-      expect(result).toContain('Base instructions')
+    mockMcpHub = createMockMcpHub()
-      expect(result).not.toContain('Rules from')
-    })
 
-    it('should handle empty rule files', async () => {
+    const prompt = await SYSTEM_PROMPT(
-      // Create empty rule files
+      '/test/path',
-      await fs.writeFile(path.join(tempDir, '.clinerules'), '')
+      false,
-      await fs.writeFile(path.join(tempDir, '.cursorrules'), '')
+      mockMcpHub
+    )
     
-      const customInstructions = 'Base instructions'
+    expect(prompt).toMatchSnapshot()
-      const result = await addCustomInstructions(customInstructions, tempDir)
+  })
 
-      // Should only contain base instructions
+  it('should explicitly handle undefined mcpHub', async () => {
-      expect(result).toContain('Base instructions')
+    const prompt = await SYSTEM_PROMPT(
-      expect(result).not.toContain('Rules from')
+      '/test/path',
-    })
+      false,
+      undefined, // explicitly undefined mcpHub
+      undefined,
+      undefined
+    )
     
-    it('should handle whitespace-only rule files', async () => {
+    expect(prompt).toMatchSnapshot()
-      // Create rule files with only whitespace
+  })
-      await fs.writeFile(path.join(tempDir, '.clinerules'), '  \n  \t  ')
-      await fs.writeFile(path.join(tempDir, '.cursorrules'), ' \n ')
 
-      const customInstructions = 'Base instructions'
+  it('should handle different browser viewport sizes', async () => {
-      const result = await addCustomInstructions(customInstructions, tempDir)
+    const prompt = await SYSTEM_PROMPT(
+      '/test/path',
+      true,
+      undefined,
+      undefined,
+      '900x600' // different viewport size
+    )
     
-      // Should only contain base instructions
+    expect(prompt).toMatchSnapshot()
-      expect(result).toContain('Base instructions')
+  })
-      expect(result).not.toContain('Rules from')
-    })
 
-    it('should handle one rule file present and one missing', async () => {
+  it('should include diff strategy tool description', async () => {
-      // Create only .clinerules
+    const prompt = await SYSTEM_PROMPT(
-      await fs.writeFile(path.join(tempDir, '.clinerules'), 'Always write tests')
+      '/test/path',
+      false,
+      undefined,
+      new SearchReplaceDiffStrategy(), // Use actual diff strategy from the codebase
+      undefined
+    )
     
-      const customInstructions = 'Base instructions'
+    expect(prompt).toMatchSnapshot()
-      const result = await addCustomInstructions(customInstructions, tempDir)
+  })
 
-      // Should contain base instructions and .clinerules content
+  afterAll(() => {
-      expect(result).toContain('Base instructions')
+    jest.restoreAllMocks()
-      expect(result).toContain('Always write tests')
+  })
-      expect(result).toContain('Rules from .clinerules:')
+})
-      expect(result).not.toContain('Rules from .cursorrules:')
+
-    })
+describe('addCustomInstructions', () => {
-
+  beforeEach(() => {
-    it('should handle empty custom instructions with rule files', async () => {
+    jest.clearAllMocks()
-      await fs.writeFile(path.join(tempDir, '.clinerules'), 'Always write tests')
+  })
-      await fs.writeFile(path.join(tempDir, '.cursorrules'), 'Format code before committing')
+
-
+  it('should prioritize mode-specific rules for code mode', async () => {
-      const result = await addCustomInstructions('', tempDir)
+    const instructions = await addCustomInstructions(
-
+      {},
-      // Should contain rule file content even with empty custom instructions
+      '/test/path',
-      expect(result).toContain('Always write tests')
+      codeMode
-      expect(result).toContain('Format code before committing')
+    )
-      expect(result).toContain('Rules from .clinerules:')
+    expect(instructions).toMatchSnapshot()
-      expect(result).toContain('Rules from .cursorrules:')
+  })
-    })
+
-
+  it('should prioritize mode-specific rules for ask mode', async () => {
-    it('should return empty string when no instructions or rules exist', async () => {
+    const instructions = await addCustomInstructions(
-      const result = await addCustomInstructions('', tempDir)
+      {},
-      expect(result).toBe('')
+      '/test/path',
-    })
+      askMode
+    )
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should prioritize mode-specific rules for architect mode', async () => {
+    const instructions = await addCustomInstructions(
+      {},
+      '/test/path',
+      architectMode
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should fall back to generic rules when mode-specific rules not found', async () => {
+    // Mock readFile to return ENOENT for mode-specific file
+    const mockReadFile = jest.fn().mockImplementation(async (path: string) => {
+      if (path.endsWith('.clinerules-code')) {
+        const error = new Error('ENOENT') as NodeJS.ErrnoException
+        error.code = 'ENOENT'
+        throw error
+      }
+      if (path.endsWith('.clinerules')) {
+        return '# Test Rules\n1. First rule\n2. Second rule'
+      }
+      return ''
+    })
+    jest.spyOn(fs, 'readFile').mockImplementation(mockReadFile)
+
+    const instructions = await addCustomInstructions(
+      {},
+      '/test/path',
+      codeMode
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should include preferred language when provided', async () => {
+    const instructions = await addCustomInstructions(
+      { preferredLanguage: 'Spanish' },
+      '/test/path',
+      codeMode
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should include custom instructions when provided', async () => {
+    const instructions = await addCustomInstructions(
+      { customInstructions: 'Custom test instructions' },
+      '/test/path'
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should combine all custom instructions', async () => {
+    const instructions = await addCustomInstructions(
+      {
+        customInstructions: 'Custom test instructions',
+        preferredLanguage: 'French'
+      },
+      '/test/path',
+      codeMode
+    )
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should handle undefined mode-specific instructions', async () => {
+    const instructions = await addCustomInstructions(
+      {},
+      '/test/path'
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should trim mode-specific instructions', async () => {
+    const instructions = await addCustomInstructions(
+      { customInstructions: '  Custom mode instructions  ' },
+      '/test/path'
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should handle empty mode-specific instructions', async () => {
+    const instructions = await addCustomInstructions(
+      { customInstructions: '' },
+      '/test/path'
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should combine global and mode-specific instructions', async () => {
+    const instructions = await addCustomInstructions(
+      {
+        customInstructions: 'Global instructions',
+        customPrompts: {
+          code: { customInstructions: 'Mode-specific instructions' }
+        }
+      },
+      '/test/path',
+      codeMode
+    )
+    
+    expect(instructions).toMatchSnapshot()
+  })
+
+  it('should prioritize mode-specific instructions after global ones', async () => {
+    const instructions = await addCustomInstructions(
+      {
+        customInstructions: 'First instruction',
+        customPrompts: {
+          code: { customInstructions: 'Second instruction' }
+        }
+      },
+      '/test/path',
+      codeMode
+    )
+    
+    const instructionParts = instructions.split('\n\n')
+    const globalIndex = instructionParts.findIndex(part => part.includes('First instruction'))
+    const modeSpecificIndex = instructionParts.findIndex(part => part.includes('Second instruction'))
+    
+    expect(globalIndex).toBeLessThan(modeSpecificIndex)
+    expect(instructions).toMatchSnapshot()
+  })
+
+  afterAll(() => {
+    jest.restoreAllMocks()
   })
 })

src/core/prompts/architect.ts

@@ -0,0 +1,40 @@
+import { architectMode, defaultPrompts, PromptComponent } from "../../shared/modes"
+import { getToolDescriptionsForMode } from "./tools"
+import {
+    getRulesSection,
+    getSystemInfoSection,
+    getObjectiveSection,
+    getSharedToolUseSection,
+    getMcpServersSection,
+    getToolUseGuidelinesSection,
+    getCapabilitiesSection
+} from "./sections"
+import { DiffStrategy } from "../diff/DiffStrategy"
+import { McpHub } from "../../services/mcp/McpHub"
+
+export const mode = architectMode
+
+export const ARCHITECT_PROMPT = async (
+    cwd: string,
+    supportsComputerUse: boolean,
+    mcpHub?: McpHub,
+    diffStrategy?: DiffStrategy,
+    browserViewportSize?: string,
+    customPrompt?: PromptComponent,
+) => `${customPrompt?.roleDefinition || defaultPrompts[architectMode].roleDefinition}
+
+${getSharedToolUseSection()}
+
+${getToolDescriptionsForMode(mode, cwd, supportsComputerUse, diffStrategy, browserViewportSize, mcpHub)}
+
+${getToolUseGuidelinesSection()}
+
+${await getMcpServersSection(mcpHub, diffStrategy)}
+
+${getCapabilitiesSection(cwd, supportsComputerUse, mcpHub, diffStrategy)}
+
+${getRulesSection(cwd, supportsComputerUse, diffStrategy)}
+
+${getSystemInfoSection(cwd)}
+
+${getObjectiveSection()}`

src/core/prompts/ask.ts

@@ -0,0 +1,40 @@
+import { Mode, askMode, defaultPrompts, PromptComponent } from "../../shared/modes"
+import { getToolDescriptionsForMode } from "./tools"
+import {
+    getRulesSection,
+    getSystemInfoSection,
+    getObjectiveSection,
+    getSharedToolUseSection,
+    getMcpServersSection,
+    getToolUseGuidelinesSection,
+    getCapabilitiesSection
+} from "./sections"
+import { DiffStrategy } from "../diff/DiffStrategy"
+import { McpHub } from "../../services/mcp/McpHub"
+
+export const mode = askMode
+
+export const ASK_PROMPT = async (
+    cwd: string,
+    supportsComputerUse: boolean,
+    mcpHub?: McpHub,
+    diffStrategy?: DiffStrategy,
+    browserViewportSize?: string,
+    customPrompt?: PromptComponent,
+) => `${customPrompt?.roleDefinition || defaultPrompts[askMode].roleDefinition}
+
+${getSharedToolUseSection()}
+
+${getToolDescriptionsForMode(mode, cwd, supportsComputerUse, diffStrategy, browserViewportSize, mcpHub)}
+
+${getToolUseGuidelinesSection()}
+
+${await getMcpServersSection(mcpHub, diffStrategy)}
+
+${getCapabilitiesSection(cwd, supportsComputerUse, mcpHub, diffStrategy)}
+
+${getRulesSection(cwd, supportsComputerUse, diffStrategy)}
+
+${getSystemInfoSection(cwd)}
+
+${getObjectiveSection()}`

src/core/prompts/code.ts

@@ -0,0 +1,40 @@
+import { Mode, codeMode, defaultPrompts, PromptComponent } from "../../shared/modes"
+import { getToolDescriptionsForMode } from "./tools"
+import {
+    getRulesSection,
+    getSystemInfoSection,
+    getObjectiveSection,
+    getSharedToolUseSection,
+    getMcpServersSection,
+    getToolUseGuidelinesSection,
+    getCapabilitiesSection
+} from "./sections"
+import { DiffStrategy } from "../diff/DiffStrategy"
+import { McpHub } from "../../services/mcp/McpHub"
+
+export const mode: Mode = codeMode
+
+export const CODE_PROMPT = async (
+    cwd: string,
+    supportsComputerUse: boolean,
+    mcpHub?: McpHub,
+    diffStrategy?: DiffStrategy,
+    browserViewportSize?: string,
+    customPrompt?: PromptComponent,
+) => `${customPrompt?.roleDefinition || defaultPrompts[codeMode].roleDefinition}
+
+${getSharedToolUseSection()}
+
+${getToolDescriptionsForMode(mode, cwd, supportsComputerUse, diffStrategy, browserViewportSize, mcpHub)}
+
+${getToolUseGuidelinesSection()}
+
+${await getMcpServersSection(mcpHub, diffStrategy)}
+
+${getCapabilitiesSection(cwd, supportsComputerUse, mcpHub, diffStrategy)}
+
+${getRulesSection(cwd, supportsComputerUse, diffStrategy)}
+
+${getSystemInfoSection(cwd)}
+
+${getObjectiveSection()}`

src/core/prompts/modes.ts

@@ -0,0 +1,5 @@
+export const codeMode = 'code' as const;
+export const architectMode = 'architect' as const;
+export const askMode = 'ask' as const;
+
+export type Mode = typeof codeMode | typeof architectMode | typeof askMode;

src/core/prompts/sections/capabilities.ts

@@ -0,0 +1,28 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+import { McpHub } from "../../../services/mcp/McpHub"
+
+export function getCapabilitiesSection(
+    cwd: string,
+    supportsComputerUse: boolean,
+    mcpHub?: McpHub,
+    diffStrategy?: DiffStrategy,
+): string {
+    return `====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search${
+    supportsComputerUse ? ", use the browser" : ""
+}, read and write files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('${cwd}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the write_to_file ${diffStrategy ? "or apply_diff " : ""}tool to apply the changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
+    supportsComputerUse
+        ? "\n- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.\n  - For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser."
+        : ""
+}${mcpHub ? `
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+` : ''}`
+}

src/core/prompts/sections/custom-instructions.ts

@@ -0,0 +1,52 @@
+import fs from 'fs/promises'
+import path from 'path'
+
+export async function loadRuleFiles(cwd: string): Promise<string> {
+    const ruleFiles = ['.clinerules', '.cursorrules', '.windsurfrules']
+    let combinedRules = ''
+
+    for (const file of ruleFiles) {
+        try {
+            const content = await fs.readFile(path.join(cwd, file), 'utf-8')
+            if (content.trim()) {
+                combinedRules += `\n# Rules from ${file}:\n${content.trim()}\n`
+            }
+        } catch (err) {
+            // Silently skip if file doesn't exist
+            if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+                throw err
+            }
+        }
+    }
+
+    return combinedRules
+}
+
+export async function addCustomInstructions(customInstructions: string, cwd: string, preferredLanguage?: string): Promise<string> {
+    const ruleFileContent = await loadRuleFiles(cwd)
+    const allInstructions = []
+
+    if (preferredLanguage) {
+        allInstructions.push(`You should always speak and think in the ${preferredLanguage} language.`)
+    }
+    
+    if (customInstructions.trim()) {
+        allInstructions.push(customInstructions.trim())
+    }
+
+    if (ruleFileContent && ruleFileContent.trim()) {
+        allInstructions.push(ruleFileContent.trim())
+    }
+
+    const joinedInstructions = allInstructions.join('\n\n')
+
+    return joinedInstructions ? `
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${joinedInstructions}`
+        : ""
+}

src/core/prompts/sections/index.ts

@@ -0,0 +1,8 @@
+export { getRulesSection } from './rules'
+export { getSystemInfoSection } from './system-info'
+export { getObjectiveSection } from './objective'
+export { addCustomInstructions } from './custom-instructions'
+export { getSharedToolUseSection } from './tool-use'
+export { getMcpServersSection } from './mcp-servers'
+export { getToolUseGuidelinesSection } from './tool-use-guidelines'
+export { getCapabilitiesSection } from './capabilities'

src/core/prompts/sections/mcp-servers.ts

@@ -0,0 +1,413 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+import { McpHub } from "../../../services/mcp/McpHub"
+
+export async function getMcpServersSection(mcpHub?: McpHub, diffStrategy?: DiffStrategy): Promise<string> {
+    if (!mcpHub) {
+        return '';
+    }
+
+    const connectedServers = mcpHub.getServers().length > 0
+        ? `${mcpHub
+            .getServers()
+            .filter((server) => server.status === "connected")
+            .map((server) => {
+                const tools = server.tools
+                    ?.map((tool) => {
+                        const schemaStr = tool.inputSchema
+                            ? `    Input Schema:
+    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`
+                            : ""
+
+                        return `- ${tool.name}: ${tool.description}\n${schemaStr}`
+                    })
+                    .join("\n\n")
+
+                const templates = server.resourceTemplates
+                    ?.map((template) => `- ${template.uriTemplate} (${template.name}): ${template.description}`)
+                    .join("\n")
+
+                const resources = server.resources
+                    ?.map((resource) => `- ${resource.uri} (${resource.name}): ${resource.description}`)
+                    .join("\n")
+
+                const config = JSON.parse(server.config)
+
+                return (
+                    `## ${server.name} (\`${config.command}${config.args && Array.isArray(config.args) ? ` ${config.args.join(" ")}` : ""}\`)` +
+                    (tools ? `\n\n### Available Tools\n${tools}` : "") +
+                    (templates ? `\n\n### Resource Templates\n${templates}` : "") +
+                    (resources ? `\n\n### Direct Resources\n${resources}` : "")
+                )
+            })
+            .join("\n\n")}`
+        : "(No MCP servers currently connected)";
+
+    return `MCP SERVERS
+
+The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
+
+# Connected MCP Servers
+
+When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
+
+${connectedServers}
+
+## Creating an MCP Server
+
+The user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`.
+
+When creating MCP servers, it's important to understand that they operate in a non-interactive environment. The server cannot initiate OAuth flows, open browser windows, or prompt for user input during runtime. All credentials and authentication tokens must be provided upfront through environment variables in the MCP settings configuration. For example, Spotify's API uses OAuth to get a refresh token for the user, but the MCP server cannot initiate this flow. While you can walk the user through obtaining an application client ID and secret, you may have to create a separate one-time setup script (like get-refresh-token.js) that captures and logs the final piece of the puzzle: the user's refresh token (i.e. you might run the script using execute_command which would open a browser for authentication, and then log the refresh token so that you can see it in the command output for you to use in the MCP settings configuration).
+
+Unless the user specifies otherwise, new MCP servers should be created in: ${await mcpHub.getMcpServersPath()}
+
+### Example MCP Server
+
+For example, if the user wanted to give you the ability to retrieve weather information, you could create an MCP server that uses the OpenWeather API to get weather information, add it to the MCP settings configuration file, and then notice that you now have access to new tools and resources in the system prompt that you might use to show the user your new capabilities.
+
+The following example demonstrates how to build an MCP server that provides weather data functionality. While this example shows how to implement resources, resource templates, and tools, in practice you should prefer using tools since they are more flexible and can handle dynamic parameters. The resource and resource template implementations are included here mainly for demonstration purposes of the different MCP capabilities, but a real weather server would likely just expose tools for fetching weather data. (The following steps are for macOS)
+
+1. Use the \`create-typescript-server\` tool to bootstrap a new project in the default MCP servers directory:
+
+\`\`\`bash
+cd ${await mcpHub.getMcpServersPath()}
+npx @modelcontextprotocol/create-server weather-server
+cd weather-server
+# Install dependencies
+npm install axios
+\`\`\`
+
+This will create a new project with the following structure:
+
+\`\`\`
+weather-server/
+  ├── package.json
+      {
+        ...
+        "type": "module", // added by default, uses ES module syntax (import/export) rather than CommonJS (require/module.exports) (Important to know if you create additional scripts in this server repository like a get-refresh-token.js script)
+        "scripts": {
+          "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+          ...
+        }
+        ...
+      }
+  ├── tsconfig.json
+  └── src/
+      └── weather-server/
+          └── index.ts      # Main server implementation
+\`\`\`
+
+2. Replace \`src/index.ts\` with the following:
+
+\`\`\`typescript
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+
+const API_KEY = process.env.OPENWEATHER_API_KEY; // provided by MCP config
+if (!API_KEY) {
+  throw new Error('OPENWEATHER_API_KEY environment variable is required');
+}
+
+interface OpenWeatherResponse {
+  main: {
+    temp: number;
+    humidity: number;
+  };
+  weather: [{ description: string }];
+  wind: { speed: number };
+  dt_txt?: string;
+}
+
+const isValidForecastArgs = (
+  args: any
+): args is { city: string; days?: number } =>
+  typeof args === 'object' &&
+  args !== null &&
+  typeof args.city === 'string' &&
+  (args.days === undefined || typeof args.days === 'number');
+
+class WeatherServer {
+  private server: Server;
+  private axiosInstance;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'example-weather-server',
+        version: '0.1.0',
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {},
+        },
+      }
+    );
+
+    this.axiosInstance = axios.create({
+      baseURL: 'http://api.openweathermap.org/data/2.5',
+      params: {
+        appid: API_KEY,
+        units: 'metric',
+      },
+    });
+
+    this.setupResourceHandlers();
+    this.setupToolHandlers();
+    
+    // Error handling
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  // MCP Resources represent any kind of UTF-8 encoded data that an MCP server wants to make available to clients, such as database records, API responses, log files, and more. Servers define direct resources with a static URI or dynamic resources with a URI template that follows the format \`[protocol]://[host]/[path]\`.
+  private setupResourceHandlers() {
+    // For static resources, servers can expose a list of resources:
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: [
+        // This is a poor example since you could use the resource template to get the same information but this demonstrates how to define a static resource
+        {
+          uri: \`weather://San Francisco/current\`, // Unique identifier for San Francisco weather resource
+          name: \`Current weather in San Francisco\`, // Human-readable name
+          mimeType: 'application/json', // Optional MIME type
+          // Optional description
+          description:
+            'Real-time weather data for San Francisco including temperature, conditions, humidity, and wind speed',
+        },
+      ],
+    }));
+
+    // For dynamic resources, servers can expose resource templates:
+    this.server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async () => ({
+        resourceTemplates: [
+          {
+            uriTemplate: 'weather://{city}/current', // URI template (RFC 6570)
+            name: 'Current weather for a given city', // Human-readable name
+            mimeType: 'application/json', // Optional MIME type
+            description: 'Real-time weather data for a specified city', // Optional description
+          },
+        ],
+      })
+    );
+
+    // ReadResourceRequestSchema is used for both static resources and dynamic resource templates
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        const match = request.params.uri.match(
+          /^weather:\/\/([^/]+)\/current$/
+        );
+        if (!match) {
+          throw new McpError(
+            ErrorCode.InvalidRequest,
+            \`Invalid URI format: \${request.params.uri}\`
+          );
+        }
+        const city = decodeURIComponent(match[1]);
+
+        try {
+          const response = await this.axiosInstance.get(
+            'weather', // current weather
+            {
+              params: { q: city },
+            }
+          );
+
+          return {
+            contents: [
+              {
+                uri: request.params.uri,
+                mimeType: 'application/json',
+                text: JSON.stringify(
+                  {
+                    temperature: response.data.main.temp,
+                    conditions: response.data.weather[0].description,
+                    humidity: response.data.main.humidity,
+                    wind_speed: response.data.wind.speed,
+                    timestamp: new Date().toISOString(),
+                  },
+                  null,
+                  2
+                ),
+              },
+            ],
+          };
+        } catch (error) {
+          if (axios.isAxiosError(error)) {
+            throw new McpError(
+              ErrorCode.InternalError,
+              \`Weather API error: \${
+                error.response?.data.message ?? error.message
+              }\`
+            );
+          }
+          throw error;
+        }
+      }
+    );
+  }
+
+  /* MCP Tools enable servers to expose executable functionality to the system. Through these tools, you can interact with external systems, perform computations, and take actions in the real world.
+   * - Like resources, tools are identified by unique names and can include descriptions to guide their usage. However, unlike resources, tools represent dynamic operations that can modify state or interact with external systems.
+   * - While resources and tools are similar, you should prefer to create tools over resources when possible as they provide more flexibility.
+   */
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'get_forecast', // Unique identifier
+          description: 'Get weather forecast for a city', // Human-readable description
+          inputSchema: {
+            // JSON Schema for parameters
+            type: 'object',
+            properties: {
+              city: {
+                type: 'string',
+                description: 'City name',
+              },
+              days: {
+                type: 'number',
+                description: 'Number of days (1-5)',
+                minimum: 1,
+                maximum: 5,
+              },
+            },
+            required: ['city'], // Array of required property names
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name !== 'get_forecast') {
+        throw new McpError(
+          ErrorCode.MethodNotFound,
+          \`Unknown tool: \${request.params.name}\`
+        );
+      }
+
+      if (!isValidForecastArgs(request.params.arguments)) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          'Invalid forecast arguments'
+        );
+      }
+
+      const city = request.params.arguments.city;
+      const days = Math.min(request.params.arguments.days || 3, 5);
+
+      try {
+        const response = await this.axiosInstance.get<{
+          list: OpenWeatherResponse[];
+        }>('forecast', {
+          params: {
+            q: city,
+            cnt: days * 8,
+          },
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(response.data.list, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        if (axios.isAxiosError(error)) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: \`Weather API error: \${
+                  error.response?.data.message ?? error.message
+                }\`,
+              },
+            ],
+            isError: true,
+          };
+        }
+        throw error;
+      }
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('Weather MCP server running on stdio');
+  }
+}
+
+const server = new WeatherServer();
+server.run().catch(console.error);
+\`\`\`
+
+(Remember: This is just an example–you may use different dependencies, break the implementation up into multiple files, etc.)
+
+3. Build and compile the executable JavaScript file
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+4. Whenever you need an environment variable such as an API key to configure the MCP server, walk the user through the process of getting the key. For example, they may need to create an account and go to a developer dashboard to generate the key. Provide step-by-step instructions and URLs to make it easy for the user to retrieve the necessary information. Then use the ask_followup_question tool to ask the user for the key, in this case the OpenWeather API key.
+
+5. Install the MCP Server by adding the MCP server configuration to the settings file located at '${await mcpHub.getMcpSettingsFilePath()}'. The settings file may have other MCP servers already configured, so you would read it first and then add your new server to the existing \`mcpServers\` object.
+
+IMPORTANT: Regardless of what else you see in the MCP settings file, you must default any new MCP servers you create to disabled=false and alwaysAllow=[].
+
+\`\`\`json
+{
+  "mcpServers": {
+    ...,
+    "weather": {
+      "command": "node",
+      "args": ["/path/to/weather-server/build/index.js"],
+      "env": {
+        "OPENWEATHER_API_KEY": "user-provided-api-key"
+      }
+    },
+  }
+}
+\`\`\`
+
+(Note: the user may also ask you to install the MCP server to the Claude desktop app, in which case you would read then modify \`~/Library/Application\ Support/Claude/claude_desktop_config.json\` on macOS for example. It follows the same format of a top level \`mcpServers\` object.)
+
+6. After you have edited the MCP settings configuration file, the system will automatically run all the servers and expose the available tools and resources in the 'Connected MCP Servers' section.
+
+7. Now that you have access to these new tools and resources, you may suggest ways the user can command you to invoke them - for example, with this new weather tool now available, you can invite the user to ask "what's the weather in San Francisco?"
+
+## Editing MCP Servers
+
+The user may ask to add tools or resources that may make sense to add to an existing MCP server (listed under 'Connected MCP Servers' above: ${
+    mcpHub
+        .getServers()
+        .map((server) => server.name)
+        .join(", ") || "(None running currently)"
+}, e.g. if it would use the same API. This would be possible if you can locate the MCP server repository on the user's system by looking at the server arguments for a filepath. You might then use list_files and read_file to explore the files in the repository, and use write_to_file${diffStrategy ? " or apply_diff" : ""} to make changes to the files.
+
+However some MCP servers may be running from installed packages rather than a local repository, in which case it may make more sense to create a new MCP server.
+
+# MCP Servers Are Not Always Necessary
+
+The user may not always request the use or creation of MCP servers. Instead, they might provide tasks that can be completed with existing tools. While using the MCP SDK to extend your capabilities can be useful, it's important to understand that this is just one specialized type of task you can accomplish. You should only implement MCP servers when the user explicitly requests it (e.g., "add a tool that...").
+
+Remember: The MCP documentation and example provided above are to help you understand and work with existing MCP servers or create new ones when requested by the user. You already have access to tools and capabilities that can be used to accomplish a wide range of tasks.`
+}

src/core/prompts/sections/objective.ts

@@ -0,0 +1,13 @@
+export function getObjectiveSection(): string {
+    return `====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. \`open index.html\` to show the website you've built.
+5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`
+}

src/core/prompts/sections/rules.ts

@@ -0,0 +1,42 @@
+import { DiffStrategy } from "../../diff/DiffStrategy"
+
+export function getRulesSection(
+    cwd: string,
+    supportsComputerUse: boolean,
+    diffStrategy?: DiffStrategy
+): string {
+    return `====
+
+RULES
+
+- Your current working directory is: ${cwd.toPosix()}
+- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwd.toPosix()}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
+- Do not use the ~ character or $HOME to refer to the home directory.
+- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwd.toPosix()}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '${cwd.toPosix()}'). For example, if you needed to run \`npm install\` in a project outside of '${cwd.toPosix()}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
+- When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches before using write_to_file to make informed changes.
+- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when writing files, as the write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
+${diffStrategy ? "- You should use apply_diff instead of write_to_file when making changes to existing files since it is much faster and easier to apply a diff than to write the entire file again. Only use write_to_file to edit files when apply_diff has failed repeatedly to apply the diff." : "- When you want to modify a file, use the write_to_file tool directly with the desired content. You do not need to display the content before using the tool."}
+- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${
+       supportsComputerUse
+               ? '\n- The user may ask generic non-development tasks, such as "what\'s the latest news" or "look up the weather in San Diego", in which case you might use the browser_action tool to complete the task if it makes sense to do so, rather than trying to create a website or using curl to answer the question. However, if an available MCP server tool or resource can be used instead, you should prefer to use it over browser_action.'
+               : ""
+}
+- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
+- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
+- When using the write_to_file tool, ALWAYS provide the COMPLETE file content in your response. This is NON-NEGOTIABLE. Partial updates or placeholders like '// rest of code unchanged' are STRICTLY FORBIDDEN. You MUST include ALL parts of the file, even if they haven't been modified. Failure to do so will result in incomplete or broken code, severely impacting the user's project.
+- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${
+       supportsComputerUse
+               ? " Then if you want to test your work, you might use browser_action to launch the site, wait for the user's response confirming the site was launched along with a screenshot, then perhaps e.g., click a button to test functionality if needed, wait for the user's response confirming the button was clicked along with a screenshot of the new state, before finally closing the browser."
+               : ""
+}`
+}

src/core/prompts/sections/system-info.ts

@@ -0,0 +1,16 @@
+import defaultShell from "default-shell"
+import os from "os"
+import osName from "os-name"
+
+export function getSystemInfoSection(cwd: string): string {
+    return `====
+
+SYSTEM INFORMATION
+
+Operating System: ${osName()}
+Default Shell: ${defaultShell}
+Home Directory: ${os.homedir().toPosix()}
+Current Working Directory: ${cwd.toPosix()}
+
+When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('/test/path') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.`
+}

src/core/prompts/sections/tool-use-guidelines.ts

@@ -0,0 +1,22 @@
+export function getToolUseGuidelinesSection(): string {
+    return `# Tool Use Guidelines
+
+1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
+2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
+3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
+4. Formulate your tool use using the XML format specified for each tool.
+5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
+  - Information about whether the tool succeeded or failed, along with any reasons for failure.
+  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
+  - New terminal output in reaction to the changes, which you may need to consider or act upon.
+  - Any other relevant feedback or information related to the tool use.
+6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
+
+It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
+1. Confirm the success of each step before proceeding.
+2. Address any issues or errors that arise immediately.
+3. Adapt your approach based on new information or unexpected results.
+4. Ensure that each action builds correctly on the previous ones.
+
+By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.`
+}

src/core/prompts/sections/tool-use.ts

@@ -0,0 +1,25 @@
+export function getSharedToolUseSection(): string {
+    return `====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+# Tool Use Formatting
+
+Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
+
+<tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</tool_name>
+
+For example:
+
+<read_file>
+<path>src/main.js</path>
+</read_file>
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.`
+}

src/core/prompts/system.ts

@@ -1,766 +1,33 @@
-import defaultShell from "default-shell"
-import os from "os"
-import osName from "os-name"
-import fs from 'fs/promises'
-import path from 'path'
 import { DiffStrategy } from "../diff/DiffStrategy"
 import { McpHub } from "../../services/mcp/McpHub"
-
+import { CODE_PROMPT } from "./code"
-export const SYSTEM_PROMPT = async (
+import { ARCHITECT_PROMPT } from "./architect"
-	cwd: string,
+import { ASK_PROMPT } from "./ask"
-	supportsComputerUse: boolean,
+import { Mode, codeMode, architectMode, askMode } from "./modes"
-	mcpHub?: McpHub,
+import { CustomPrompts } from "../../shared/modes"
-	diffStrategy?: DiffStrategy,
+import fs from 'fs/promises'
-	browserViewportSize?: string
+import path from 'path'
-) => `You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
-
+async function loadRuleFiles(cwd: string, mode: Mode): Promise<string> {
-====
-
-TOOL USE
-
-You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
-
-# Tool Use Formatting
-
-Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-
-For example:
-
-<read_file>
-<path>src/main.js</path>
-</read_file>
-
-Always adhere to this format for the tool use to ensure proper parsing and execution.
-
-# Tools
-
-## execute_command
-Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${cwd.toPosix()}
-Parameters:
-- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
-Usage:
-<execute_command>
-<command>Your command here</command>
-</execute_command>
-
-## read_file
-Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. The output includes line numbers prefixed to each line (e.g. "1 | const x = 1"), making it easier to reference specific lines when creating diffs or discussing code. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
-Parameters:
-- path: (required) The path of the file to read (relative to the current working directory ${cwd.toPosix()})
-Usage:
-<read_file>
-<path>File path here</path>
-</read_file>
-
-## write_to_file
-Description: Request to write full content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
-Parameters:
-- path: (required) The path of the file to write to (relative to the current working directory ${cwd.toPosix()})
-- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include the line numbers in the content though, just the actual content of the file.
-- line_count: (required) The number of lines in the file. Make sure to compute this based on the actual content of the file, not the number of lines in the content you're providing.
-Usage:
-<write_to_file>
-<path>File path here</path>
-<content>
-Your file content here
-</content>
-<line_count>total number of lines in the file, including empty lines</line_count>
-</write_to_file>
-
-${diffStrategy ? diffStrategy.getToolDescription(cwd.toPosix()) : ""}
-
-## search_files
-Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.
-Parameters:
-- path: (required) The path of the directory to search in (relative to the current working directory ${cwd.toPosix()}). This directory will be recursively searched.
-- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
-- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
-Usage:
-<search_files>
-<path>Directory path here</path>
-<regex>Your regex pattern here</regex>
-<file_pattern>file pattern here (optional)</file_pattern>
-</search_files>
-
-## list_files
-Description: Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
-Parameters:
-- path: (required) The path of the directory to list contents for (relative to the current working directory ${cwd.toPosix()})
-- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
-Usage:
-<list_files>
-<path>Directory path here</path>
-<recursive>true or false (optional)</recursive>
-</list_files>
-
-## list_code_definition_names
-Description: Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.
-Parameters:
-- path: (required) The path of the directory (relative to the current working directory ${cwd.toPosix()}) to list top level source code definitions for.
-Usage:
-<list_code_definition_names>
-<path>Directory path here</path>
-</list_code_definition_names>${
-	supportsComputerUse
-		? `
-
-## browser_action
-Description: Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
-- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
-- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
-- The browser window has a resolution of **${browserViewportSize || "900x600"}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
-- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
-Parameters:
-- action: (required) The action to perform. The available actions are:
-    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
-        - Use with the \`url\` parameter to provide the URL.
-        - Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.)
-    * click: Click at a specific x,y coordinate.
-        - Use with the \`coordinate\` parameter to specify the location.
-        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
-    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
-        - Use with the \`text\` parameter to provide the string to type.
-    * scroll_down: Scroll down the page by one page height.
-    * scroll_up: Scroll up the page by one page height.
-    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
-        - Example: \`<action>close</action>\`
-- url: (optional) Use this for providing the URL for the \`launch\` action.
-    * Example: <url>https://example.com</url>
-- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${browserViewportSize || "900x600"}** resolution.
-    * Example: <coordinate>450,300</coordinate>
-- text: (optional) Use this for providing the text for the \`type\` action.
-    * Example: <text>Hello, world!</text>
-Usage:
-<browser_action>
-<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
-<url>URL to launch the browser at (optional)</url>
-<coordinate>x,y coordinates (optional)</coordinate>
-<text>Text to type (optional)</text>
-</browser_action>`
-		: ""
-}
-
-${mcpHub ? `
-## use_mcp_tool
-Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
-Parameters:
-- server_name: (required) The name of the MCP server providing the tool
-- tool_name: (required) The name of the tool to execute
-- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
-Usage:
-<use_mcp_tool>
-<server_name>server name here</server_name>
-<tool_name>tool name here</tool_name>
-<arguments>
-{
-  "param1": "value1",
-  "param2": "value2"
-}
-</arguments>
-</use_mcp_tool>
-
-## access_mcp_resource
-Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
-Parameters:
-- server_name: (required) The name of the MCP server providing the resource
-- uri: (required) The URI identifying the specific resource to access
-Usage:
-<access_mcp_resource>
-<server_name>server name here</server_name>
-<uri>resource URI here</uri>
-</access_mcp_resource>` : ''}
-
-## ask_followup_question
-Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
-Parameters:
-- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
-Usage:
-<ask_followup_question>
-<question>Your question here</question>
-</ask_followup_question>
-
-## attempt_completion
-Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
-IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
-Parameters:
-- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
-- command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. But DO NOT use commands like \`echo\` or \`cat\` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
-Usage:
-<attempt_completion>
-<result>
-Your final result description here
-</result>
-<command>Command to demonstrate result (optional)</command>
-</attempt_completion>
-
-# Tool Use Examples
-
-## Example 1: Requesting to execute a command
-
-<execute_command>
-<command>npm run dev</command>
-</execute_command>
-
-## Example 2: Requesting to write to a file
-
-<write_to_file>
-<path>frontend-config.json</path>
-<content>
-{
-  "apiEndpoint": "https://api.example.com",
-  "theme": {
-    "primaryColor": "#007bff",
-    "secondaryColor": "#6c757d",
-    "fontFamily": "Arial, sans-serif"
-  },
-  "features": {
-    "darkMode": true,
-    "notifications": true,
-    "analytics": false
-  },
-  "version": "1.0.0"
-}
-</content>
-<line_count>14</line_count>
-</write_to_file>
-
-${mcpHub ? `
-## Example 3: Requesting to use an MCP tool
-
-<use_mcp_tool>
-<server_name>weather-server</server_name>
-<tool_name>get_forecast</tool_name>
-<arguments>
-{
-  "city": "San Francisco",
-  "days": 5
-}
-</arguments>
-</use_mcp_tool>
-
-## Example 4: Requesting to access an MCP resource
-
-<access_mcp_resource>
-<server_name>weather-server</server_name>
-<uri>weather://san-francisco/current</uri>
-</access_mcp_resource>` : ''}
-
-# Tool Use Guidelines
-
-1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
-2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
-3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-4. Formulate your tool use using the XML format specified for each tool.
-5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
-  - Information about whether the tool succeeded or failed, along with any reasons for failure.
-  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
-  - New terminal output in reaction to the changes, which you may need to consider or act upon.
-  - Any other relevant feedback or information related to the tool use.
-6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
-
-It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
-1. Confirm the success of each step before proceeding.
-2. Address any issues or errors that arise immediately.
-3. Adapt your approach based on new information or unexpected results.
-4. Ensure that each action builds correctly on the previous ones.
-
-By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
-
-====
-
-${mcpHub ? `
-MCP SERVERS
-
-The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
-
-# Connected MCP Servers
-
-When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
-
-${
-	mcpHub.getServers().length > 0
-		? `${mcpHub
-				.getServers()
-				.filter((server) => server.status === "connected")
-				.map((server) => {
-					const tools = server.tools
-						?.map((tool) => {
-							const schemaStr = tool.inputSchema
-								? `    Input Schema:
-    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`
-								: ""
-
-							return `- ${tool.name}: ${tool.description}\n${schemaStr}`
-						})
-						.join("\n\n")
-
-					const templates = server.resourceTemplates
-						?.map((template) => `- ${template.uriTemplate} (${template.name}): ${template.description}`)
-						.join("\n")
-
-					const resources = server.resources
-						?.map((resource) => `- ${resource.uri} (${resource.name}): ${resource.description}`)
-						.join("\n")
-
-					const config = JSON.parse(server.config)
-
-					return (
-						`## ${server.name} (\`${config.command}${config.args && Array.isArray(config.args) ? ` ${config.args.join(" ")}` : ""}\`)` +
-						(tools ? `\n\n### Available Tools\n${tools}` : "") +
-						(templates ? `\n\n### Resource Templates\n${templates}` : "") +
-						(resources ? `\n\n### Direct Resources\n${resources}` : "")
-					)
-				})
-				.join("\n\n")}`
-		: "(No MCP servers currently connected)"
-}
-
-## Creating an MCP Server
-
-The user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`.
-
-When creating MCP servers, it's important to understand that they operate in a non-interactive environment. The server cannot initiate OAuth flows, open browser windows, or prompt for user input during runtime. All credentials and authentication tokens must be provided upfront through environment variables in the MCP settings configuration. For example, Spotify's API uses OAuth to get a refresh token for the user, but the MCP server cannot initiate this flow. While you can walk the user through obtaining an application client ID and secret, you may have to create a separate one-time setup script (like get-refresh-token.js) that captures and logs the final piece of the puzzle: the user's refresh token (i.e. you might run the script using execute_command which would open a browser for authentication, and then log the refresh token so that you can see it in the command output for you to use in the MCP settings configuration).
-
-Unless the user specifies otherwise, new MCP servers should be created in: ${await mcpHub.getMcpServersPath()}
-
-### Example MCP Server
-
-For example, if the user wanted to give you the ability to retrieve weather information, you could create an MCP server that uses the OpenWeather API to get weather information, add it to the MCP settings configuration file, and then notice that you now have access to new tools and resources in the system prompt that you might use to show the user your new capabilities.
-
-The following example demonstrates how to build an MCP server that provides weather data functionality. While this example shows how to implement resources, resource templates, and tools, in practice you should prefer using tools since they are more flexible and can handle dynamic parameters. The resource and resource template implementations are included here mainly for demonstration purposes of the different MCP capabilities, but a real weather server would likely just expose tools for fetching weather data. (The following steps are for macOS)
-
-1. Use the \`create-typescript-server\` tool to bootstrap a new project in the default MCP servers directory:
-
-\`\`\`bash
-cd ${await mcpHub.getMcpServersPath()}
-npx @modelcontextprotocol/create-server weather-server
-cd weather-server
-# Install dependencies
-npm install axios
-\`\`\`
-
-This will create a new project with the following structure:
-
-\`\`\`
-weather-server/
-  ├── package.json
-      {
-        ...
-        "type": "module", // added by default, uses ES module syntax (import/export) rather than CommonJS (require/module.exports) (Important to know if you create additional scripts in this server repository like a get-refresh-token.js script)
-        "scripts": {
-          "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
-          ...
-        }
-        ...
-      }
-  ├── tsconfig.json
-  └── src/
-      └── weather-server/
-          └── index.ts      # Main server implementation
-\`\`\`
-
-2. Replace \`src/index.ts\` with the following:
-
-\`\`\`typescript
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  McpError,
-  ReadResourceRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import axios from 'axios';
-
-const API_KEY = process.env.OPENWEATHER_API_KEY; // provided by MCP config
-if (!API_KEY) {
-  throw new Error('OPENWEATHER_API_KEY environment variable is required');
-}
-
-interface OpenWeatherResponse {
-  main: {
-    temp: number;
-    humidity: number;
-  };
-  weather: [{ description: string }];
-  wind: { speed: number };
-  dt_txt?: string;
-}
-
-const isValidForecastArgs = (
-  args: any
-): args is { city: string; days?: number } =>
-  typeof args === 'object' &&
-  args !== null &&
-  typeof args.city === 'string' &&
-  (args.days === undefined || typeof args.days === 'number');
-
-class WeatherServer {
-  private server: Server;
-  private axiosInstance;
-
-  constructor() {
-    this.server = new Server(
-      {
-        name: 'example-weather-server',
-        version: '0.1.0',
-      },
-      {
-        capabilities: {
-          resources: {},
-          tools: {},
-        },
-      }
-    );
-
-    this.axiosInstance = axios.create({
-      baseURL: 'http://api.openweathermap.org/data/2.5',
-      params: {
-        appid: API_KEY,
-        units: 'metric',
-      },
-    });
-
-    this.setupResourceHandlers();
-    this.setupToolHandlers();
-    
-    // Error handling
-    this.server.onerror = (error) => console.error('[MCP Error]', error);
-    process.on('SIGINT', async () => {
-      await this.server.close();
-      process.exit(0);
-    });
-  }
-
-  // MCP Resources represent any kind of UTF-8 encoded data that an MCP server wants to make available to clients, such as database records, API responses, log files, and more. Servers define direct resources with a static URI or dynamic resources with a URI template that follows the format \`[protocol]://[host]/[path]\`.
-  private setupResourceHandlers() {
-    // For static resources, servers can expose a list of resources:
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-      resources: [
-        // This is a poor example since you could use the resource template to get the same information but this demonstrates how to define a static resource
-        {
-          uri: \`weather://San Francisco/current\`, // Unique identifier for San Francisco weather resource
-          name: \`Current weather in San Francisco\`, // Human-readable name
-          mimeType: 'application/json', // Optional MIME type
-          // Optional description
-          description:
-            'Real-time weather data for San Francisco including temperature, conditions, humidity, and wind speed',
-        },
-      ],
-    }));
-
-    // For dynamic resources, servers can expose resource templates:
-    this.server.setRequestHandler(
-      ListResourceTemplatesRequestSchema,
-      async () => ({
-        resourceTemplates: [
-          {
-            uriTemplate: 'weather://{city}/current', // URI template (RFC 6570)
-            name: 'Current weather for a given city', // Human-readable name
-            mimeType: 'application/json', // Optional MIME type
-            description: 'Real-time weather data for a specified city', // Optional description
-          },
-        ],
-      })
-    );
-
-    // ReadResourceRequestSchema is used for both static resources and dynamic resource templates
-    this.server.setRequestHandler(
-      ReadResourceRequestSchema,
-      async (request) => {
-        const match = request.params.uri.match(
-          /^weather:\/\/([^/]+)\/current$/
-        );
-        if (!match) {
-          throw new McpError(
-            ErrorCode.InvalidRequest,
-            \`Invalid URI format: \${request.params.uri}\`
-          );
-        }
-        const city = decodeURIComponent(match[1]);
-
-        try {
-          const response = await this.axiosInstance.get(
-            'weather', // current weather
-            {
-              params: { q: city },
-            }
-          );
-
-          return {
-            contents: [
-              {
-                uri: request.params.uri,
-                mimeType: 'application/json',
-                text: JSON.stringify(
-                  {
-                    temperature: response.data.main.temp,
-                    conditions: response.data.weather[0].description,
-                    humidity: response.data.main.humidity,
-                    wind_speed: response.data.wind.speed,
-                    timestamp: new Date().toISOString(),
-                  },
-                  null,
-                  2
-                ),
-              },
-            ],
-          };
-        } catch (error) {
-          if (axios.isAxiosError(error)) {
-            throw new McpError(
-              ErrorCode.InternalError,
-              \`Weather API error: \${
-                error.response?.data.message ?? error.message
-              }\`
-            );
-          }
-          throw error;
-        }
-      }
-    );
-  }
-
-  /* MCP Tools enable servers to expose executable functionality to the system. Through these tools, you can interact with external systems, perform computations, and take actions in the real world.
-   * - Like resources, tools are identified by unique names and can include descriptions to guide their usage. However, unlike resources, tools represent dynamic operations that can modify state or interact with external systems.
-   * - While resources and tools are similar, you should prefer to create tools over resources when possible as they provide more flexibility.
-   */
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        {
-          name: 'get_forecast', // Unique identifier
-          description: 'Get weather forecast for a city', // Human-readable description
-          inputSchema: {
-            // JSON Schema for parameters
-            type: 'object',
-            properties: {
-              city: {
-                type: 'string',
-                description: 'City name',
-              },
-              days: {
-                type: 'number',
-                description: 'Number of days (1-5)',
-                minimum: 1,
-                maximum: 5,
-              },
-            },
-            required: ['city'], // Array of required property names
-          },
-        },
-      ],
-    }));
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      if (request.params.name !== 'get_forecast') {
-        throw new McpError(
-          ErrorCode.MethodNotFound,
-          \`Unknown tool: \${request.params.name}\`
-        );
-      }
-
-      if (!isValidForecastArgs(request.params.arguments)) {
-        throw new McpError(
-          ErrorCode.InvalidParams,
-          'Invalid forecast arguments'
-        );
-      }
-
-      const city = request.params.arguments.city;
-      const days = Math.min(request.params.arguments.days || 3, 5);
-
-      try {
-        const response = await this.axiosInstance.get<{
-          list: OpenWeatherResponse[];
-        }>('forecast', {
-          params: {
-            q: city,
-            cnt: days * 8,
-          },
-        });
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(response.data.list, null, 2),
-            },
-          ],
-        };
-      } catch (error) {
-        if (axios.isAxiosError(error)) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: \`Weather API error: \${
-                  error.response?.data.message ?? error.message
-                }\`,
-              },
-            ],
-            isError: true,
-          };
-        }
-        throw error;
-      }
-    });
-  }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    console.error('Weather MCP server running on stdio');
-  }
-}
-
-const server = new WeatherServer();
-server.run().catch(console.error);
-\`\`\`
-
-(Remember: This is just an example–you may use different dependencies, break the implementation up into multiple files, etc.)
-
-3. Build and compile the executable JavaScript file
-
-\`\`\`bash
-npm run build
-\`\`\`
-
-4. Whenever you need an environment variable such as an API key to configure the MCP server, walk the user through the process of getting the key. For example, they may need to create an account and go to a developer dashboard to generate the key. Provide step-by-step instructions and URLs to make it easy for the user to retrieve the necessary information. Then use the ask_followup_question tool to ask the user for the key, in this case the OpenWeather API key.
-
-5. Install the MCP Server by adding the MCP server configuration to the settings file located at '${await mcpHub.getMcpSettingsFilePath()}'. The settings file may have other MCP servers already configured, so you would read it first and then add your new server to the existing \`mcpServers\` object.
-
-IMPORTANT: Regardless of what else you see in the MCP settings file, you must default any new MCP servers you create to disabled=false and alwaysAllow=[].
-
-\`\`\`json
-{
-  "mcpServers": {
-    ...,
-    "weather": {
-      "command": "node",
-      "args": ["/path/to/weather-server/build/index.js"],
-      "env": {
-        "OPENWEATHER_API_KEY": "user-provided-api-key"
-      }
-    },
-  }
-}
-\`\`\`
-
-(Note: the user may also ask you to install the MCP server to the Claude desktop app, in which case you would read then modify \`~/Library/Application\ Support/Claude/claude_desktop_config.json\` on macOS for example. It follows the same format of a top level \`mcpServers\` object.)
-
-6. After you have edited the MCP settings configuration file, the system will automatically run all the servers and expose the available tools and resources in the 'Connected MCP Servers' section.
-
-7. Now that you have access to these new tools and resources, you may suggest ways the user can command you to invoke them - for example, with this new weather tool now available, you can invite the user to ask "what's the weather in San Francisco?"
-
-## Editing MCP Servers
-
-The user may ask to add tools or resources that may make sense to add to an existing MCP server (listed under 'Connected MCP Servers' above: ${
-	mcpHub
-		.getServers()
-		.map((server) => server.name)
-		.join(", ") || "(None running currently)"
-}, e.g. if it would use the same API. This would be possible if you can locate the MCP server repository on the user's system by looking at the server arguments for a filepath. You might then use list_files and read_file to explore the files in the repository, and use write_to_file ${diffStrategy ? "or apply_diff " : ""}to make changes to the files.
-
-However some MCP servers may be running from installed packages rather than a local repository, in which case it may make more sense to create a new MCP server.
-
-# MCP Servers Are Not Always Necessary
-
-The user may not always request the use or creation of MCP servers. Instead, they might provide tasks that can be completed with existing tools. While using the MCP SDK to extend your capabilities can be useful, it's important to understand that this is just one specialized type of task you can accomplish. You should only implement MCP servers when the user explicitly requests it (e.g., "add a tool that...").
-
-Remember: The MCP documentation and example provided above are to help you understand and work with existing MCP servers or create new ones when requested by the user. You already have access to tools and capabilities that can be used to accomplish a wide range of tasks.` : ''}
-
-====
- 
-CAPABILITIES
-
-- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search${
-	supportsComputerUse ? ", use the browser" : ""
-}, read and write files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
-- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('${cwd.toPosix()}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
-- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
-- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
-	- For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the write_to_file ${diffStrategy ? "or apply_diff " : ""}tool to apply the changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
-- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
-	supportsComputerUse
-		? "\n- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.\n	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser."
-		: ""
-}
-${mcpHub ? `
-- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
-` : ''}
-
-====
-
-RULES
-
-- Your current working directory is: ${cwd.toPosix()}
-- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwd.toPosix()}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
-- Do not use the ~ character or $HOME to refer to the home directory.
-- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwd.toPosix()}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '${cwd.toPosix()}'). For example, if you needed to run \`npm install\` in a project outside of '${cwd.toPosix()}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
-- When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches before using write_to_file to make informed changes.
-- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when writing files, as the write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
-${diffStrategy ? "- You should use apply_diff instead of write_to_file when making changes to existing files since it is much faster and easier to apply a diff than to write the entire file again. Only use write_to_file to edit files when apply_diff has failed repeatedly to apply the diff." : "- When you want to modify a file, use the write_to_file tool directly with the desired content. You do not need to display the content before using the tool."}
-- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
-- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
-- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
-- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
-- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
-- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
-- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${
-	supportsComputerUse
-		? '\n- The user may ask generic non-development tasks, such as "what\'s the latest news" or "look up the weather in San Diego", in which case you might use the browser_action tool to complete the task if it makes sense to do so, rather than trying to create a website or using curl to answer the question. However, if an available MCP server tool or resource can be used instead, you should prefer to use it over browser_action.'
-		: ""
-}
-- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
-- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
-- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
-- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
-- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
-- When using the write_to_file tool, ALWAYS provide the COMPLETE file content in your response. This is NON-NEGOTIABLE. Partial updates or placeholders like '// rest of code unchanged' are STRICTLY FORBIDDEN. You MUST include ALL parts of the file, even if they haven't been modified. Failure to do so will result in incomplete or broken code, severely impacting the user's project.
-- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
-- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${
-	supportsComputerUse
-		? " Then if you want to test your work, you might use browser_action to launch the site, wait for the user's response confirming the site was launched along with a screenshot, then perhaps e.g., click a button to test functionality if needed, wait for the user's response confirming the button was clicked along with a screenshot of the new state, before finally closing the browser."
-		: ""
-}
-
-====
-
-SYSTEM INFORMATION
-
-Operating System: ${osName()}
-Default Shell: ${defaultShell}
-Home Directory: ${os.homedir().toPosix()}
-Current Working Directory: ${cwd.toPosix()}
-
-====
-
-OBJECTIVE
-
-You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
-
-1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
-2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
-3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
-4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. \`open index.html\` to show the website you've built.
-5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`
-
-async function loadRuleFiles(cwd: string): Promise<string> {
-    const ruleFiles = ['.clinerules', '.cursorrules']
     let combinedRules = ''
 
-    for (const file of ruleFiles) {
+    // First try mode-specific rules
+    const modeSpecificFile = `.clinerules-${mode}`
+    try {
+        const content = await fs.readFile(path.join(cwd, modeSpecificFile), 'utf-8')
+        if (content.trim()) {
+            combinedRules += `\n# Rules from ${modeSpecificFile}:\n${content.trim()}\n`
+        }
+    } catch (err) {
+        // Silently skip if file doesn't exist
+        if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+            throw err
+        }
+    }
+
+    // Then try generic rules files
+    const genericRuleFiles = ['.clinerules']
+    for (const file of genericRuleFiles) {
         try {
             const content = await fs.readFile(path.join(cwd, file), 'utf-8')
             if (content.trim()) {
@@ -777,16 +44,30 @@ async function loadRuleFiles(cwd: string): Promise<string> {
     return combinedRules
 }
 
-export async function addCustomInstructions(customInstructions: string, cwd: string, preferredLanguage?: string): Promise<string> {
+interface State {
-    const ruleFileContent = await loadRuleFiles(cwd)
+    customInstructions?: string;
+    customPrompts?: CustomPrompts;
+    preferredLanguage?: string;
+}
+
+export async function addCustomInstructions(
+    state: State,
+    cwd: string,
+    mode: Mode = codeMode
+): Promise<string> {
+    const ruleFileContent = await loadRuleFiles(cwd, mode)
     const allInstructions = []
 
-    if (preferredLanguage) {
+    if (state.preferredLanguage) {
-        allInstructions.push(`You should always speak and think in the ${preferredLanguage} language.`)
+        allInstructions.push(`You should always speak and think in the ${state.preferredLanguage} language.`)
     }
 
-    if (customInstructions.trim()) {
+    if (state.customInstructions?.trim()) {
-        allInstructions.push(customInstructions.trim())
+        allInstructions.push(state.customInstructions.trim())
+    }
+
+    if (state.customPrompts?.[mode]?.customInstructions?.trim()) {
+        allInstructions.push(state.customPrompts[mode].customInstructions.trim())
     }
 
     if (ruleFileContent && ruleFileContent.trim()) {
@@ -803,5 +84,26 @@ USER'S CUSTOM INSTRUCTIONS
 The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
 
 ${joinedInstructions}`
-		: ""
+        : ""
 }
+
+export const SYSTEM_PROMPT = async (
+    cwd: string,
+    supportsComputerUse: boolean,
+    mcpHub?: McpHub,
+    diffStrategy?: DiffStrategy,
+    browserViewportSize?: string,
+    mode: Mode = codeMode,
+    customPrompts?: CustomPrompts,
+) => {
+    switch (mode) {
+        case architectMode:
+            return ARCHITECT_PROMPT(cwd, supportsComputerUse, mcpHub, diffStrategy, browserViewportSize, customPrompts?.architect)
+        case askMode:
+            return ASK_PROMPT(cwd, supportsComputerUse, mcpHub, diffStrategy, browserViewportSize, customPrompts?.ask)
+        default:
+            return CODE_PROMPT(cwd, supportsComputerUse, mcpHub, diffStrategy, browserViewportSize, customPrompts?.code)
+    }
+}
+
+export { codeMode, architectMode, askMode }

src/core/prompts/tools/access-mcp-resource.ts

@@ -0,0 +1,19 @@
+export function getAccessMcpResourceDescription(): string {
+    return `## access_mcp_resource
+Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
+Parameters:
+- server_name: (required) The name of the MCP server providing the resource
+- uri: (required) The URI identifying the specific resource to access
+Usage:
+<access_mcp_resource>
+<server_name>server name here</server_name>
+<uri>resource URI here</uri>
+</access_mcp_resource>
+
+Example: Requesting to access an MCP resource
+
+<access_mcp_resource>
+<server_name>weather-server</server_name>
+<uri>weather://san-francisco/current</uri>
+</access_mcp_resource>`
+}

src/core/prompts/tools/ask-followup-question.ts

@@ -0,0 +1,15 @@
+export function getAskFollowupQuestionDescription(): string {
+    return `## ask_followup_question
+Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
+Parameters:
+- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
+Usage:
+<ask_followup_question>
+<question>Your question here</question>
+</ask_followup_question>
+
+Example: Requesting to ask the user for the path to the frontend-config.json file
+<ask_followup_question>
+<question>What is the path to the frontend-config.json file?</question>
+</ask_followup_question>`
+}

src/core/prompts/tools/attempt-completion.ts

@@ -0,0 +1,23 @@
+export function getAttemptCompletionDescription(): string {
+    return `## attempt_completion
+Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
+IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
+Parameters:
+- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
+- command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. But DO NOT use commands like \`echo\` or \`cat\` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+Usage:
+<attempt_completion>
+<result>
+Your final result description here
+</result>
+<command>Command to demonstrate result (optional)</command>
+</attempt_completion>
+
+Example: Requesting to attempt completion with a result and command
+<attempt_completion>
+<result>
+I've updated the CSS
+</result>
+<command>open index.html</command>
+</attempt_completion>`
+}

src/core/prompts/tools/browser-action.ts

@@ -0,0 +1,47 @@
+export function getBrowserActionDescription(cwd: string, browserViewportSize: string = "900x600"): string {
+    return `## browser_action
+Description: Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
+- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
+- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
+- The browser window has a resolution of **${browserViewportSize}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
+- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
+Parameters:
+- action: (required) The action to perform. The available actions are:
+    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
+        - Use with the \`url\` parameter to provide the URL.
+        - Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.)
+    * click: Click at a specific x,y coordinate.
+        - Use with the \`coordinate\` parameter to specify the location.
+        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
+    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
+        - Use with the \`text\` parameter to provide the string to type.
+    * scroll_down: Scroll down the page by one page height.
+    * scroll_up: Scroll up the page by one page height.
+    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
+        - Example: \`<action>close</action>\`
+- url: (optional) Use this for providing the URL for the \`launch\` action.
+    * Example: <url>https://example.com</url>
+- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${browserViewportSize}** resolution.
+    * Example: <coordinate>450,300</coordinate>
+- text: (optional) Use this for providing the text for the \`type\` action.
+    * Example: <text>Hello, world!</text>
+Usage:
+<browser_action>
+<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
+<url>URL to launch the browser at (optional)</url>
+<coordinate>x,y coordinates (optional)</coordinate>
+<text>Text to type (optional)</text>
+</browser_action>
+
+Example: Requesting to launch a browser at https://example.com
+<browser_action>
+<action>launch</action>
+<url>https://example.com</url>
+</browser_action>
+
+Example: Requesting to click on the element at coordinates 450,300
+<browser_action>
+<action>click</action>
+<coordinate>450,300</coordinate>
+</browser_action>`
+}

src/core/prompts/tools/execute-command.ts

@@ -0,0 +1,15 @@
+export function getExecuteCommandDescription(cwd: string): string {
+    return `## execute_command
+Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${cwd}
+Parameters:
+- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
+Usage:
+<execute_command>
+<command>Your command here</command>
+</execute_command>
+
+Example: Requesting to execute npm run dev
+<execute_command>
+<command>npm run dev</command>
+</execute_command>`
+}

src/core/prompts/tools/index.ts

@@ -0,0 +1,101 @@
+import { getExecuteCommandDescription } from './execute-command'
+import { getReadFileDescription } from './read-file'
+import { getWriteToFileDescription } from './write-to-file'
+import { getSearchFilesDescription } from './search-files'
+import { getListFilesDescription } from './list-files'
+import { getListCodeDefinitionNamesDescription } from './list-code-definition-names'
+import { getBrowserActionDescription } from './browser-action'
+import { getAskFollowupQuestionDescription } from './ask-followup-question'
+import { getAttemptCompletionDescription } from './attempt-completion'
+import { getUseMcpToolDescription } from './use-mcp-tool'
+import { getAccessMcpResourceDescription } from './access-mcp-resource'
+import { DiffStrategy } from '../../diff/DiffStrategy'
+import { McpHub } from '../../../services/mcp/McpHub'
+import { Mode, codeMode, askMode } from '../modes'
+import { CODE_ALLOWED_TOOLS, READONLY_ALLOWED_TOOLS, ToolName, ReadOnlyToolName } from '../../tool-lists'
+
+type AllToolNames = ToolName | ReadOnlyToolName;
+
+// Helper function to safely check if a tool is allowed
+function hasAllowedTool(tools: readonly string[], tool: AllToolNames): boolean {
+    return tools.includes(tool);
+}
+
+export function getToolDescriptionsForMode(
+    mode: Mode,
+    cwd: string,
+    supportsComputerUse: boolean,
+    diffStrategy?: DiffStrategy,
+    browserViewportSize?: string,
+    mcpHub?: McpHub
+): string {
+    const descriptions = []
+
+    const allowedTools = mode === codeMode ? CODE_ALLOWED_TOOLS : READONLY_ALLOWED_TOOLS;
+
+    // Core tools based on mode
+    if (hasAllowedTool(allowedTools, 'execute_command')) {
+        descriptions.push(getExecuteCommandDescription(cwd));
+    }
+    if (hasAllowedTool(allowedTools, 'read_file')) {
+        descriptions.push(getReadFileDescription(cwd));
+    }
+    if (hasAllowedTool(allowedTools, 'write_to_file')) {
+        descriptions.push(getWriteToFileDescription(cwd));
+    }
+
+    // Optional diff strategy
+    if (diffStrategy && hasAllowedTool(allowedTools, 'apply_diff')) {
+        descriptions.push(diffStrategy.getToolDescription(cwd));
+    }
+
+    // File operation tools
+    if (hasAllowedTool(allowedTools, 'search_files')) {
+        descriptions.push(getSearchFilesDescription(cwd));
+    }
+    if (hasAllowedTool(allowedTools, 'list_files')) {
+        descriptions.push(getListFilesDescription(cwd));
+    }
+    if (hasAllowedTool(allowedTools, 'list_code_definition_names')) {
+        descriptions.push(getListCodeDefinitionNamesDescription(cwd));
+    }
+
+    // Browser actions
+    if (supportsComputerUse && hasAllowedTool(allowedTools, 'browser_action')) {
+        descriptions.push(getBrowserActionDescription(cwd, browserViewportSize));
+    }
+
+    // Common tools at the end
+    if (hasAllowedTool(allowedTools, 'ask_followup_question')) {
+        descriptions.push(getAskFollowupQuestionDescription());
+    }
+    if (hasAllowedTool(allowedTools, 'attempt_completion')) {
+        descriptions.push(getAttemptCompletionDescription());
+    }
+
+    // MCP tools if available
+    if (mcpHub) {
+        if (hasAllowedTool(allowedTools, 'use_mcp_tool')) {
+            descriptions.push(getUseMcpToolDescription());
+        }
+        if (hasAllowedTool(allowedTools, 'access_mcp_resource')) {
+            descriptions.push(getAccessMcpResourceDescription());
+        }
+    }
+
+    return `# Tools\n\n${descriptions.filter(Boolean).join('\n\n')}`
+}
+
+export {
+    getExecuteCommandDescription,
+    getReadFileDescription,
+    getWriteToFileDescription,
+    getSearchFilesDescription,
+    getListFilesDescription,
+    getListCodeDefinitionNamesDescription,
+    getBrowserActionDescription,
+    getAskFollowupQuestionDescription,
+    getAttemptCompletionDescription,
+    getUseMcpToolDescription,
+    getAccessMcpResourceDescription
+}

src/core/prompts/tools/list-code-definition-names.ts

@@ -0,0 +1,15 @@
+export function getListCodeDefinitionNamesDescription(cwd: string): string {
+    return `## list_code_definition_names
+Description: Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.
+Parameters:
+- path: (required) The path of the directory (relative to the current working directory ${cwd.toPosix()}) to list top level source code definitions for.
+Usage:
+<list_code_definition_names>
+<path>Directory path here</path>
+</list_code_definition_names>
+
+Example: Requesting to list all top level source code definitions in the current directory
+<list_code_definition_names>
+<path>.</path>
+</list_code_definition_names>`
+}

src/core/prompts/tools/list-files.ts

@@ -0,0 +1,18 @@
+export function getListFilesDescription(cwd: string): string {
+    return `## list_files
+Description: Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
+Parameters:
+- path: (required) The path of the directory to list contents for (relative to the current working directory ${cwd.toPosix()})
+- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
+Usage:
+<list_files>
+<path>Directory path here</path>
+<recursive>true or false (optional)</recursive>
+</list_files>
+
+Example: Requesting to list all files in the current directory
+<list_files>
+<path>.</path>
+<recursive>false</recursive>
+</list_files>`
+}

src/core/prompts/tools/read-file.ts

@@ -0,0 +1,15 @@
+export function getReadFileDescription(cwd: string): string {
+    return `## read_file
+Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. The output includes line numbers prefixed to each line (e.g. "1 | const x = 1"), making it easier to reference specific lines when creating diffs or discussing code. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
+Parameters:
+- path: (required) The path of the file to read (relative to the current working directory ${cwd})
+Usage:
+<read_file>
+<path>File path here</path>
+</read_file>
+
+Example: Requesting to read frontend-config.json
+<read_file>
+<path>frontend-config.json</path>
+</read_file>`
+}

src/core/prompts/tools/search-files.ts

@@ -0,0 +1,21 @@
+export function getSearchFilesDescription(cwd: string): string {
+    return `## search_files
+Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current working directory ${cwd.toPosix()}). This directory will be recursively searched.
+- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
+- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
+Usage:
+<search_files>
+<path>Directory path here</path>
+<regex>Your regex pattern here</regex>
+<file_pattern>file pattern here (optional)</file_pattern>
+</search_files>
+
+Example: Requesting to search for all .ts files in the current directory
+<search_files>
+<path>.</path>
+<regex>.*</regex>
+<file_pattern>*.ts</file_pattern>
+</search_files>`
+}

src/core/prompts/tools/use-mcp-tool.ts

@@ -0,0 +1,32 @@
+export function getUseMcpToolDescription(): string {
+    return `## use_mcp_tool
+Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
+Parameters:
+- server_name: (required) The name of the MCP server providing the tool
+- tool_name: (required) The name of the tool to execute
+- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
+Usage:
+<use_mcp_tool>
+<server_name>server name here</server_name>
+<tool_name>tool name here</tool_name>
+<arguments>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</arguments>
+</use_mcp_tool>
+
+Example: Requesting to use an MCP tool
+
+<use_mcp_tool>
+<server_name>weather-server</server_name>
+<tool_name>get_forecast</tool_name>
+<arguments>
+{
+  "city": "San Francisco",
+  "days": 5
+}
+</arguments>
+</use_mcp_tool>`
+}

src/core/prompts/tools/write-to-file.ts

@@ -0,0 +1,38 @@
+export function getWriteToFileDescription(cwd: string): string {
+    return `## write_to_file
+Description: Request to write full content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
+Parameters:
+- path: (required) The path of the file to write to (relative to the current working directory ${cwd.toPosix()})
+- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include the line numbers in the content though, just the actual content of the file.
+- line_count: (required) The number of lines in the file. Make sure to compute this based on the actual content of the file, not the number of lines in the content you're providing.
+Usage:
+<write_to_file>
+<path>File path here</path>
+<content>
+Your file content here
+</content>
+<line_count>total number of lines in the file, including empty lines</line_count>
+</write_to_file>
+
+Example: Requesting to write to frontend-config.json
+<write_to_file>
+<path>frontend-config.json</path>
+<content>
+{
+  "apiEndpoint": "https://api.example.com",
+  "theme": {
+    "primaryColor": "#007bff",
+    "secondaryColor": "#6c757d",
+    "fontFamily": "Arial, sans-serif"
+  },
+  "features": {
+    "darkMode": true,
+    "notifications": true,
+    "analytics": false
+  },
+  "version": "1.0.0"
+}
+</content>
+<line_count>14</line_count>
+</write_to_file>`
+}

src/core/prompts/types.ts

@@ -0,0 +1,52 @@
+import { Mode } from '../../shared/modes';
+
+export type { Mode };
+
+export type ToolName =
+  | 'execute_command'
+  | 'read_file'
+  | 'write_to_file'
+  | 'apply_diff'
+  | 'search_files'
+  | 'list_files'
+  | 'list_code_definition_names'
+  | 'browser_action'
+  | 'use_mcp_tool'
+  | 'access_mcp_resource'
+  | 'ask_followup_question'
+  | 'attempt_completion';
+
+export const CODE_TOOLS: ToolName[] = [
+  'execute_command',
+  'read_file',
+  'write_to_file',
+  'apply_diff',
+  'search_files',
+  'list_files',
+  'list_code_definition_names',
+  'browser_action',
+  'use_mcp_tool',
+  'access_mcp_resource',
+  'ask_followup_question',
+  'attempt_completion'
+];
+
+export const ARCHITECT_TOOLS: ToolName[] = [
+  'read_file',
+  'search_files',
+  'list_files',
+  'list_code_definition_names',
+  'ask_followup_question',
+  'attempt_completion'
+];
+
+export const ASK_TOOLS: ToolName[] = [
+  'read_file',
+  'search_files',
+  'list_files',
+  'browser_action',
+  'use_mcp_tool',
+  'access_mcp_resource',
+  'ask_followup_question',
+  'attempt_completion'
+];

src/core/tool-lists.ts

@@ -0,0 +1,32 @@
+// Shared tools for architect and ask modes - read-only operations plus MCP and browser tools
+export const READONLY_ALLOWED_TOOLS = [
+    'read_file',
+    'search_files',
+    'list_files',
+    'list_code_definition_names',
+    'browser_action',
+    'use_mcp_tool',
+    'access_mcp_resource',
+    'ask_followup_question',
+    'attempt_completion'
+] as const;
+
+// Code mode has access to all tools
+export const CODE_ALLOWED_TOOLS = [
+    'execute_command',
+    'read_file',
+    'write_to_file',
+    'apply_diff',
+    'search_files',
+    'list_files',
+    'list_code_definition_names',
+    'browser_action',
+    'use_mcp_tool',
+    'access_mcp_resource',
+    'ask_followup_question',
+    'attempt_completion'
+] as const;
+
+// Tool name types for type safety
+export type ReadOnlyToolName = typeof READONLY_ALLOWED_TOOLS[number];
+export type ToolName = typeof CODE_ALLOWED_TOOLS[number];

src/core/webview/ClineProvider.ts

@@ -12,19 +12,25 @@ import { selectImages } from "../../integrations/misc/process-images"
 import { getTheme } from "../../integrations/theme/getTheme"
 import WorkspaceTracker from "../../integrations/workspace/WorkspaceTracker"
 import { McpHub } from "../../services/mcp/McpHub"
-import { ApiProvider, ModelInfo } from "../../shared/api"
+import { ApiConfiguration, ApiProvider, ModelInfo } from "../../shared/api"
 import { findLast } from "../../shared/array"
-import { ExtensionMessage } from "../../shared/ExtensionMessage"
+import { ApiConfigMeta, ExtensionMessage } from "../../shared/ExtensionMessage"
 import { HistoryItem } from "../../shared/HistoryItem"
-import { WebviewMessage } from "../../shared/WebviewMessage"
+import { WebviewMessage, PromptMode } from "../../shared/WebviewMessage"
+import { defaultPrompts } from "../../shared/modes"
+import { SYSTEM_PROMPT, addCustomInstructions } from "../prompts/system"
 import { fileExistsAtPath } from "../../utils/fs"
 import { Cline } from "../Cline"
 import { openMention } from "../mentions"
 import { getNonce } from "./getNonce"
 import { getUri } from "./getUri"
 import { playSound, setSoundEnabled, setSoundVolume } from "../../utils/sound"
+import { checkExistKey } from "../../shared/checkExistApiConfig"
 import { enhancePrompt } from "../../utils/enhance-prompt"
 import { getCommitInfo, searchCommits, getWorkingState } from "../../utils/git"
+import { ConfigManager } from "../config/ConfigManager"
+import { Mode } from "../prompts/types"
+import { codeMode, CustomPrompts } from "../../shared/modes"
 
 /*
 https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -85,7 +91,14 @@ type GlobalStateKey =
 	| "mcpEnabled"
 	| "alwaysApproveResubmit"
 	| "requestDelaySeconds"
-	| "experimentalDiffStrategy"
+	| "currentApiConfigName"
+	| "listApiConfigMeta"
+	| "mode"
+	| "modeApiConfigs"
+	| "customPrompts"
+	| "enhancementApiConfigId",
+  | "experimentalDiffStrategy"
+
 export const GlobalFileNames = {
 	apiConversationHistory: "api_conversation_history.json",
 	uiMessages: "ui_messages.json",
@@ -103,7 +116,8 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 	private cline?: Cline
 	private workspaceTracker?: WorkspaceTracker
 	mcpHub?: McpHub
-	private latestAnnouncementId = "dec-10-2024" // update to some unique identifier when we add a new announcement
+	private latestAnnouncementId = "jan-13-2025-custom-prompt" // update to some unique identifier when we add a new announcement
+	configManager: ConfigManager
 
 	constructor(
 		readonly context: vscode.ExtensionContext,
@@ -113,6 +127,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		ClineProvider.activeInstances.add(this)
 		this.workspaceTracker = new WorkspaceTracker(this)
 		this.mcpHub = new McpHub(this)
+		this.configManager = new ConfigManager(this.context)
 	}
 
 	/*
@@ -228,20 +243,27 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		this.outputChannel.appendLine("Webview view resolved")
 	}
 
-	async initClineWithTask(task?: string, images?: string[]) {
+	public async initClineWithTask(task?: string, images?: string[]) {
 		await this.clearTask()
 		const {
 			apiConfiguration,
-			customInstructions,
+			customPrompts,
 			diffEnabled,
 			fuzzyMatchThreshold,
-			experimentalDiffStrategy
+			mode,
+			customInstructions: globalInstructions,
+      experimentalDiffStrategy
 		} = await this.getState()
 
+		const modeInstructions = customPrompts?.[mode]?.customInstructions
+		const effectiveInstructions = [globalInstructions, modeInstructions]
+			.filter(Boolean)
+			.join('\n\n')
+
 		this.cline = new Cline(
 			this,
 			apiConfiguration,
-			customInstructions,
+			effectiveInstructions,
 			diffEnabled,
 			fuzzyMatchThreshold,
 			task,
@@ -251,20 +273,27 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		)
 	}
 
-	async initClineWithHistoryItem(historyItem: HistoryItem) {
+	public async initClineWithHistoryItem(historyItem: HistoryItem) {
 		await this.clearTask()
 		const {
 			apiConfiguration,
-			customInstructions,
+			customPrompts,
 			diffEnabled,
 			fuzzyMatchThreshold,
-			experimentalDiffStrategy
+			mode,
+			customInstructions: globalInstructions,
+      experimentalDiffStrategy
 		} = await this.getState()
 
+		const modeInstructions = customPrompts?.[mode]?.customInstructions
+		const effectiveInstructions = [globalInstructions, modeInstructions]
+			.filter(Boolean)
+			.join('\n\n')
+
 		this.cline = new Cline(
 			this,
 			apiConfiguration,
-			customInstructions,
+			effectiveInstructions,
 			diffEnabled,
 			fuzzyMatchThreshold,
 			undefined,
@@ -274,8 +303,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		)
 	}
 
-	// Send any JSON serializable data to the react app
+	public async postMessageToWebview(message: ExtensionMessage) {
-	async postMessageToWebview(message: ExtensionMessage) {
 		await this.view?.webview.postMessage(message)
 	}
 
@@ -327,15 +355,15 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 
 		// Use a nonce to only allow a specific script to be run.
 		/*
-        content security policy of your webview to only allow scripts that have a specific nonce
+		content security policy of your webview to only allow scripts that have a specific nonce
-        create a content security policy meta tag so that only loading scripts with a nonce is allowed
+		create a content security policy meta tag so that only loading scripts with a nonce is allowed
-        As your extension grows you will likely want to add custom styles, fonts, and/or images to your webview. If you do, you will need to update the content security policy meta tag to explicity allow for these resources. E.g.
+		As your extension grows you will likely want to add custom styles, fonts, and/or images to your webview. If you do, you will need to update the content security policy meta tag to explicity allow for these resources. E.g.
-                <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource}; font-src ${webview.cspSource}; img-src ${webview.cspSource} https:; script-src 'nonce-${nonce}';">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource}; font-src ${webview.cspSource}; img-src ${webview.cspSource} https:; script-src 'nonce-${nonce}';">
 		- 'unsafe-inline' is required for styles due to vscode-webview-toolkit's dynamic style injection
 		- since we pass base64 images to the webview, we need to specify img-src ${webview.cspSource} data:;
 
-        in meta tag we add nonce attribute: A cryptographic nonce (only used once) to allow scripts. The server must generate a unique nonce value each time it transmits a policy. It is critical to provide a nonce that cannot be guessed as bypassing a resource's policy is otherwise trivial.
+		in meta tag we add nonce attribute: A cryptographic nonce (only used once) to allow scripts. The server must generate a unique nonce value each time it transmits a policy. It is critical to provide a nonce that cannot be guessed as bypassing a resource's policy is otherwise trivial.
-        */
+		*/
 		const nonce = getNonce()
 
 		// Tip: Install the es6-string-html VS Code extension to enable code highlighting below
@@ -371,6 +399,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			async (message: WebviewMessage) => {
 				switch (message.type) {
 					case "webviewDidLaunch":
+
 						this.postStateToWebview()
 						this.workspaceTracker?.initializeFilePaths() // don't await
 						getTheme().then((theme) =>
@@ -416,6 +445,55 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 								}
 							}
 						})
+
+
+						this.configManager.ListConfig().then(async (listApiConfig) => {
+
+							if (!listApiConfig) {
+								return
+							}
+
+							if (listApiConfig.length === 1) {
+								// check if first time init then sync with exist config
+								if (!checkExistKey(listApiConfig[0])) {
+									const {
+										apiConfiguration,
+									} = await this.getState()
+									await this.configManager.SaveConfig(listApiConfig[0].name ?? "default", apiConfiguration)
+									listApiConfig[0].apiProvider = apiConfiguration.apiProvider
+								}
+							}
+
+							let currentConfigName = await this.getGlobalState("currentApiConfigName") as string
+
+							if (currentConfigName) {
+								if (!await this.configManager.HasConfig(currentConfigName)) {
+									// current config name not valid, get first config in list
+									await this.updateGlobalState("currentApiConfigName", listApiConfig?.[0]?.name)
+									if (listApiConfig?.[0]?.name) {
+										const apiConfig = await this.configManager.LoadConfig(listApiConfig?.[0]?.name);
+
+										await Promise.all([
+											this.updateGlobalState("listApiConfigMeta", listApiConfig),
+											this.postMessageToWebview({ type: "listApiConfig", listApiConfig }),
+											this.updateApiConfiguration(apiConfig),
+										])
+										await this.postStateToWebview()
+										return
+									}
+
+								}
+							}
+
+
+							await Promise.all(
+								[
+									await this.updateGlobalState("listApiConfigMeta", listApiConfig),
+									await this.postMessageToWebview({ type: "listApiConfig", listApiConfig })
+								]
+							)
+						}).catch(console.error);
+
 						break
 					case "newTask":
 						// Code that should run in response to the hello message command
@@ -430,70 +508,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						break
 					case "apiConfiguration":
 						if (message.apiConfiguration) {
-							const {
+							await this.updateApiConfiguration(message.apiConfiguration)
-								apiProvider,
-								apiModelId,
-								apiKey,
-								glamaModelId,
-								glamaModelInfo,
-								glamaApiKey,
-								openRouterApiKey,
-								awsAccessKey,
-								awsSecretKey,
-								awsSessionToken,
-								awsRegion,
-								awsUseCrossRegionInference,
-								vertexProjectId,
-								vertexRegion,
-								openAiBaseUrl,
-								openAiApiKey,
-								openAiModelId,
-								ollamaModelId,
-								ollamaBaseUrl,
-								lmStudioModelId,
-								lmStudioBaseUrl,
-								anthropicBaseUrl,
-								geminiApiKey,
-								openAiNativeApiKey,
-								azureApiVersion,
-								openAiStreamingEnabled,
-								openRouterModelId,
-								openRouterModelInfo,
-								openRouterUseMiddleOutTransform,
-							} = message.apiConfiguration
-							await this.updateGlobalState("apiProvider", apiProvider)
-							await this.updateGlobalState("apiModelId", apiModelId)
-							await this.storeSecret("apiKey", apiKey)
-							await this.updateGlobalState("glamaModelId", glamaModelId)
-							await this.updateGlobalState("glamaModelInfo", glamaModelInfo)
-							await this.storeSecret("glamaApiKey", glamaApiKey)
-							await this.storeSecret("openRouterApiKey", openRouterApiKey)
-							await this.storeSecret("awsAccessKey", awsAccessKey)
-							await this.storeSecret("awsSecretKey", awsSecretKey)
-							await this.storeSecret("awsSessionToken", awsSessionToken)
-							await this.updateGlobalState("awsRegion", awsRegion)
-							await this.updateGlobalState("awsUseCrossRegionInference", awsUseCrossRegionInference)
-							await this.updateGlobalState("vertexProjectId", vertexProjectId)
-							await this.updateGlobalState("vertexRegion", vertexRegion)
-							await this.updateGlobalState("openAiBaseUrl", openAiBaseUrl)
-							await this.storeSecret("openAiApiKey", openAiApiKey)
-							await this.updateGlobalState("openAiModelId", openAiModelId)
-							await this.updateGlobalState("ollamaModelId", ollamaModelId)
-							await this.updateGlobalState("ollamaBaseUrl", ollamaBaseUrl)
-							await this.updateGlobalState("lmStudioModelId", lmStudioModelId)
-							await this.updateGlobalState("lmStudioBaseUrl", lmStudioBaseUrl)
-							await this.updateGlobalState("anthropicBaseUrl", anthropicBaseUrl)
-							await this.storeSecret("geminiApiKey", geminiApiKey)
-							await this.storeSecret("openAiNativeApiKey", openAiNativeApiKey)
-							await this.storeSecret("deepSeekApiKey", message.apiConfiguration.deepSeekApiKey)
-							await this.updateGlobalState("azureApiVersion", azureApiVersion)
-							await this.updateGlobalState("openAiStreamingEnabled", openAiStreamingEnabled)
-							await this.updateGlobalState("openRouterModelId", openRouterModelId)
-							await this.updateGlobalState("openRouterModelInfo", openRouterModelInfo)
-							await this.updateGlobalState("openRouterUseMiddleOutTransform", openRouterUseMiddleOutTransform)
-							if (this.cline) {
-								this.cline.api = buildApiHandler(message.apiConfiguration)
-							}
 						}
 						await this.postStateToWebview()
 						break
@@ -578,7 +593,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						openImage(message.text!)
 						break
 					case "openFile":
-						openFile(message.text!)
+						openFile(message.text!, message.values as { create?: boolean; content?: string })
 						break
 					case "openMention":
 						openMention(message.text)
@@ -703,6 +718,90 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						await this.updateGlobalState("terminalOutputLineLimit", message.value)
 						await this.postStateToWebview()
 						break
+					case "mode":
+						const newMode = message.text as Mode
+						await this.updateGlobalState("mode", newMode)
+						
+						// Load the saved API config for the new mode if it exists
+						const savedConfigId = await this.configManager.GetModeConfigId(newMode)
+						const listApiConfig = await this.configManager.ListConfig()
+						
+						// Update listApiConfigMeta first to ensure UI has latest data
+						await this.updateGlobalState("listApiConfigMeta", listApiConfig)
+						
+						// If this mode has a saved config, use it
+						if (savedConfigId) {
+							const config = listApiConfig?.find(c => c.id === savedConfigId)
+							if (config?.name) {
+								const apiConfig = await this.configManager.LoadConfig(config.name)
+								await Promise.all([
+									this.updateGlobalState("currentApiConfigName", config.name),
+									this.updateApiConfiguration(apiConfig)
+								])
+							}
+						} else {
+							// If no saved config for this mode, save current config as default
+							const currentApiConfigName = await this.getGlobalState("currentApiConfigName")
+							if (currentApiConfigName) {
+								const config = listApiConfig?.find(c => c.name === currentApiConfigName)
+								if (config?.id) {
+									await this.configManager.SetModeConfig(newMode, config.id)
+								}
+							}
+						}
+						
+						await this.postStateToWebview()
+						break
+					case "updateEnhancedPrompt":
+						const existingPrompts = await this.getGlobalState("customPrompts") || {}
+						
+						const updatedPrompts = {
+							...existingPrompts,
+							enhance: message.text
+						}
+						
+						await this.updateGlobalState("customPrompts", updatedPrompts)
+						
+						// Get current state and explicitly include customPrompts
+						const currentState = await this.getState()
+						
+						const stateWithPrompts = {
+							...currentState,
+							customPrompts: updatedPrompts
+						}
+						
+						// Post state with prompts
+						this.view?.webview.postMessage({
+							type: "state",
+							state: stateWithPrompts
+						})
+						break
+					case "updatePrompt":
+						if (message.promptMode && message.customPrompt !== undefined) {
+							const existingPrompts = await this.getGlobalState("customPrompts") || {}
+							
+							const updatedPrompts = {
+								...existingPrompts,
+								[message.promptMode]: message.customPrompt
+							}
+							
+							await this.updateGlobalState("customPrompts", updatedPrompts)
+							
+							// Get current state and explicitly include customPrompts
+							const currentState = await this.getState()
+							
+							const stateWithPrompts = {
+								...currentState,
+								customPrompts: updatedPrompts
+							}
+							
+							// Post state with prompts
+							this.view?.webview.postMessage({
+								type: "state",
+								state: stateWithPrompts
+							})
+						}
+						break
 					case "deleteMessage": {
 						const answer = await vscode.window.showInformationMessage(
 							"What would you like to delete?",
@@ -773,16 +872,28 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						await this.updateGlobalState("screenshotQuality", message.value)
 						await this.postStateToWebview()
 						break
+					case "enhancementApiConfigId":
+						await this.updateGlobalState("enhancementApiConfigId", message.text)
+						await this.postStateToWebview()
+						break
 					case "enhancePrompt":
 						if (message.text) {
 							try {
-								const { apiConfiguration } = await this.getState()
+								const { apiConfiguration, customPrompts, listApiConfigMeta, enhancementApiConfigId } = await this.getState()
-								const enhanceConfig = {
+								
-									...apiConfiguration,
+								// Try to get enhancement config first, fall back to current config
-									apiProvider: "openrouter" as const,
+								let configToUse: ApiConfiguration = apiConfiguration
-									openRouterModelId: "gpt-4o",
+								if (enhancementApiConfigId) {
+									const config = listApiConfigMeta?.find(c => c.id === enhancementApiConfigId)
+									if (config?.name) {
+										const loadedConfig = await this.configManager.LoadConfig(config.name)
+										if (loadedConfig.apiProvider) {
+											configToUse = loadedConfig
+										}
+									}
 								}
-								const enhancedPrompt = await enhancePrompt(enhanceConfig, message.text)
+								
+								const enhancedPrompt = await enhancePrompt(configToUse, message.text, customPrompts?.enhance)
 								await this.postMessageToWebview({
 									type: "enhancedPrompt",
 									text: enhancedPrompt
@@ -790,11 +901,45 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 							} catch (error) {
 								console.error("Error enhancing prompt:", error)
 								vscode.window.showErrorMessage("Failed to enhance prompt")
+								await this.postMessageToWebview({
+									type: "enhancedPrompt"
+								})
 							}
 						}
 						break
+					case "getSystemPrompt":
+						try {
+							const { apiConfiguration, customPrompts, customInstructions, preferredLanguage, browserViewportSize, mcpEnabled } = await this.getState()
+							const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) || ''
 
+							const mode = message.mode ?? codeMode
+							const instructions = await addCustomInstructions(
+								{ customInstructions, customPrompts, preferredLanguage },
+								cwd,
+								mode
+							)
 
+							const systemPrompt = await SYSTEM_PROMPT(
+								cwd,
+								apiConfiguration.openRouterModelInfo?.supportsComputerUse ?? false,
+								mcpEnabled ? this.mcpHub : undefined,
+								undefined,
+								browserViewportSize ?? "900x600",
+								mode,
+								customPrompts
+							)
+							const fullPrompt = instructions ? `${systemPrompt}${instructions}` : systemPrompt
+							
+							await this.postMessageToWebview({
+								type: "systemPrompt",
+								text: fullPrompt,
+								mode: message.mode
+							})
+						} catch (error) {
+							console.error("Error getting system prompt:", error)
+							vscode.window.showErrorMessage("Failed to get system prompt")
+						}
+						break
 					case "searchCommits": {
 						const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
 						if (cwd) {
@@ -811,10 +956,123 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 						}
 						break
 					}
-					case "experimentalDiffStrategy":
+					case "upsertApiConfiguration":
+						if (message.text && message.apiConfiguration) {
+							try {
+								await this.configManager.SaveConfig(message.text, message.apiConfiguration);
+								let listApiConfig = await this.configManager.ListConfig();
+								
+								// Update listApiConfigMeta first to ensure UI has latest data
+								await this.updateGlobalState("listApiConfigMeta", listApiConfig);
+
+								await Promise.all([
+									this.updateApiConfiguration(message.apiConfiguration),
+									this.updateGlobalState("currentApiConfigName", message.text),
+								])
+
+								await this.postStateToWebview()
+							} catch (error) {
+								console.error("Error create new api configuration:", error)
+								vscode.window.showErrorMessage("Failed to create api configuration")
+							}
+						}
+						break
+					case "renameApiConfiguration":
+						if (message.values && message.apiConfiguration) {
+							try {
+								const { oldName, newName } = message.values
+
+								await this.configManager.SaveConfig(newName, message.apiConfiguration);
+								await this.configManager.DeleteConfig(oldName)
+
+								let listApiConfig = await this.configManager.ListConfig();
+								const config = listApiConfig?.find(c => c.name === newName);
+								
+								// Update listApiConfigMeta first to ensure UI has latest data
+								await this.updateGlobalState("listApiConfigMeta", listApiConfig);
+
+								await Promise.all([
+									this.updateGlobalState("currentApiConfigName", newName),
+								])
+
+								await this.postStateToWebview()
+							} catch (error) {
+								console.error("Error create new api configuration:", error)
+								vscode.window.showErrorMessage("Failed to create api configuration")
+							}
+						}
+						break
+					case "loadApiConfiguration":
+						if (message.text) {
+							try {
+								const apiConfig = await this.configManager.LoadConfig(message.text);
+								const listApiConfig = await this.configManager.ListConfig();
+								const config = listApiConfig?.find(c => c.name === message.text);
+								
+								// Update listApiConfigMeta first to ensure UI has latest data
+								await this.updateGlobalState("listApiConfigMeta", listApiConfig);
+
+								await Promise.all([
+									this.updateGlobalState("currentApiConfigName", message.text),
+									this.updateApiConfiguration(apiConfig),
+								])
+
+								await this.postStateToWebview()
+							} catch (error) {
+								console.error("Error load api configuration:", error)
+								vscode.window.showErrorMessage("Failed to load api configuration")
+							}
+						}
+						break
+					case "deleteApiConfiguration":
+						if (message.text) {
+							const answer = await vscode.window.showInformationMessage(
+								"Are you sure you want to delete this configuration profile?",
+								{ modal: true },
+								"Yes",
+							)
+
+							if (answer !== "Yes") {
+								break
+							}
+
+							try {
+								await this.configManager.DeleteConfig(message.text);
+								const listApiConfig = await this.configManager.ListConfig();
+								
+								// Update listApiConfigMeta first to ensure UI has latest data
+								await this.updateGlobalState("listApiConfigMeta", listApiConfig);
+
+								// If this was the current config, switch to first available
+								let currentApiConfigName = await this.getGlobalState("currentApiConfigName")
+								if (message.text === currentApiConfigName && listApiConfig?.[0]?.name) {
+									const apiConfig = await this.configManager.LoadConfig(listApiConfig[0].name);
+									await Promise.all([
+										this.updateGlobalState("currentApiConfigName", listApiConfig[0].name),
+										this.updateApiConfiguration(apiConfig),
+									])
+								}
+
+								await this.postStateToWebview()
+							} catch (error) {
+								console.error("Error delete api configuration:", error)
+								vscode.window.showErrorMessage("Failed to delete api configuration")
+							}
+						}
+						break
+					case "getListApiConfiguration":
+						try {
+							let listApiConfig = await this.configManager.ListConfig();
+							await this.updateGlobalState("listApiConfigMeta", listApiConfig)
+							this.postMessageToWebview({ type: "listApiConfig", listApiConfig })
+						} catch (error) {
+							console.error("Error get list api configuration:", error)
+							vscode.window.showErrorMessage("Failed to get list api configuration")
+						}
+						break
+          case "experimentalDiffStrategy":
 						await this.updateGlobalState("experimentalDiffStrategy", message.bool ?? false)
 						await this.postStateToWebview()
-						break
 				}
 			},
 			null,
@@ -822,6 +1080,85 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 		)
 	}
 
+	private async updateApiConfiguration(apiConfiguration: ApiConfiguration) {
+		// Update mode's default config
+		const { mode } = await this.getState();
+		if (mode) {
+			const currentApiConfigName = await this.getGlobalState("currentApiConfigName");
+			const listApiConfig = await this.configManager.ListConfig();
+			const config = listApiConfig?.find(c => c.name === currentApiConfigName);
+			if (config?.id) {
+				await this.configManager.SetModeConfig(mode, config.id);
+			}
+		}
+
+		const {
+			apiProvider,
+			apiModelId,
+			apiKey,
+			glamaModelId,
+			glamaModelInfo,
+			glamaApiKey,
+			openRouterApiKey,
+			awsAccessKey,
+			awsSecretKey,
+			awsSessionToken,
+			awsRegion,
+			awsUseCrossRegionInference,
+			vertexProjectId,
+			vertexRegion,
+			openAiBaseUrl,
+			openAiApiKey,
+			openAiModelId,
+			ollamaModelId,
+			ollamaBaseUrl,
+			lmStudioModelId,
+			lmStudioBaseUrl,
+			anthropicBaseUrl,
+			geminiApiKey,
+			openAiNativeApiKey,
+			deepSeekApiKey,
+			azureApiVersion,
+			openAiStreamingEnabled,
+			openRouterModelId,
+			openRouterModelInfo,
+			openRouterUseMiddleOutTransform,
+		} = apiConfiguration
+		await this.updateGlobalState("apiProvider", apiProvider)
+		await this.updateGlobalState("apiModelId", apiModelId)
+		await this.storeSecret("apiKey", apiKey)
+		await this.updateGlobalState("glamaModelId", glamaModelId)
+		await this.updateGlobalState("glamaModelInfo", glamaModelInfo)
+		await this.storeSecret("glamaApiKey", glamaApiKey)
+		await this.storeSecret("openRouterApiKey", openRouterApiKey)
+		await this.storeSecret("awsAccessKey", awsAccessKey)
+		await this.storeSecret("awsSecretKey", awsSecretKey)
+		await this.storeSecret("awsSessionToken", awsSessionToken)
+		await this.updateGlobalState("awsRegion", awsRegion)
+		await this.updateGlobalState("awsUseCrossRegionInference", awsUseCrossRegionInference)
+		await this.updateGlobalState("vertexProjectId", vertexProjectId)
+		await this.updateGlobalState("vertexRegion", vertexRegion)
+		await this.updateGlobalState("openAiBaseUrl", openAiBaseUrl)
+		await this.storeSecret("openAiApiKey", openAiApiKey)
+		await this.updateGlobalState("openAiModelId", openAiModelId)
+		await this.updateGlobalState("ollamaModelId", ollamaModelId)
+		await this.updateGlobalState("ollamaBaseUrl", ollamaBaseUrl)
+		await this.updateGlobalState("lmStudioModelId", lmStudioModelId)
+		await this.updateGlobalState("lmStudioBaseUrl", lmStudioBaseUrl)
+		await this.updateGlobalState("anthropicBaseUrl", anthropicBaseUrl)
+		await this.storeSecret("geminiApiKey", geminiApiKey)
+		await this.storeSecret("openAiNativeApiKey", openAiNativeApiKey)
+		await this.storeSecret("deepSeekApiKey", deepSeekApiKey)
+		await this.updateGlobalState("azureApiVersion", azureApiVersion)
+		await this.updateGlobalState("openAiStreamingEnabled", openAiStreamingEnabled)
+		await this.updateGlobalState("openRouterModelId", openRouterModelId)
+		await this.updateGlobalState("openRouterModelInfo", openRouterModelInfo)
+		await this.updateGlobalState("openRouterUseMiddleOutTransform", openRouterUseMiddleOutTransform)
+		if (this.cline) {
+			this.cline.api = buildApiHandler(apiConfiguration)
+		} 
+	}
+
 	async updateCustomInstructions(instructions?: string) {
 		// User may be clearing the field
 		await this.updateGlobalState("customInstructions", instructions || undefined)
@@ -1266,7 +1603,12 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			mcpEnabled,
 			alwaysApproveResubmit,
 			requestDelaySeconds,
-			experimentalDiffStrategy,
+			currentApiConfigName,
+			listApiConfigMeta,
+			mode,
+			customPrompts,
+			enhancementApiConfigId,
+      experimentalDiffStrategy,
 		} = await this.getState()
 
 		const allowedCommands = vscode.workspace
@@ -1285,8 +1627,8 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			uriScheme: vscode.env.uriScheme,
 			clineMessages: this.cline?.clineMessages || [],
 			taskHistory: (taskHistory || [])
-				.filter((item) => item.ts && item.task)
+				.filter((item: HistoryItem) => item.ts && item.task)
-				.sort((a, b) => b.ts - a.ts),
+				.sort((a: HistoryItem, b: HistoryItem) => b.ts - a.ts),
 			soundEnabled: soundEnabled ?? false,
 			diffEnabled: diffEnabled ?? true,
 			shouldShowAnnouncement: lastShownAnnouncementId !== this.latestAnnouncementId,
@@ -1301,7 +1643,12 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			mcpEnabled: mcpEnabled ?? true,
 			alwaysApproveResubmit: alwaysApproveResubmit ?? false,
 			requestDelaySeconds: requestDelaySeconds ?? 5,
-			experimentalDiffStrategy: experimentalDiffStrategy ?? false,
+			currentApiConfigName: currentApiConfigName ?? "default",
+			listApiConfigMeta: listApiConfigMeta ?? [],
+			mode: mode ?? codeMode,
+			customPrompts: customPrompts ?? {},
+			enhancementApiConfigId,
+      experimentalDiffStrategy: experimentalDiffStrategy ?? false,
 		}
 	}
 
@@ -1409,7 +1756,13 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			mcpEnabled,
 			alwaysApproveResubmit,
 			requestDelaySeconds,
-			experimentalDiffStrategy,
+			currentApiConfigName,
+			listApiConfigMeta,
+			mode,
+			modeApiConfigs,
+			customPrompts,
+			enhancementApiConfigId,
+      experimentalDiffStrategy,
 		] = await Promise.all([
 			this.getGlobalState("apiProvider") as Promise<ApiProvider | undefined>,
 			this.getGlobalState("apiModelId") as Promise<string | undefined>,
@@ -1462,7 +1815,13 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			this.getGlobalState("mcpEnabled") as Promise<boolean | undefined>,
 			this.getGlobalState("alwaysApproveResubmit") as Promise<boolean | undefined>,
 			this.getGlobalState("requestDelaySeconds") as Promise<number | undefined>,
-			this.getGlobalState("experimentalDiffStrategy") as Promise<boolean | undefined>,
+			this.getGlobalState("currentApiConfigName") as Promise<string | undefined>,
+			this.getGlobalState("listApiConfigMeta") as Promise<ApiConfigMeta[] | undefined>,
+			this.getGlobalState("mode") as Promise<Mode | undefined>,
+			this.getGlobalState("modeApiConfigs") as Promise<Record<Mode, string> | undefined>,
+			this.getGlobalState("customPrompts") as Promise<CustomPrompts | undefined>,
+			this.getGlobalState("enhancementApiConfigId") as Promise<string | undefined>,
+      this.getGlobalState("experimentalDiffStrategy") as Promise<boolean | undefined>,
 		])
 
 		let apiProvider: ApiProvider
@@ -1529,6 +1888,7 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			fuzzyMatchThreshold: fuzzyMatchThreshold ?? 1.0,
 			writeDelayMs: writeDelayMs ?? 1000,
 			terminalOutputLineLimit: terminalOutputLineLimit ?? 500,
+			mode: mode ?? codeMode,
 			preferredLanguage: preferredLanguage ?? (() => {
 				// Get VSCode's locale setting
 				const vscodeLang = vscode.env.language;
@@ -1559,7 +1919,12 @@ export class ClineProvider implements vscode.WebviewViewProvider {
 			mcpEnabled: mcpEnabled ?? true,
 			alwaysApproveResubmit: alwaysApproveResubmit ?? false,
 			requestDelaySeconds: requestDelaySeconds ?? 5,
-			experimentalDiffStrategy: experimentalDiffStrategy ?? false,
+			currentApiConfigName: currentApiConfigName ?? "default",
+			listApiConfigMeta: listApiConfigMeta ?? [],
+			modeApiConfigs: modeApiConfigs ?? {} as Record<Mode, string>,
+			customPrompts: customPrompts ?? {},
+			enhancementApiConfigId,
+      experimentalDiffStrategy: experimentalDiffStrategy ?? false,
 		}
 	}
 

src/core/webview/__tests__/ClineProvider.test.ts

@@ -2,6 +2,7 @@ import { ClineProvider } from '../ClineProvider'
 import * as vscode from 'vscode'
 import { ExtensionMessage, ExtensionState } from '../../../shared/ExtensionMessage'
 import { setSoundEnabled } from '../../../utils/sound'
+import { codeMode } from '../../prompts/system';
 
 // Mock delay module
 jest.mock('delay', () => {
@@ -61,6 +62,7 @@ jest.mock('vscode', () => ({
     },
     window: {
         showInformationMessage: jest.fn(),
+        showErrorMessage: jest.fn(),
     },
     workspace: {
         getConfiguration: jest.fn().mockReturnValue({
@@ -112,6 +114,13 @@ jest.mock('../../../api', () => ({
     buildApiHandler: jest.fn()
 }))
 
+// Mock system prompt
+jest.mock('../../prompts/system', () => ({
+    SYSTEM_PROMPT: jest.fn().mockImplementation(async () => 'mocked system prompt'),
+    codeMode: 'code',
+    addCustomInstructions: jest.fn().mockImplementation(async () => '')
+}))
+
 // Mock WorkspaceTracker
 jest.mock('../../../integrations/workspace/WorkspaceTracker', () => {
     return jest.fn().mockImplementation(() => ({
@@ -121,19 +130,25 @@ jest.mock('../../../integrations/workspace/WorkspaceTracker', () => {
 })
 
 // Mock Cline
-jest.mock('../../Cline', () => {
+jest.mock('../../Cline', () => ({
-    return {
+    Cline: jest.fn().mockImplementation((
-        Cline: jest.fn().mockImplementation(() => ({
+        provider,
-            abortTask: jest.fn(),
+        apiConfiguration,
-            handleWebviewAskResponse: jest.fn(),
+        customInstructions,
-            clineMessages: [],
+        diffEnabled,
-            apiConversationHistory: [],
+        fuzzyMatchThreshold,
-            overwriteClineMessages: jest.fn(),
+        task,
-            overwriteApiConversationHistory: jest.fn(),
+        taskId
-            taskId: 'test-task-id'
+    ) => ({
-        }))
+        abortTask: jest.fn(),
-    }
+        handleWebviewAskResponse: jest.fn(),
-})
+        clineMessages: [],
+        apiConversationHistory: [],
+        overwriteClineMessages: jest.fn(),
+        overwriteApiConversationHistory: jest.fn(),
+        taskId: taskId || 'test-task-id'
+    }))
+}))
 
 // Mock extract-text
 jest.mock('../../../integrations/misc/extract-text', () => ({
@@ -171,7 +186,16 @@ describe('ClineProvider', () => {
             extensionPath: '/test/path',
             extensionUri: {} as vscode.Uri,
             globalState: {
-                get: jest.fn(),
+                get: jest.fn().mockImplementation((key: string) => {
+                    switch (key) {
+                        case 'mode':
+                            return 'architect'
+                        case 'currentApiConfigName':
+                            return 'new-config'
+                        default:
+                            return undefined
+                    }
+                }),
                 update: jest.fn(),
                 keys: jest.fn().mockReturnValue([]),
             },
@@ -263,7 +287,8 @@ describe('ClineProvider', () => {
             browserViewportSize: "900x600",
             fuzzyMatchThreshold: 1.0,
             mcpEnabled: true,
-            requestDelaySeconds: 5
+            requestDelaySeconds: 5,
+            mode: codeMode,
         }
         
         const message: ExtensionMessage = { 
@@ -404,6 +429,80 @@ describe('ClineProvider', () => {
         expect(state.alwaysApproveResubmit).toBe(false)
     })
 
+    test('loads saved API config when switching modes', async () => {
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        // Mock ConfigManager methods
+        provider.configManager = {
+            GetModeConfigId: jest.fn().mockResolvedValue('test-id'),
+            ListConfig: jest.fn().mockResolvedValue([
+                { name: 'test-config', id: 'test-id', apiProvider: 'anthropic' }
+            ]),
+            LoadConfig: jest.fn().mockResolvedValue({ apiProvider: 'anthropic' }),
+            SetModeConfig: jest.fn()
+        } as any
+
+        // Switch to architect mode
+        await messageHandler({ type: 'mode', text: 'architect' })
+
+        // Should load the saved config for architect mode
+        expect(provider.configManager.GetModeConfigId).toHaveBeenCalledWith('architect')
+        expect(provider.configManager.LoadConfig).toHaveBeenCalledWith('test-config')
+        expect(mockContext.globalState.update).toHaveBeenCalledWith('currentApiConfigName', 'test-config')
+    })
+
+    test('saves current config when switching to mode without config', async () => {
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        // Mock ConfigManager methods
+        provider.configManager = {
+            GetModeConfigId: jest.fn().mockResolvedValue(undefined),
+            ListConfig: jest.fn().mockResolvedValue([
+                { name: 'current-config', id: 'current-id', apiProvider: 'anthropic' }
+            ]),
+            SetModeConfig: jest.fn()
+        } as any
+
+        // Mock current config name
+        (mockContext.globalState.get as jest.Mock).mockImplementation((key: string) => {
+            if (key === 'currentApiConfigName') {
+                return 'current-config'
+            }
+            return undefined
+        })
+
+        // Switch to architect mode
+        await messageHandler({ type: 'mode', text: 'architect' })
+
+        // Should save current config as default for architect mode
+        expect(provider.configManager.SetModeConfig).toHaveBeenCalledWith('architect', 'current-id')
+    })
+
+    test('saves config as default for current mode when loading config', async () => {
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        provider.configManager = {
+            LoadConfig: jest.fn().mockResolvedValue({ apiProvider: 'anthropic', id: 'new-id' }),
+            ListConfig: jest.fn().mockResolvedValue([
+                { name: 'new-config', id: 'new-id', apiProvider: 'anthropic' }
+            ]),
+            SetModeConfig: jest.fn(),
+            GetModeConfigId: jest.fn().mockResolvedValue(undefined)
+        } as any
+
+        // First set the mode
+        await messageHandler({ type: 'mode', text: 'architect' })
+
+        // Then load the config
+        await messageHandler({ type: 'loadApiConfiguration', text: 'new-config' })
+
+        // Should save new config as default for architect mode
+        expect(provider.configManager.SetModeConfig).toHaveBeenCalledWith('architect', 'new-id')
+    })
+
     test('handles request delay settings messages', async () => {
         provider.resolveWebviewView(mockWebviewView)
         const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
@@ -419,6 +518,182 @@ describe('ClineProvider', () => {
         expect(mockPostMessage).toHaveBeenCalled()
     })
 
+    test('handles updatePrompt message correctly', async () => {
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        // Mock existing prompts
+        const existingPrompts = {
+            code: 'existing code prompt',
+            architect: 'existing architect prompt'
+        }
+        ;(mockContext.globalState.get as jest.Mock).mockImplementation((key: string) => {
+            if (key === 'customPrompts') {
+                return existingPrompts
+            }
+            return undefined
+        })
+
+        // Test updating a prompt
+        await messageHandler({
+            type: 'updatePrompt',
+            promptMode: 'code',
+            customPrompt: 'new code prompt'
+        })
+
+        // Verify state was updated correctly
+        expect(mockContext.globalState.update).toHaveBeenCalledWith(
+            'customPrompts',
+            {
+                ...existingPrompts,
+                code: 'new code prompt'
+            }
+        )
+
+        // Verify state was posted to webview
+        expect(mockPostMessage).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: 'state',
+                state: expect.objectContaining({
+                    customPrompts: {
+                        ...existingPrompts,
+                        code: 'new code prompt'
+                    }
+                })
+            })
+        )
+    })
+
+    test('customPrompts defaults to empty object', async () => {
+        // Mock globalState.get to return undefined for customPrompts
+        (mockContext.globalState.get as jest.Mock).mockImplementation((key: string) => {
+            if (key === 'customPrompts') {
+                return undefined
+            }
+            return null
+        })
+
+        const state = await provider.getState()
+        expect(state.customPrompts).toEqual({})
+    })
+
+    test('uses mode-specific custom instructions in Cline initialization', async () => {
+        // Setup mock state
+        const modeCustomInstructions = 'Code mode instructions';
+        const mockApiConfig = {
+            apiProvider: 'openrouter',
+            openRouterModelInfo: { supportsComputerUse: true }
+        };
+
+        jest.spyOn(provider, 'getState').mockResolvedValue({
+            apiConfiguration: mockApiConfig,
+            customPrompts: {
+                code: { customInstructions: modeCustomInstructions }
+            },
+            mode: 'code',
+            diffEnabled: true,
+            fuzzyMatchThreshold: 1.0
+        } as any);
+
+        // Reset Cline mock
+        const { Cline } = require('../../Cline');
+        (Cline as jest.Mock).mockClear();
+
+        // Initialize Cline with a task
+        await provider.initClineWithTask('Test task');
+
+        // Verify Cline was initialized with mode-specific instructions
+        expect(Cline).toHaveBeenCalledWith(
+            provider,
+            mockApiConfig,
+            modeCustomInstructions,
+            true,
+            1.0,
+            'Test task',
+            undefined
+        );
+    });
+    test('handles mode-specific custom instructions updates', async () => {
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        // Mock existing prompts
+        const existingPrompts = {
+            code: {
+                roleDefinition: 'Code role',
+                customInstructions: 'Old instructions'
+            }
+        }
+        mockContext.globalState.get = jest.fn((key: string) => {
+            if (key === 'customPrompts') {
+                return existingPrompts
+            }
+            return undefined
+        })
+
+        // Update custom instructions for code mode
+        await messageHandler({
+            type: 'updatePrompt',
+            promptMode: 'code',
+            customPrompt: {
+                roleDefinition: 'Code role',
+                customInstructions: 'New instructions'
+            }
+        })
+
+        // Verify state was updated correctly
+        expect(mockContext.globalState.update).toHaveBeenCalledWith(
+            'customPrompts',
+            {
+                code: {
+                    roleDefinition: 'Code role',
+                    customInstructions: 'New instructions'
+                }
+            }
+        )
+    })
+
+    test('saves mode config when updating API configuration', async () => {
+        // Setup mock context with mode and config name
+        mockContext = {
+            ...mockContext,
+            globalState: {
+                ...mockContext.globalState,
+                get: jest.fn((key: string) => {
+                    if (key === 'mode') {
+                        return 'code'
+                    } else if (key === 'currentApiConfigName') {
+                        return 'test-config'
+                    }
+                    return undefined
+                }),
+                update: jest.fn(),
+                keys: jest.fn().mockReturnValue([]),
+            }
+        } as unknown as vscode.ExtensionContext
+
+        // Create new provider with updated mock context
+        provider = new ClineProvider(mockContext, mockOutputChannel)
+        provider.resolveWebviewView(mockWebviewView)
+        const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+
+        provider.configManager = {
+            ListConfig: jest.fn().mockResolvedValue([
+                { name: 'test-config', id: 'test-id', apiProvider: 'anthropic' }
+            ]),
+            SetModeConfig: jest.fn()
+        } as any
+
+        // Update API configuration
+        await messageHandler({
+            type: 'apiConfiguration',
+            apiConfiguration: { apiProvider: 'anthropic' }
+        })
+
+        // Should save config as default for current mode
+        expect(provider.configManager.SetModeConfig).toHaveBeenCalledWith('code', 'test-id')
+    })
+
     test('file content includes line numbers', async () => {
         const { extractTextFromFile } = require('../../../integrations/misc/extract-text')
         const result = await extractTextFromFile('test.js')
@@ -569,4 +844,165 @@ describe('ClineProvider', () => {
             expect(mockCline.overwriteApiConversationHistory).not.toHaveBeenCalled()
         })
     })
+    
+    describe('getSystemPrompt', () => {
+        beforeEach(() => {
+            mockPostMessage.mockClear();
+            provider.resolveWebviewView(mockWebviewView);
+        });
+
+        const getMessageHandler = () => {
+            const mockCalls = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls;
+            expect(mockCalls.length).toBeGreaterThan(0);
+            return mockCalls[0][0];
+        };
+
+        test('handles mcpEnabled setting correctly', async () => {
+            // Mock getState to return mcpEnabled: true
+            jest.spyOn(provider, 'getState').mockResolvedValue({
+                apiConfiguration: {
+                    apiProvider: 'openrouter' as const,
+                    openRouterModelInfo: {
+                        supportsComputerUse: true,
+                        supportsPromptCache: false,
+                        maxTokens: 4096,
+                        contextWindow: 8192,
+                        supportsImages: false,
+                        inputPrice: 0.0,
+                        outputPrice: 0.0,
+                        description: undefined
+                    }
+                },
+                mcpEnabled: true,
+                mode: 'code' as const
+            } as any);
+
+            const handler1 = getMessageHandler();
+            expect(typeof handler1).toBe('function');
+            await handler1({ type: 'getSystemPrompt', mode: 'code' });
+
+            // Verify mcpHub is passed when mcpEnabled is true
+            expect(mockPostMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: 'systemPrompt',
+                    text: expect.any(String)
+                })
+            );
+
+            // Mock getState to return mcpEnabled: false
+            jest.spyOn(provider, 'getState').mockResolvedValue({
+                apiConfiguration: {
+                    apiProvider: 'openrouter' as const,
+                    openRouterModelInfo: {
+                        supportsComputerUse: true,
+                        supportsPromptCache: false,
+                        maxTokens: 4096,
+                        contextWindow: 8192,
+                        supportsImages: false,
+                        inputPrice: 0.0,
+                        outputPrice: 0.0,
+                        description: undefined
+                    }
+                },
+                mcpEnabled: false,
+                mode: 'code' as const
+            } as any);
+
+            const handler2 = getMessageHandler();
+            await handler2({ type: 'getSystemPrompt', mode: 'code' });
+
+            // Verify mcpHub is not passed when mcpEnabled is false
+            expect(mockPostMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: 'systemPrompt',
+                    text: expect.any(String)
+                })
+            );
+        });
+
+        test('handles errors gracefully', async () => {
+            // Mock SYSTEM_PROMPT to throw an error
+            const systemPrompt = require('../../prompts/system')
+            jest.spyOn(systemPrompt, 'SYSTEM_PROMPT').mockRejectedValueOnce(new Error('Test error'))
+
+            const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+            await messageHandler({ type: 'getSystemPrompt', mode: 'code' })
+
+            expect(vscode.window.showErrorMessage).toHaveBeenCalledWith('Failed to get system prompt')
+        })
+
+        test('uses mode-specific custom instructions in system prompt', async () => {
+            const systemPrompt = require('../../prompts/system')
+            const { addCustomInstructions } = systemPrompt
+
+            // Mock getState to return mode-specific custom instructions
+            jest.spyOn(provider, 'getState').mockResolvedValue({
+                apiConfiguration: {
+                    apiProvider: 'openrouter',
+                    openRouterModelInfo: { supportsComputerUse: true }
+                },
+                customPrompts: {
+                    code: { customInstructions: 'Code mode specific instructions' }
+                },
+                mode: 'code',
+                mcpEnabled: false,
+                browserViewportSize: '900x600'
+            } as any)
+
+            const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+            await messageHandler({ type: 'getSystemPrompt', mode: 'code' })
+
+            // Verify addCustomInstructions was called with mode-specific instructions
+            expect(addCustomInstructions).toHaveBeenCalledWith(
+                {
+                    customInstructions: undefined,
+                    customPrompts: {
+                        code: { customInstructions: 'Code mode specific instructions' }
+                    },
+                    preferredLanguage: undefined
+                },
+                expect.any(String),
+                'code'
+            )
+        })
+
+        test('uses correct mode-specific instructions when mode is specified', async () => {
+            const systemPrompt = require('../../prompts/system')
+            const { addCustomInstructions } = systemPrompt
+
+            // Mock getState to return instructions for multiple modes
+            jest.spyOn(provider, 'getState').mockResolvedValue({
+                apiConfiguration: {
+                    apiProvider: 'openrouter',
+                    openRouterModelInfo: { supportsComputerUse: true }
+                },
+                customPrompts: {
+                    code: { customInstructions: 'Code mode instructions' },
+                    architect: { customInstructions: 'Architect mode instructions' }
+                },
+                mode: 'code',
+                mcpEnabled: false,
+                browserViewportSize: '900x600'
+            } as any)
+
+            const messageHandler = (mockWebviewView.webview.onDidReceiveMessage as jest.Mock).mock.calls[0][0]
+            
+            // Request architect mode prompt
+            await messageHandler({ type: 'getSystemPrompt', mode: 'architect' })
+
+            // Verify architect mode instructions were used
+            expect(addCustomInstructions).toHaveBeenCalledWith(
+                {
+                    customInstructions: undefined,
+                    customPrompts: {
+                        code: { customInstructions: 'Code mode instructions' },
+                        architect: { customInstructions: 'Architect mode instructions' }
+                    },
+                    preferredLanguage: undefined
+                },
+                expect.any(String),
+                'architect'
+            )
+        })
+    })
 })

src/extension.ts

@@ -59,6 +59,12 @@ export function activate(context: vscode.ExtensionContext) {
 		}),
 	)
 
+	context.subscriptions.push(
+		vscode.commands.registerCommand("roo-cline.promptsButtonClicked", () => {
+			sidebarProvider.postMessageToWebview({ type: "action", action: "promptsButtonClicked" })
+		}),
+	)
+
 	const openClineInNewTab = async () => {
 		outputChannel.appendLine("Opening Cline in new tab")
 		// (this example uses webviewProvider activation event which is necessary to deserialize cached webview, but since we use retainContextWhenHidden, we don't need to use that event)

src/integrations/misc/open-file.ts

@@ -20,11 +20,41 @@ export async function openImage(dataUri: string) {
 	}
 }
 
-export async function openFile(absolutePath: string) {
+interface OpenFileOptions {
-	try {
+	create?: boolean;
-		const uri = vscode.Uri.file(absolutePath)
+	content?: string;
+}
 
-		// Check if the document is already open in a tab group that's not in the active editor's column. If it is, then close it (if not dirty) so that we don't duplicate tabs
+export async function openFile(filePath: string, options: OpenFileOptions = {}) {
+	try {
+		// Get workspace root
+		const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+		if (!workspaceRoot) {
+			throw new Error('No workspace root found')
+		}
+
+		// If path starts with ./, resolve it relative to workspace root
+		const fullPath = filePath.startsWith('./') ?
+			path.join(workspaceRoot, filePath.slice(2)) :
+			filePath
+
+		const uri = vscode.Uri.file(fullPath)
+
+		// Check if file exists
+		try {
+			await vscode.workspace.fs.stat(uri)
+		} catch {
+			// File doesn't exist
+			if (!options.create) {
+				throw new Error('File does not exist')
+			}
+			
+			// Create with provided content or empty string
+			const content = options.content || ''
+			await vscode.workspace.fs.writeFile(uri, Buffer.from(content, 'utf8'))
+		}
+
+		// Check if the document is already open in a tab group that's not in the active editor's column
 		try {
 			for (const group of vscode.window.tabGroups.all) {
 				const existingTab = group.tabs.find(
@@ -47,6 +77,10 @@ export async function openFile(absolutePath: string) {
 		const document = await vscode.workspace.openTextDocument(uri)
 		await vscode.window.showTextDocument(document, { preview: false })
 	} catch (error) {
-		vscode.window.showErrorMessage(`Could not open file!`)
+		if (error instanceof Error) {
+			vscode.window.showErrorMessage(`Could not open file: ${error.message}`)
+		} else {
+			vscode.window.showErrorMessage(`Could not open file!`)
+		}
 	}
 }

src/integrations/terminal/__tests__/TerminalProcess.test.ts

@@ -0,0 +1,229 @@
+import { TerminalProcess, mergePromise } from "../TerminalProcess"
+import * as vscode from "vscode"
+import { EventEmitter } from "events"
+
+// Mock vscode
+jest.mock("vscode")
+
+describe("TerminalProcess", () => {
+    let terminalProcess: TerminalProcess
+    let mockTerminal: jest.Mocked<vscode.Terminal & {
+        shellIntegration: {
+            executeCommand: jest.Mock
+        }
+    }>
+    let mockExecution: any
+    let mockStream: AsyncIterableIterator<string>
+
+    beforeEach(() => {
+        terminalProcess = new TerminalProcess()
+        
+        // Create properly typed mock terminal
+        mockTerminal = {
+            shellIntegration: {
+                executeCommand: jest.fn()
+            },
+            name: "Mock Terminal",
+            processId: Promise.resolve(123),
+            creationOptions: {},
+            exitStatus: undefined,
+            state: { isInteractedWith: true },
+            dispose: jest.fn(),
+            hide: jest.fn(),
+            show: jest.fn(),
+            sendText: jest.fn()
+        } as unknown as jest.Mocked<vscode.Terminal & {
+            shellIntegration: {
+                executeCommand: jest.Mock
+            }
+        }>
+
+        // Reset event listeners
+        terminalProcess.removeAllListeners()
+    })
+
+    describe("run", () => {
+        it("handles shell integration commands correctly", async () => {
+            const lines: string[] = []
+            terminalProcess.on("line", (line) => {
+                // Skip empty lines used for loading spinner
+                if (line !== "") {
+                    lines.push(line)
+                }
+            })
+
+            // Mock stream data with shell integration sequences
+            mockStream = (async function* () {
+                // The first chunk contains the command start sequence
+                yield "Initial output\n"
+                yield "More output\n"
+                // The last chunk contains the command end sequence
+                yield "Final output"
+            })()
+
+            mockExecution = {
+                read: jest.fn().mockReturnValue(mockStream)
+            }
+
+            mockTerminal.shellIntegration.executeCommand.mockReturnValue(mockExecution)
+
+            const completedPromise = new Promise<void>((resolve) => {
+                terminalProcess.once("completed", resolve)
+            })
+
+            await terminalProcess.run(mockTerminal, "test command")
+            await completedPromise
+
+            expect(lines).toEqual(["Initial output", "More output", "Final output"])
+            expect(terminalProcess.isHot).toBe(false)
+        })
+
+        it("handles terminals without shell integration", async () => {
+            const noShellTerminal = {
+                sendText: jest.fn(),
+                shellIntegration: undefined
+            } as unknown as vscode.Terminal
+
+            const noShellPromise = new Promise<void>((resolve) => {
+                terminalProcess.once("no_shell_integration", resolve)
+            })
+
+            await terminalProcess.run(noShellTerminal, "test command")
+            await noShellPromise
+
+            expect(noShellTerminal.sendText).toHaveBeenCalledWith("test command", true)
+        })
+
+        it("sets hot state for compiling commands", async () => {
+            const lines: string[] = []
+            terminalProcess.on("line", (line) => {
+                if (line !== "") {
+                    lines.push(line)
+                }
+            })
+
+            // Create a promise that resolves when the first chunk is processed
+            const firstChunkProcessed = new Promise<void>(resolve => {
+                terminalProcess.on("line", () => resolve())
+            })
+
+            mockStream = (async function* () {
+                yield "compiling...\n"
+                // Wait to ensure hot state check happens after first chunk
+                await new Promise(resolve => setTimeout(resolve, 10))
+                yield "still compiling...\n"
+                yield "done"
+            })()
+
+            mockExecution = {
+                read: jest.fn().mockReturnValue(mockStream)
+            }
+
+            mockTerminal.shellIntegration.executeCommand.mockReturnValue(mockExecution)
+
+            // Start the command execution
+            const runPromise = terminalProcess.run(mockTerminal, "npm run build")
+            
+            // Wait for the first chunk to be processed
+            await firstChunkProcessed
+            
+            // Hot state should be true while compiling
+            expect(terminalProcess.isHot).toBe(true)
+
+            // Complete the execution
+            const completedPromise = new Promise<void>((resolve) => {
+                terminalProcess.once("completed", resolve)
+            })
+
+            await runPromise
+            await completedPromise
+
+            expect(lines).toEqual(["compiling...", "still compiling...", "done"])
+        })
+    })
+
+    describe("buffer processing", () => {
+        it("correctly processes and emits lines", () => {
+            const lines: string[] = []
+            terminalProcess.on("line", (line) => lines.push(line))
+
+            // Simulate incoming chunks
+            terminalProcess["emitIfEol"]("first line\n")
+            terminalProcess["emitIfEol"]("second")
+            terminalProcess["emitIfEol"](" line\n")
+            terminalProcess["emitIfEol"]("third line")
+
+            expect(lines).toEqual(["first line", "second line"])
+
+            // Process remaining buffer
+            terminalProcess["emitRemainingBufferIfListening"]()
+            expect(lines).toEqual(["first line", "second line", "third line"])
+        })
+
+        it("handles Windows-style line endings", () => {
+            const lines: string[] = []
+            terminalProcess.on("line", (line) => lines.push(line))
+
+            terminalProcess["emitIfEol"]("line1\r\nline2\r\n")
+
+            expect(lines).toEqual(["line1", "line2"])
+        })
+    })
+
+    describe("removeLastLineArtifacts", () => {
+        it("removes terminal artifacts from output", () => {
+            const cases = [
+                ["output%", "output"],
+                ["output$ ", "output"],
+                ["output#", "output"],
+                ["output> ", "output"],
+                ["multi\nline%", "multi\nline"],
+                ["no artifacts", "no artifacts"]
+            ]
+
+            for (const [input, expected] of cases) {
+                expect(terminalProcess["removeLastLineArtifacts"](input)).toBe(expected)
+            }
+        })
+    })
+
+    describe("continue", () => {
+        it("stops listening and emits continue event", () => {
+            const continueSpy = jest.fn()
+            terminalProcess.on("continue", continueSpy)
+
+            terminalProcess.continue()
+
+            expect(continueSpy).toHaveBeenCalled()
+            expect(terminalProcess["isListening"]).toBe(false)
+        })
+    })
+
+    describe("getUnretrievedOutput", () => {
+        it("returns and clears unretrieved output", () => {
+            terminalProcess["fullOutput"] = "previous\nnew output"
+            terminalProcess["lastRetrievedIndex"] = 9 // After "previous\n"
+
+            const unretrieved = terminalProcess.getUnretrievedOutput()
+
+            expect(unretrieved).toBe("new output")
+            expect(terminalProcess["lastRetrievedIndex"]).toBe(terminalProcess["fullOutput"].length)
+        })
+    })
+
+    describe("mergePromise", () => {
+        it("merges promise methods with terminal process", async () => {
+            const process = new TerminalProcess()
+            const promise = Promise.resolve()
+
+            const merged = mergePromise(process, promise)
+
+            expect(merged).toHaveProperty("then")
+            expect(merged).toHaveProperty("catch")
+            expect(merged).toHaveProperty("finally")
+            expect(merged instanceof TerminalProcess).toBe(true)
+
+            await expect(merged).resolves.toBeUndefined()
+        })
+    })
+})

src/services/tree-sitter/__tests__/index.test.ts

@@ -0,0 +1,254 @@
+import { parseSourceCodeForDefinitionsTopLevel } from '../index';
+import { listFiles } from '../../glob/list-files';
+import { loadRequiredLanguageParsers } from '../languageParser';
+import { fileExistsAtPath } from '../../../utils/fs';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// Mock dependencies
+jest.mock('../../glob/list-files');
+jest.mock('../languageParser');
+jest.mock('../../../utils/fs');
+jest.mock('fs/promises');
+
+describe('Tree-sitter Service', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (fileExistsAtPath as jest.Mock).mockResolvedValue(true);
+    });
+
+    describe('parseSourceCodeForDefinitionsTopLevel', () => {
+        it('should handle non-existent directory', async () => {
+            (fileExistsAtPath as jest.Mock).mockResolvedValue(false);
+            
+            const result = await parseSourceCodeForDefinitionsTopLevel('/non/existent/path');
+            expect(result).toBe('This directory does not exist or you do not have permission to access it.');
+        });
+
+        it('should handle empty directory', async () => {
+            (listFiles as jest.Mock).mockResolvedValue([[], new Set()]);
+            
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            expect(result).toBe('No source code definitions found.');
+        });
+
+        it('should parse TypeScript files correctly', async () => {
+            const mockFiles = [
+                '/test/path/file1.ts',
+                '/test/path/file2.tsx',
+                '/test/path/readme.md'
+            ];
+            
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockReturnValue({
+                    rootNode: 'mockNode'
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn().mockReturnValue([
+                    {
+                        node: {
+                            startPosition: { row: 0 },
+                            endPosition: { row: 0 }
+                        },
+                        name: 'name.definition'
+                    }
+                ])
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                ts: { parser: mockParser, query: mockQuery },
+                tsx: { parser: mockParser, query: mockQuery }
+            });
+
+            (fs.readFile as jest.Mock).mockResolvedValue(
+                'export class TestClass {\n  constructor() {}\n}'
+            );
+
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            
+            expect(result).toContain('file1.ts');
+            expect(result).toContain('file2.tsx');
+            expect(result).not.toContain('readme.md');
+            expect(result).toContain('export class TestClass');
+        });
+
+        it('should handle multiple definition types', async () => {
+            const mockFiles = ['/test/path/file.ts'];
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockReturnValue({
+                    rootNode: 'mockNode'
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn().mockReturnValue([
+                    {
+                        node: {
+                            startPosition: { row: 0 },
+                            endPosition: { row: 0 }
+                        },
+                        name: 'name.definition.class'
+                    },
+                    {
+                        node: {
+                            startPosition: { row: 2 },
+                            endPosition: { row: 2 }
+                        },
+                        name: 'name.definition.function'
+                    }
+                ])
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                ts: { parser: mockParser, query: mockQuery }
+            });
+
+            const fileContent = 
+                'class TestClass {\n' +
+                '  constructor() {}\n' +
+                '  testMethod() {}\n' +
+                '}';
+            
+            (fs.readFile as jest.Mock).mockResolvedValue(fileContent);
+
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            
+            expect(result).toContain('class TestClass');
+            expect(result).toContain('testMethod()');
+            expect(result).toContain('|----');
+        });
+
+        it('should handle parsing errors gracefully', async () => {
+            const mockFiles = ['/test/path/file.ts'];
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockImplementation(() => {
+                    throw new Error('Parsing error');
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn()
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                ts: { parser: mockParser, query: mockQuery }
+            });
+
+            (fs.readFile as jest.Mock).mockResolvedValue('invalid code');
+
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            expect(result).toBe('No source code definitions found.');
+        });
+
+        it('should respect file limit', async () => {
+            const mockFiles = Array(100).fill(0).map((_, i) => `/test/path/file${i}.ts`);
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockReturnValue({
+                    rootNode: 'mockNode'
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn().mockReturnValue([])
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                ts: { parser: mockParser, query: mockQuery }
+            });
+
+            await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            
+            // Should only process first 50 files
+            expect(mockParser.parse).toHaveBeenCalledTimes(50);
+        });
+
+        it('should handle various supported file extensions', async () => {
+            const mockFiles = [
+                '/test/path/script.js',
+                '/test/path/app.py',
+                '/test/path/main.rs',
+                '/test/path/program.cpp',
+                '/test/path/code.go'
+            ];
+            
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockReturnValue({
+                    rootNode: 'mockNode'
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn().mockReturnValue([{
+                    node: {
+                        startPosition: { row: 0 },
+                        endPosition: { row: 0 }
+                    },
+                    name: 'name'
+                }])
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                js: { parser: mockParser, query: mockQuery },
+                py: { parser: mockParser, query: mockQuery },
+                rs: { parser: mockParser, query: mockQuery },
+                cpp: { parser: mockParser, query: mockQuery },
+                go: { parser: mockParser, query: mockQuery }
+            });
+
+            (fs.readFile as jest.Mock).mockResolvedValue('function test() {}');
+
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            
+            expect(result).toContain('script.js');
+            expect(result).toContain('app.py');
+            expect(result).toContain('main.rs');
+            expect(result).toContain('program.cpp');
+            expect(result).toContain('code.go');
+        });
+
+        it('should normalize paths in output', async () => {
+            const mockFiles = ['/test/path/dir\\file.ts'];
+            (listFiles as jest.Mock).mockResolvedValue([mockFiles, new Set()]);
+            
+            const mockParser = {
+                parse: jest.fn().mockReturnValue({
+                    rootNode: 'mockNode'
+                })
+            };
+            
+            const mockQuery = {
+                captures: jest.fn().mockReturnValue([{
+                    node: {
+                        startPosition: { row: 0 },
+                        endPosition: { row: 0 }
+                    },
+                    name: 'name'
+                }])
+            };
+
+            (loadRequiredLanguageParsers as jest.Mock).mockResolvedValue({
+                ts: { parser: mockParser, query: mockQuery }
+            });
+
+            (fs.readFile as jest.Mock).mockResolvedValue('class Test {}');
+
+            const result = await parseSourceCodeForDefinitionsTopLevel('/test/path');
+            
+            // Should use forward slashes regardless of platform
+            expect(result).toContain('dir/file.ts');
+            expect(result).not.toContain('dir\\file.ts');
+        });
+    });
+});

src/services/tree-sitter/__tests__/languageParser.test.ts

@@ -0,0 +1,128 @@
+import { loadRequiredLanguageParsers } from '../languageParser';
+import Parser from 'web-tree-sitter';
+
+// Mock web-tree-sitter
+const mockSetLanguage = jest.fn();
+jest.mock('web-tree-sitter', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            setLanguage: mockSetLanguage
+        }))
+    };
+});
+
+// Add static methods to Parser mock
+const ParserMock = Parser as jest.MockedClass<typeof Parser>;
+ParserMock.init = jest.fn().mockResolvedValue(undefined);
+ParserMock.Language = {
+    load: jest.fn().mockResolvedValue({
+        query: jest.fn().mockReturnValue('mockQuery')
+    }),
+    prototype: {} // Add required prototype property
+} as unknown as typeof Parser.Language;
+
+describe('Language Parser', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('loadRequiredLanguageParsers', () => {
+        it('should initialize parser only once', async () => {
+            const files = ['test.js', 'test2.js'];
+            await loadRequiredLanguageParsers(files);
+            await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.init).toHaveBeenCalledTimes(1);
+        });
+
+        it('should load JavaScript parser for .js and .jsx files', async () => {
+            const files = ['test.js', 'test.jsx'];
+            const parsers = await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-javascript.wasm')
+            );
+            expect(parsers.js).toBeDefined();
+            expect(parsers.jsx).toBeDefined();
+            expect(parsers.js.query).toBeDefined();
+            expect(parsers.jsx.query).toBeDefined();
+        });
+
+        it('should load TypeScript parser for .ts and .tsx files', async () => {
+            const files = ['test.ts', 'test.tsx'];
+            const parsers = await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-typescript.wasm')
+            );
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-tsx.wasm')
+            );
+            expect(parsers.ts).toBeDefined();
+            expect(parsers.tsx).toBeDefined();
+        });
+
+        it('should load Python parser for .py files', async () => {
+            const files = ['test.py'];
+            const parsers = await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-python.wasm')
+            );
+            expect(parsers.py).toBeDefined();
+        });
+
+        it('should load multiple language parsers as needed', async () => {
+            const files = ['test.js', 'test.py', 'test.rs', 'test.go'];
+            const parsers = await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledTimes(4);
+            expect(parsers.js).toBeDefined();
+            expect(parsers.py).toBeDefined();
+            expect(parsers.rs).toBeDefined();
+            expect(parsers.go).toBeDefined();
+        });
+
+        it('should handle C/C++ files correctly', async () => {
+            const files = ['test.c', 'test.h', 'test.cpp', 'test.hpp'];
+            const parsers = await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-c.wasm')
+            );
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-cpp.wasm')
+            );
+            expect(parsers.c).toBeDefined();
+            expect(parsers.h).toBeDefined();
+            expect(parsers.cpp).toBeDefined();
+            expect(parsers.hpp).toBeDefined();
+        });
+
+        it('should throw error for unsupported file extensions', async () => {
+            const files = ['test.unsupported'];
+            
+            await expect(loadRequiredLanguageParsers(files)).rejects.toThrow(
+                'Unsupported language: unsupported'
+            );
+        });
+
+        it('should load each language only once for multiple files', async () => {
+            const files = ['test1.js', 'test2.js', 'test3.js'];
+            await loadRequiredLanguageParsers(files);
+            
+            expect(ParserMock.Language.load).toHaveBeenCalledTimes(1);
+            expect(ParserMock.Language.load).toHaveBeenCalledWith(
+                expect.stringContaining('tree-sitter-javascript.wasm')
+            );
+        });
+
+        it('should set language for each parser instance', async () => {
+            const files = ['test.js', 'test.py'];
+            await loadRequiredLanguageParsers(files);
+            
+            expect(mockSetLanguage).toHaveBeenCalledTimes(2);
+        });
+    });
+});

src/shared/ExtensionMessage.ts

@@ -1,9 +1,10 @@
 // type that represents json data that is sent from extension to webview, called ExtensionMessage and has 'type' enum which can be 'plusButtonClicked' or 'settingsButtonClicked' or 'hello'
 
-import { ApiConfiguration, ModelInfo } from "./api"
+import { ApiConfiguration, ApiProvider, ModelInfo } from "./api"
 import { HistoryItem } from "./HistoryItem"
 import { McpServer } from "./mcp"
 import { GitCommit } from "../utils/git"
+import { Mode, CustomPrompts } from "./modes"
 
 // webview will hold state
 export interface ExtensionMessage {
@@ -23,12 +24,16 @@ export interface ExtensionMessage {
 		| "mcpServers"
 		| "enhancedPrompt"
 		| "commitSearchResults"
+		| "listApiConfig"
+		| "updatePrompt"
+		| "systemPrompt"
 	text?: string
 	action?:
 		| "chatButtonClicked"
 		| "mcpButtonClicked"
 		| "settingsButtonClicked"
 		| "historyButtonClicked"
+		| "promptsButtonClicked"
 		| "didBecomeVisible"
 	invoke?: "sendMessage" | "primaryButtonClick" | "secondaryButtonClick"
 	state?: ExtensionState
@@ -42,6 +47,14 @@ export interface ExtensionMessage {
 	openAiModels?: string[]
 	mcpServers?: McpServer[]
 	commits?: GitCommit[]
+	listApiConfig?: ApiConfigMeta[]
+	mode?: Mode
+}
+
+export interface ApiConfigMeta {
+	id: string
+	name: string
+	apiProvider?: ApiProvider
 }
 
 export interface ExtensionState {
@@ -50,7 +63,10 @@ export interface ExtensionState {
 	taskHistory: HistoryItem[]
 	shouldShowAnnouncement: boolean
 	apiConfiguration?: ApiConfiguration
+	currentApiConfigName?: string
+	listApiConfigMeta?: ApiConfigMeta[]
 	customInstructions?: string
+	customPrompts?: CustomPrompts
 	alwaysAllowReadOnly?: boolean
 	alwaysAllowWrite?: boolean
 	alwaysAllowExecute?: boolean
@@ -70,7 +86,10 @@ export interface ExtensionState {
 	writeDelayMs: number
 	terminalOutputLineLimit?: number
 	mcpEnabled: boolean
-	experimentalDiffStrategy?: boolean
+	mode: Mode
+	modeApiConfigs?: Record<Mode, string>
+	enhancementApiConfigId?: string
+  experimentalDiffStrategy?: boolean
 }
 
 export interface ClineMessage {

src/shared/WebviewMessage.ts

@@ -1,10 +1,19 @@
 import { ApiConfiguration, ApiProvider } from "./api"
+import { Mode, PromptComponent } from "./modes"
+
+export type PromptMode = Mode | 'enhance'
 
 export type AudioType = "notification" | "celebration" | "progress_loop"
 
 export interface WebviewMessage {
 	type:
 		| "apiConfiguration"
+		| "currentApiConfigName"
+		| "upsertApiConfiguration"
+		| "deleteApiConfiguration"
+		| "loadApiConfiguration"
+		| "renameApiConfiguration"
+		| "getListApiConfiguration"
 		| "customInstructions"
 		| "allowedCommands"
 		| "alwaysAllowReadOnly"
@@ -54,7 +63,15 @@ export interface WebviewMessage {
 		| "searchCommits"
 		| "alwaysApproveResubmit"
 		| "requestDelaySeconds"
-		| "experimentalDiffStrategy"
+		| "setApiConfigPassword"
+		| "mode"
+		| "updatePrompt"
+		| "updateEnhancedPrompt"
+		| "getSystemPrompt"
+		| "systemPrompt"
+		| "enhancementApiConfigId"
+    | "experimentalDiffStrategy"
+
 	text?: string
 	disabled?: boolean
 	askResponse?: ClineAskResponse
@@ -67,6 +84,9 @@ export interface WebviewMessage {
 	serverName?: string
 	toolName?: string
 	alwaysAllow?: boolean
+	mode?: Mode
+	promptMode?: PromptMode
+	customPrompt?: PromptComponent
 	dataUrls?: string[]
 	values?: Record<string, any>
 	query?: string

src/shared/api.ts

@@ -51,6 +51,7 @@ export interface ApiHandlerOptions {
 
 export type ApiConfiguration = ApiHandlerOptions & {
 	apiProvider?: ApiProvider
+	id?: string // stable unique identifier
 }
 
 // Models

src/shared/checkExistApiConfig.ts

@@ -0,0 +1,19 @@
+import { ApiConfiguration } from "../shared/api";
+
+export function checkExistKey(config: ApiConfiguration | undefined) {
+	return config
+		? [
+			config.apiKey,
+			config.glamaApiKey,
+			config.openRouterApiKey,
+			config.awsRegion,
+			config.vertexProjectId,
+			config.openAiApiKey,
+			config.ollamaModelId,
+			config.lmStudioModelId,
+			config.geminiApiKey,
+			config.openAiNativeApiKey,
+			config.deepSeekApiKey
+		].some((key) => key !== undefined)
+		: false;
+}

src/shared/modes.ts

@@ -0,0 +1,30 @@
+export const codeMode = 'code' as const;
+export const architectMode = 'architect' as const;
+export const askMode = 'ask' as const;
+
+export type Mode = typeof codeMode | typeof architectMode | typeof askMode;
+
+export type PromptComponent = {
+    roleDefinition?: string;
+    customInstructions?: string;
+}
+
+export type CustomPrompts = {
+    ask?: PromptComponent;
+    code?: PromptComponent;
+    architect?: PromptComponent;
+    enhance?: string;
+}
+
+export const defaultPrompts = {
+    [askMode]: {
+        roleDefinition: "You are Cline, a knowledgeable technical assistant focused on answering questions and providing information about software development, technology, and related topics. You can analyze code, explain concepts, and access external resources while maintaining a read-only approach to the codebase. Make sure to answer the user's questions and don't rush to switch to implementing code.",
+    },
+    [codeMode]: {
+        roleDefinition: "You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.",
+    },
+    [architectMode]: {
+        roleDefinition: "You are Cline, a software architecture expert specializing in analyzing codebases, identifying patterns, and providing high-level technical guidance. You excel at understanding complex systems, evaluating architectural decisions, and suggesting improvements while maintaining a read-only approach to the codebase. Make sure to help the user come up with a solid implementation plan for their project and don't rush to switch to implementing code.",
+    },
+    enhance: "Generate an enhanced version of this prompt (reply with only the enhanced prompt - no conversation, explanations, lead-in, bullet points, placeholders, or surrounding quotes):"
+} as const;

src/utils/__tests__/cost.test.ts

@@ -0,0 +1,97 @@
+import { calculateApiCost } from '../cost';
+import { ModelInfo } from '../../shared/api';
+
+describe('Cost Utility', () => {
+    describe('calculateApiCost', () => {
+        const mockModelInfo: ModelInfo = {
+            maxTokens: 8192,
+            contextWindow: 200_000,
+            supportsPromptCache: true,
+            inputPrice: 3.0,  // $3 per million tokens
+            outputPrice: 15.0, // $15 per million tokens
+            cacheWritesPrice: 3.75, // $3.75 per million tokens
+            cacheReadsPrice: 0.3,  // $0.30 per million tokens
+        };
+
+        it('should calculate basic input/output costs correctly', () => {
+            const cost = calculateApiCost(mockModelInfo, 1000, 500);
+            
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Total: 0.003 + 0.0075 = 0.0105
+            expect(cost).toBe(0.0105);
+        });
+
+        it('should handle cache writes cost', () => {
+            const cost = calculateApiCost(mockModelInfo, 1000, 500, 2000);
+            
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Cache writes: (3.75 / 1_000_000) * 2000 = 0.0075
+            // Total: 0.003 + 0.0075 + 0.0075 = 0.018
+            expect(cost).toBeCloseTo(0.018, 6);
+        });
+
+        it('should handle cache reads cost', () => {
+            const cost = calculateApiCost(mockModelInfo, 1000, 500, undefined, 3000);
+            
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Cache reads: (0.3 / 1_000_000) * 3000 = 0.0009
+            // Total: 0.003 + 0.0075 + 0.0009 = 0.0114
+            expect(cost).toBe(0.0114);
+        });
+
+        it('should handle all cost components together', () => {
+            const cost = calculateApiCost(mockModelInfo, 1000, 500, 2000, 3000);
+            
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Cache writes: (3.75 / 1_000_000) * 2000 = 0.0075
+            // Cache reads: (0.3 / 1_000_000) * 3000 = 0.0009
+            // Total: 0.003 + 0.0075 + 0.0075 + 0.0009 = 0.0189
+            expect(cost).toBe(0.0189);
+        });
+
+        it('should handle missing prices gracefully', () => {
+            const modelWithoutPrices: ModelInfo = {
+                maxTokens: 8192,
+                contextWindow: 200_000,
+                supportsPromptCache: true
+            };
+
+            const cost = calculateApiCost(modelWithoutPrices, 1000, 500, 2000, 3000);
+            expect(cost).toBe(0);
+        });
+
+        it('should handle zero tokens', () => {
+            const cost = calculateApiCost(mockModelInfo, 0, 0, 0, 0);
+            expect(cost).toBe(0);
+        });
+
+        it('should handle undefined cache values', () => {
+            const cost = calculateApiCost(mockModelInfo, 1000, 500);
+            
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Total: 0.003 + 0.0075 = 0.0105
+            expect(cost).toBe(0.0105);
+        });
+
+        it('should handle missing cache prices', () => {
+            const modelWithoutCachePrices: ModelInfo = {
+                ...mockModelInfo,
+                cacheWritesPrice: undefined,
+                cacheReadsPrice: undefined
+            };
+
+            const cost = calculateApiCost(modelWithoutCachePrices, 1000, 500, 2000, 3000);
+            
+            // Should only include input and output costs
+            // Input cost: (3.0 / 1_000_000) * 1000 = 0.003
+            // Output cost: (15.0 / 1_000_000) * 500 = 0.0075
+            // Total: 0.003 + 0.0075 = 0.0105
+            expect(cost).toBe(0.0105);
+        });
+    });
+});

src/utils/__tests__/enhance-prompt.test.ts

@@ -1,80 +1,126 @@
 import { enhancePrompt } from '../enhance-prompt'
-import { buildApiHandler } from '../../api'
 import { ApiConfiguration } from '../../shared/api'
-import { OpenRouterHandler } from '../../api/providers/openrouter'
+import { buildApiHandler, SingleCompletionHandler } from '../../api'
+import { defaultPrompts } from '../../shared/modes'
 
-// Mock the buildApiHandler function
+// Mock the API handler
 jest.mock('../../api', () => ({
-    buildApiHandler: jest.fn()
+  buildApiHandler: jest.fn()
 }))
 
 describe('enhancePrompt', () => {
-    const mockApiConfig: ApiConfiguration = {
+  const mockApiConfig: ApiConfiguration = {
-        apiProvider: 'openrouter',
+    apiProvider: 'openai',
-        apiKey: 'test-key',
+    openAiApiKey: 'test-key',
-        openRouterApiKey: 'test-key',
+    openAiBaseUrl: 'https://api.openai.com/v1'
-        openRouterModelId: 'test-model'
+  }
-    }
 
-    // Create a mock handler that looks like OpenRouterHandler
+  beforeEach(() => {
-    const mockHandler = {
+    jest.clearAllMocks()
-        completePrompt: jest.fn(),
-        createMessage: jest.fn(),
-        getModel: jest.fn()
-    }
     
-    // Make instanceof check work
+    // Mock the API handler with a completePrompt method
-    Object.setPrototypeOf(mockHandler, OpenRouterHandler.prototype)
+    ;(buildApiHandler as jest.Mock).mockReturnValue({
-
+      completePrompt: jest.fn().mockResolvedValue('Enhanced prompt'),
-    beforeEach(() => {
+      createMessage: jest.fn(),
-        jest.clearAllMocks()
+      getModel: jest.fn().mockReturnValue({ 
-        ;(buildApiHandler as jest.Mock).mockReturnValue(mockHandler)
+        id: 'test-model',
-    })
+        info: {
-
+          maxTokens: 4096,
-    it('should throw error for non-OpenRouter providers', async () => {
+          contextWindow: 8192,
-        const nonOpenRouterConfig: ApiConfiguration = {
+          supportsPromptCache: false
-            apiProvider: 'anthropic',
-            apiKey: 'test-key',
-            apiModelId: 'claude-3'
         }
-        await expect(enhancePrompt(nonOpenRouterConfig, 'test')).rejects.toThrow('Prompt enhancement is only available with OpenRouter')
+      })
+    } as unknown as SingleCompletionHandler)
+  })
+
+  it('enhances prompt using default enhancement prompt when no custom prompt provided', async () => {
+    const result = await enhancePrompt(mockApiConfig, 'Test prompt')
+    
+    expect(result).toBe('Enhanced prompt')
+    const handler = buildApiHandler(mockApiConfig)
+    expect((handler as any).completePrompt).toHaveBeenCalledWith(
+      `${defaultPrompts.enhance}\n\nTest prompt`
+    )
+  })
+
+  it('enhances prompt using custom enhancement prompt when provided', async () => {
+    const customEnhancePrompt = 'You are a custom prompt enhancer'
+    
+    const result = await enhancePrompt(mockApiConfig, 'Test prompt', customEnhancePrompt)
+    
+    expect(result).toBe('Enhanced prompt')
+    const handler = buildApiHandler(mockApiConfig)
+    expect((handler as any).completePrompt).toHaveBeenCalledWith(
+      `${customEnhancePrompt}\n\nTest prompt`
+    )
+  })
+
+  it('throws error for empty prompt input', async () => {
+    await expect(enhancePrompt(mockApiConfig, '')).rejects.toThrow('No prompt text provided')
+  })
+
+  it('throws error for missing API configuration', async () => {
+    await expect(enhancePrompt({} as ApiConfiguration, 'Test prompt')).rejects.toThrow('No valid API configuration provided')
+  })
+
+  it('throws error for API provider that does not support prompt enhancement', async () => {
+    (buildApiHandler as jest.Mock).mockReturnValue({
+      // No completePrompt method
+      createMessage: jest.fn(),
+      getModel: jest.fn().mockReturnValue({ 
+        id: 'test-model',
+        info: {
+          maxTokens: 4096,
+          contextWindow: 8192,
+          supportsPromptCache: false
+        }
+      })
     })
 
-    it('should enhance a valid prompt', async () => {
+    await expect(enhancePrompt(mockApiConfig, 'Test prompt')).rejects.toThrow('The selected API provider does not support prompt enhancement')
-        const inputPrompt = 'Write a function to sort an array'
+  })
-        const enhancedPrompt = 'Write a TypeScript function that implements an efficient sorting algorithm for a generic array, including error handling and type safety'
 
-        mockHandler.completePrompt.mockResolvedValue(enhancedPrompt)
+  it('uses appropriate model based on provider', async () => {
+    const openRouterConfig: ApiConfiguration = {
+      apiProvider: 'openrouter',
+      openRouterApiKey: 'test-key',
+      openRouterModelId: 'test-model'
+    }
 
-        const result = await enhancePrompt(mockApiConfig, inputPrompt)
+    // Mock successful enhancement
+    ;(buildApiHandler as jest.Mock).mockReturnValue({
+      completePrompt: jest.fn().mockResolvedValue('Enhanced prompt'),
+      createMessage: jest.fn(),
+      getModel: jest.fn().mockReturnValue({ 
+        id: 'test-model',
+        info: {
+          maxTokens: 4096,
+          contextWindow: 8192,
+          supportsPromptCache: false
+        }
+      })
+    } as unknown as SingleCompletionHandler)
 
-        expect(result).toBe(enhancedPrompt)
+    const result = await enhancePrompt(openRouterConfig, 'Test prompt')
-        expect(buildApiHandler).toHaveBeenCalledWith(mockApiConfig)
-        expect(mockHandler.completePrompt).toHaveBeenCalledWith(
-            expect.stringContaining(inputPrompt)
-        )
-    })
     
-    it('should throw error when no prompt text is provided', async () => {
+    expect(buildApiHandler).toHaveBeenCalledWith(openRouterConfig)
-        await expect(enhancePrompt(mockApiConfig, '')).rejects.toThrow('No prompt text provided')
+    expect(result).toBe('Enhanced prompt')
-        expect(mockHandler.completePrompt).not.toHaveBeenCalled()
+  })
-    })
 
-    it('should pass through API errors', async () => {
+  it('propagates API errors', async () => {
-        const inputPrompt = 'Test prompt'
+    (buildApiHandler as jest.Mock).mockReturnValue({
-        mockHandler.completePrompt.mockRejectedValue('API error')
+      completePrompt: jest.fn().mockRejectedValue(new Error('API Error')),
+      createMessage: jest.fn(),
+      getModel: jest.fn().mockReturnValue({ 
+        id: 'test-model',
+        info: {
+          maxTokens: 4096,
+          contextWindow: 8192,
+          supportsPromptCache: false
+        }
+      })
+    } as unknown as SingleCompletionHandler)
 
-        await expect(enhancePrompt(mockApiConfig, inputPrompt)).rejects.toBe('API error')
+    await expect(enhancePrompt(mockApiConfig, 'Test prompt')).rejects.toThrow('API Error')
-    })
+  })
-
-    it('should pass the correct prompt format to the API', async () => {
-        const inputPrompt = 'Test prompt'
-        mockHandler.completePrompt.mockResolvedValue('Enhanced test prompt')
-        
-        await enhancePrompt(mockApiConfig, inputPrompt)
-
-        expect(mockHandler.completePrompt).toHaveBeenCalledWith(
-            'Generate an enhanced version of this prompt (reply with only the enhanced prompt - no conversation, explanations, lead-in, bullet points, placeholders, or surrounding quotes):\n\nTest prompt'
-        )
-    })
 })

src/utils/__tests__/git.test.ts

@@ -0,0 +1,336 @@
+import { jest } from '@jest/globals'
+import { searchCommits, getCommitInfo, getWorkingState, GitCommit } from '../git'
+import { ExecException } from 'child_process'
+
+type ExecFunction = (
+  command: string,
+  options: { cwd?: string },
+  callback: (error: ExecException | null, result?: { stdout: string; stderr: string }) => void
+) => void
+
+type PromisifiedExec = (command: string, options?: { cwd?: string }) => Promise<{ stdout: string; stderr: string }>
+
+// Mock child_process.exec
+jest.mock('child_process', () => ({
+  exec: jest.fn()
+}))
+
+// Mock util.promisify to return our own mock function
+jest.mock('util', () => ({
+  promisify: jest.fn((fn: ExecFunction): PromisifiedExec => {
+    return async (command: string, options?: { cwd?: string }) => {
+      // Call the original mock to maintain the mock implementation
+      return new Promise((resolve, reject) => {
+        fn(command, options || {}, (error: ExecException | null, result?: { stdout: string; stderr: string }) => {
+          if (error) {
+            reject(error)
+          } else {
+            resolve(result!)
+          }
+        })
+      })
+    }
+  })
+}))
+
+// Mock extract-text
+jest.mock('../../integrations/misc/extract-text', () => ({
+  truncateOutput: jest.fn(text => text)
+}))
+
+describe('git utils', () => {
+  // Get the mock with proper typing
+  const { exec } = jest.requireMock('child_process') as { exec: jest.MockedFunction<ExecFunction> }
+  const cwd = '/test/path'
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('searchCommits', () => {
+    const mockCommitData = [
+      'abc123def456',
+      'abc123',
+      'fix: test commit',
+      'John Doe',
+      '2024-01-06',
+      'def456abc789',
+      'def456',
+      'feat: new feature',
+      'Jane Smith',
+      '2024-01-05'
+    ].join('\n')
+
+    it('should return commits when git is installed and repo exists', async () => {
+      // Set up mock responses
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', { stdout: '.git', stderr: '' }],
+        ['git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short --grep="test" --regexp-ignore-case', { stdout: mockCommitData, stderr: '' }]
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        // Find matching response
+        for (const [cmd, response] of responses) {
+          if (command === cmd) {
+            callback(null, response)
+            return
+          }
+        }
+        callback(new Error(`Unexpected command: ${command}`))
+      })
+
+      const result = await searchCommits('test', cwd)
+
+      // First verify the result is correct
+      expect(result).toHaveLength(2)
+      expect(result[0]).toEqual({
+        hash: 'abc123def456',
+        shortHash: 'abc123',
+        subject: 'fix: test commit',
+        author: 'John Doe',
+        date: '2024-01-06'
+      })
+
+      // Then verify all commands were called correctly
+      expect(exec).toHaveBeenCalledWith(
+        'git --version',
+        {},
+        expect.any(Function)
+      )
+      expect(exec).toHaveBeenCalledWith(
+        'git rev-parse --git-dir',
+        { cwd },
+        expect.any(Function)
+      )
+      expect(exec).toHaveBeenCalledWith(
+        'git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short --grep="test" --regexp-ignore-case',
+        { cwd },
+        expect.any(Function)
+      )
+    }, 20000)
+
+    it('should return empty array when git is not installed', async () => {
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        if (command === 'git --version') {
+          callback(new Error('git not found'))
+          return
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await searchCommits('test', cwd)
+      expect(result).toEqual([])
+      expect(exec).toHaveBeenCalledWith('git --version', {}, expect.any(Function))
+    })
+
+    it('should return empty array when not in a git repository', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', null] // null indicates error should be called
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        const response = responses.get(command)
+        if (response === null) {
+          callback(new Error('not a git repository'))
+        } else if (response) {
+          callback(null, response)
+        } else {
+          callback(new Error('Unexpected command'))
+        }
+      })
+
+      const result = await searchCommits('test', cwd)
+      expect(result).toEqual([])
+      expect(exec).toHaveBeenCalledWith('git --version', {}, expect.any(Function))
+      expect(exec).toHaveBeenCalledWith('git rev-parse --git-dir', { cwd }, expect.any(Function))
+    })
+
+    it('should handle hash search when grep search returns no results', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', { stdout: '.git', stderr: '' }],
+        ['git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short --grep="abc123" --regexp-ignore-case', { stdout: '', stderr: '' }],
+        ['git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short --author-date-order abc123', { stdout: mockCommitData, stderr: '' }]
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        for (const [cmd, response] of responses) {
+          if (command === cmd) {
+            callback(null, response)
+            return
+          }
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await searchCommits('abc123', cwd)
+      expect(result).toHaveLength(2)
+      expect(result[0]).toEqual({
+        hash: 'abc123def456',
+        shortHash: 'abc123',
+        subject: 'fix: test commit',
+        author: 'John Doe',
+        date: '2024-01-06'
+      })
+    })
+  })
+
+  describe('getCommitInfo', () => {
+    const mockCommitInfo = [
+      'abc123def456',
+      'abc123',
+      'fix: test commit',
+      'John Doe',
+      '2024-01-06',
+      'Detailed description'
+    ].join('\n')
+    const mockStats = '1 file changed, 2 insertions(+), 1 deletion(-)'
+    const mockDiff = '@@ -1,1 +1,2 @@\n-old line\n+new line'
+
+    it('should return formatted commit info', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', { stdout: '.git', stderr: '' }],
+        ['git show --format="%H%n%h%n%s%n%an%n%ad%n%b" --no-patch abc123', { stdout: mockCommitInfo, stderr: '' }],
+        ['git show --stat --format="" abc123', { stdout: mockStats, stderr: '' }],
+        ['git show --format="" abc123', { stdout: mockDiff, stderr: '' }]
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        for (const [cmd, response] of responses) {
+          if (command.startsWith(cmd)) {
+            callback(null, response)
+            return
+          }
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await getCommitInfo('abc123', cwd)
+      expect(result).toContain('Commit: abc123')
+      expect(result).toContain('Author: John Doe')
+      expect(result).toContain('Files Changed:')
+      expect(result).toContain('Full Changes:')
+    })
+
+    it('should return error message when git is not installed', async () => {
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        if (command === 'git --version') {
+          callback(new Error('git not found'))
+          return
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await getCommitInfo('abc123', cwd)
+      expect(result).toBe('Git is not installed')
+    })
+
+    it('should return error message when not in a git repository', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', null] // null indicates error should be called
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        const response = responses.get(command)
+        if (response === null) {
+          callback(new Error('not a git repository'))
+        } else if (response) {
+          callback(null, response)
+        } else {
+          callback(new Error('Unexpected command'))
+        }
+      })
+
+      const result = await getCommitInfo('abc123', cwd)
+      expect(result).toBe('Not a git repository')
+    })
+  })
+
+  describe('getWorkingState', () => {
+    const mockStatus = ' M src/file1.ts\n?? src/file2.ts'
+    const mockDiff = '@@ -1,1 +1,2 @@\n-old line\n+new line'
+
+    it('should return working directory changes', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', { stdout: '.git', stderr: '' }],
+        ['git status --short', { stdout: mockStatus, stderr: '' }],
+        ['git diff HEAD', { stdout: mockDiff, stderr: '' }]
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        for (const [cmd, response] of responses) {
+          if (command === cmd) {
+            callback(null, response)
+            return
+          }
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await getWorkingState(cwd)
+      expect(result).toContain('Working directory changes:')
+      expect(result).toContain('src/file1.ts')
+      expect(result).toContain('src/file2.ts')
+    })
+
+    it('should return message when working directory is clean', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', { stdout: '.git', stderr: '' }],
+        ['git status --short', { stdout: '', stderr: '' }]
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        for (const [cmd, response] of responses) {
+          if (command === cmd) {
+            callback(null, response)
+            return
+          }
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await getWorkingState(cwd)
+      expect(result).toBe('No changes in working directory')
+    })
+
+    it('should return error message when git is not installed', async () => {
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        if (command === 'git --version') {
+          callback(new Error('git not found'))
+          return
+        }
+        callback(new Error('Unexpected command'))
+      })
+
+      const result = await getWorkingState(cwd)
+      expect(result).toBe('Git is not installed')
+    })
+
+    it('should return error message when not in a git repository', async () => {
+      const responses = new Map([
+        ['git --version', { stdout: 'git version 2.39.2', stderr: '' }],
+        ['git rev-parse --git-dir', null] // null indicates error should be called
+      ])
+
+      exec.mockImplementation((command: string, options: { cwd?: string }, callback: Function) => {
+        const response = responses.get(command)
+        if (response === null) {
+          callback(new Error('not a git repository'))
+        } else if (response) {
+          callback(null, response)
+        } else {
+          callback(new Error('Unexpected command'))
+        }
+      })
+
+      const result = await getWorkingState(cwd)
+      expect(result).toBe('Not a git repository')
+    })
+  })
+})

src/utils/__tests__/path.test.ts

@@ -0,0 +1,135 @@
+import { arePathsEqual, getReadablePath } from '../path';
+import * as path from 'path';
+import os from 'os';
+
+describe('Path Utilities', () => {
+    const originalPlatform = process.platform;
+
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform
+        });
+    });
+
+    describe('String.prototype.toPosix', () => {
+        it('should convert backslashes to forward slashes', () => {
+            const windowsPath = 'C:\\Users\\test\\file.txt';
+            expect(windowsPath.toPosix()).toBe('C:/Users/test/file.txt');
+        });
+
+        it('should not modify paths with forward slashes', () => {
+            const unixPath = '/home/user/file.txt';
+            expect(unixPath.toPosix()).toBe('/home/user/file.txt');
+        });
+
+        it('should preserve extended-length Windows paths', () => {
+            const extendedPath = '\\\\?\\C:\\Very\\Long\\Path';
+            expect(extendedPath.toPosix()).toBe('\\\\?\\C:\\Very\\Long\\Path');
+        });
+    });
+
+    describe('arePathsEqual', () => {
+        describe('on Windows', () => {
+            beforeEach(() => {
+                Object.defineProperty(process, 'platform', {
+                    value: 'win32'
+                });
+            });
+
+            it('should compare paths case-insensitively', () => {
+                expect(arePathsEqual('C:\\Users\\Test', 'c:\\users\\test')).toBe(true);
+            });
+
+            it('should handle different path separators', () => {
+                // Convert both paths to use forward slashes after normalization
+                const path1 = path.normalize('C:\\Users\\Test').replace(/\\/g, '/');
+                const path2 = path.normalize('C:/Users/Test').replace(/\\/g, '/');
+                expect(arePathsEqual(path1, path2)).toBe(true);
+            });
+
+            it('should normalize paths with ../', () => {
+                // Convert both paths to use forward slashes after normalization
+                const path1 = path.normalize('C:\\Users\\Test\\..\\Test').replace(/\\/g, '/');
+                const path2 = path.normalize('C:\\Users\\Test').replace(/\\/g, '/');
+                expect(arePathsEqual(path1, path2)).toBe(true);
+            });
+        });
+
+        describe('on POSIX', () => {
+            beforeEach(() => {
+                Object.defineProperty(process, 'platform', {
+                    value: 'darwin'
+                });
+            });
+
+            it('should compare paths case-sensitively', () => {
+                expect(arePathsEqual('/Users/Test', '/Users/test')).toBe(false);
+            });
+
+            it('should normalize paths', () => {
+                expect(arePathsEqual('/Users/./Test', '/Users/Test')).toBe(true);
+            });
+
+            it('should handle trailing slashes', () => {
+                expect(arePathsEqual('/Users/Test/', '/Users/Test')).toBe(true);
+            });
+        });
+
+        describe('edge cases', () => {
+            it('should handle undefined paths', () => {
+                expect(arePathsEqual(undefined, undefined)).toBe(true);
+                expect(arePathsEqual('/test', undefined)).toBe(false);
+                expect(arePathsEqual(undefined, '/test')).toBe(false);
+            });
+
+            it('should handle root paths with trailing slashes', () => {
+                expect(arePathsEqual('/', '/')).toBe(true);
+                expect(arePathsEqual('C:\\', 'C:\\')).toBe(true);
+            });
+        });
+    });
+
+    describe('getReadablePath', () => {
+        const homeDir = os.homedir();
+        const desktop = path.join(homeDir, 'Desktop');
+
+        it('should return basename when path equals cwd', () => {
+            const cwd = '/Users/test/project';
+            expect(getReadablePath(cwd, cwd)).toBe('project');
+        });
+
+        it('should return relative path when inside cwd', () => {
+            const cwd = '/Users/test/project';
+            const filePath = '/Users/test/project/src/file.txt';
+            expect(getReadablePath(cwd, filePath)).toBe('src/file.txt');
+        });
+
+        it('should return absolute path when outside cwd', () => {
+            const cwd = '/Users/test/project';
+            const filePath = '/Users/test/other/file.txt';
+            expect(getReadablePath(cwd, filePath)).toBe('/Users/test/other/file.txt');
+        });
+
+        it('should handle Desktop as cwd', () => {
+            const filePath = path.join(desktop, 'file.txt');
+            expect(getReadablePath(desktop, filePath)).toBe(filePath.toPosix());
+        });
+
+        it('should handle undefined relative path', () => {
+            const cwd = '/Users/test/project';
+            expect(getReadablePath(cwd)).toBe('project');
+        });
+
+        it('should handle parent directory traversal', () => {
+            const cwd = '/Users/test/project';
+            const filePath = '../../other/file.txt';
+            expect(getReadablePath(cwd, filePath)).toBe('/Users/other/file.txt');
+        });
+
+        it('should normalize paths with redundant segments', () => {
+            const cwd = '/Users/test/project';
+            const filePath = '/Users/test/project/./src/../src/file.txt';
+            expect(getReadablePath(cwd, filePath)).toBe('src/file.txt');
+        });
+    });
+});

src/utils/enhance-prompt.ts

@@ -1,26 +1,27 @@
 import { ApiConfiguration } from "../shared/api"
-import { buildApiHandler } from "../api"
+import { buildApiHandler, SingleCompletionHandler } from "../api"
-import { OpenRouterHandler } from "../api/providers/openrouter"
+import { defaultPrompts } from "../shared/modes"
 
 /**
- * Enhances a prompt using the OpenRouter API without creating a full Cline instance or task history.
+ * Enhances a prompt using the configured API without creating a full Cline instance or task history.
  * This is a lightweight alternative that only uses the API's completion functionality.
  */
-export async function enhancePrompt(apiConfiguration: ApiConfiguration, promptText: string): Promise<string> {
+export async function enhancePrompt(apiConfiguration: ApiConfiguration, promptText: string, enhancePrompt?: string): Promise<string> {
     if (!promptText) {
         throw new Error("No prompt text provided")
     }
-    if (apiConfiguration.apiProvider !== "openrouter") {
+    if (!apiConfiguration || !apiConfiguration.apiProvider) {
-        throw new Error("Prompt enhancement is only available with OpenRouter")
+        throw new Error("No valid API configuration provided")
     }
     
     const handler = buildApiHandler(apiConfiguration)
     
-    // Type guard to check if handler is OpenRouterHandler
+    // Check if handler supports single completions
-    if (!(handler instanceof OpenRouterHandler)) {
+    if (!('completePrompt' in handler)) {
-        throw new Error("Expected OpenRouter handler")
+        throw new Error("The selected API provider does not support prompt enhancement")
     }
     
-    const prompt = `Generate an enhanced version of this prompt (reply with only the enhanced prompt - no conversation, explanations, lead-in, bullet points, placeholders, or surrounding quotes):\n\n${promptText}`
+    const enhancePromptText = enhancePrompt ?? defaultPrompts.enhance
-    return handler.completePrompt(prompt)
+    const prompt = `${enhancePromptText}\n\n${promptText}`
+    return (handler as SingleCompletionHandler).completePrompt(prompt)
 }

webview-ui/config-overrides.js

@@ -0,0 +1,22 @@
+const { override } = require('customize-cra');
+
+module.exports = override();
+
+// Jest configuration override
+module.exports.jest = function(config) {
+    // Configure reporters
+    config.reporters = [["jest-simple-dot-reporter", {}]];
+    
+    // Configure module name mapper for CSS modules
+    config.moduleNameMapper = {
+        ...config.moduleNameMapper,
+        "\\.(css|less|scss|sass)$": "identity-obj-proxy"
+    };
+    
+    // Configure transform ignore patterns for ES modules
+    config.transformIgnorePatterns = [
+        '/node_modules/(?!(rehype-highlight|react-remark|unist-util-visit|unist-util-find-after|vfile|unified|bail|is-plain-obj|trough|vfile-message|unist-util-stringify-position|mdast-util-from-markdown|mdast-util-to-string|micromark|decode-named-character-reference|character-entities|markdown-table|zwitch|longest-streak|escape-string-regexp|unist-util-is|hast-util-to-text|@vscode/webview-ui-toolkit|@microsoft/fast-react-wrapper|@microsoft/fast-element|@microsoft/fast-foundation|@microsoft/fast-web-utilities|exenv-es6)/)'
+    ];
+    
+    return config;
+}

webview-ui/package-lock.json

@@ -18,7 +18,7 @@
 				"@vscode/webview-ui-toolkit": "^1.4.0",
 				"debounce": "^2.1.1",
 				"fast-deep-equal": "^3.1.3",
-				"fuse.js": "^7.0.0",
+				"fzf": "^0.5.2",
 				"react": "^18.3.1",
 				"react-dom": "^18.3.1",
 				"react-remark": "^2.1.0",
@@ -37,7 +37,10 @@
 				"@babel/plugin-proposal-private-property-in-object": "^7.21.11",
 				"@types/shell-quote": "^1.7.5",
 				"@types/vscode-webview": "^1.57.5",
-				"eslint": "^8.57.0"
+				"customize-cra": "^1.0.0",
+				"eslint": "^8.57.0",
+				"jest-simple-dot-reporter": "^1.0.5",
+				"react-app-rewired": "^2.2.1"
 			}
 		},
 		"node_modules/@adobe/css-tools": {
@@ -5624,6 +5627,15 @@
 			"version": "3.1.3",
 			"license": "MIT"
 		},
+		"node_modules/customize-cra": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/customize-cra/-/customize-cra-1.0.0.tgz",
+			"integrity": "sha512-DbtaLuy59224U+xCiukkxSq8clq++MOtJ1Et7LED1fLszWe88EoblEYFBJ895sB1mC6B4uu3xPT/IjClELhMbA==",
+			"dev": true,
+			"dependencies": {
+				"lodash.flow": "^3.5.0"
+			}
+		},
 		"node_modules/damerau-levenshtein": {
 			"version": "1.0.8",
 			"license": "BSD-2-Clause"
@@ -7468,12 +7480,10 @@
 				"url": "https://github.com/sponsors/ljharb"
 			}
 		},
-		"node_modules/fuse.js": {
+		"node_modules/fzf": {
-			"version": "7.0.0",
+			"version": "0.5.2",
-			"license": "Apache-2.0",
+			"resolved": "https://registry.npmjs.org/fzf/-/fzf-0.5.2.tgz",
-			"engines": {
+			"integrity": "sha512-Tt4kuxLXFKHy8KT40zwsUPUkg1CrsgY25FxA2U/j/0WgEDCk3ddc/zLTCCcbSHX9FcKtLuVaDGtGE/STWC+j3Q=="
-				"node": ">=10"
-			}
 		},
 		"node_modules/gensync": {
 			"version": "1.0.0-beta.2",
@@ -9257,6 +9267,12 @@
 				"node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
 			}
 		},
+		"node_modules/jest-simple-dot-reporter": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/jest-simple-dot-reporter/-/jest-simple-dot-reporter-1.0.5.tgz",
+			"integrity": "sha512-cZLFG/C7k0+WYoIGGuGXKm0vmJiXlWG/m3uCZ4RaMPYxt8lxjdXMLHYkxXaQ7gVWaSPe7uAPCEUcRxthC5xskg==",
+			"dev": true
+		},
 		"node_modules/jest-snapshot": {
 			"version": "27.5.1",
 			"license": "MIT",
@@ -9896,6 +9912,12 @@
 			"version": "4.0.8",
 			"license": "MIT"
 		},
+		"node_modules/lodash.flow": {
+			"version": "3.5.0",
+			"resolved": "https://registry.npmjs.org/lodash.flow/-/lodash.flow-3.5.0.tgz",
+			"integrity": "sha512-ff3BX/tSioo+XojX4MOsOMhJw0nZoUEF011LX8g8d3gvjVbxd89cCio4BCXronjxcTUIJUoqKEUA+n4CqvvRPw==",
+			"dev": true
+		},
 		"node_modules/lodash.memoize": {
 			"version": "4.1.2",
 			"license": "MIT"
@@ -12269,6 +12291,30 @@
 			"version": "0.13.11",
 			"license": "MIT"
 		},
+		"node_modules/react-app-rewired": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/react-app-rewired/-/react-app-rewired-2.2.1.tgz",
+			"integrity": "sha512-uFQWTErXeLDrMzOJHKp0h8P1z0LV9HzPGsJ6adOtGlA/B9WfT6Shh4j2tLTTGlXOfiVx6w6iWpp7SOC5pvk+gA==",
+			"dev": true,
+			"dependencies": {
+				"semver": "^5.6.0"
+			},
+			"bin": {
+				"react-app-rewired": "bin/index.js"
+			},
+			"peerDependencies": {
+				"react-scripts": ">=2.1.3"
+			}
+		},
+		"node_modules/react-app-rewired/node_modules/semver": {
+			"version": "5.7.2",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
+			"integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
+			"dev": true,
+			"bin": {
+				"semver": "bin/semver"
+			}
+		},
 		"node_modules/react-dev-utils": {
 			"version": "12.0.1",
 			"license": "MIT",

webview-ui/package.json

@@ -13,7 +13,7 @@
 		"@vscode/webview-ui-toolkit": "^1.4.0",
 		"debounce": "^2.1.1",
 		"fast-deep-equal": "^3.1.3",
-		"fuse.js": "^7.0.0",
+		"fzf": "^0.5.2",
 		"react": "^18.3.1",
 		"react-dom": "^18.3.1",
 		"react-remark": "^2.1.0",
@@ -29,9 +29,9 @@
 		"web-vitals": "^2.1.4"
 	},
 	"scripts": {
-		"start": "react-scripts start",
+		"start": "react-app-rewired start",
 		"build": "node ./scripts/build-react-no-split.js",
-		"test": "react-scripts test --watchAll=false",
+		"test": "react-app-rewired test --watchAll=false",
 		"eject": "react-scripts eject",
 		"lint": "eslint src --ext ts,tsx"
 	},
@@ -57,14 +57,9 @@
 		"@babel/plugin-proposal-private-property-in-object": "^7.21.11",
 		"@types/shell-quote": "^1.7.5",
 		"@types/vscode-webview": "^1.57.5",
-		"eslint": "^8.57.0"
+		"customize-cra": "^1.0.0",
-	},
+		"eslint": "^8.57.0",
-	"jest": {
+		"jest-simple-dot-reporter": "^1.0.5",
-		"transformIgnorePatterns": [
+		"react-app-rewired": "^2.2.1"
-			"/node_modules/(?!(rehype-highlight|react-remark|unist-util-visit|unist-util-find-after|vfile|unified|bail|is-plain-obj|trough|vfile-message|unist-util-stringify-position|mdast-util-from-markdown|mdast-util-to-string|micromark|decode-named-character-reference|character-entities|markdown-table|zwitch|longest-streak|escape-string-regexp|unist-util-is|hast-util-to-text|@vscode/webview-ui-toolkit|@microsoft/fast-react-wrapper|@microsoft/fast-element|@microsoft/fast-foundation|@microsoft/fast-web-utilities|exenv-es6)/)"
-		],
-		"moduleNameMapper": {
-			"\\.(css|less|scss|sass)$": "identity-obj-proxy"
-		}
 	}
 }

webview-ui/src/App.tsx

@@ -8,12 +8,14 @@ import WelcomeView from "./components/welcome/WelcomeView"
 import { ExtensionStateContextProvider, useExtensionState } from "./context/ExtensionStateContext"
 import { vscode } from "./utils/vscode"
 import McpView from "./components/mcp/McpView"
+import PromptsView from "./components/prompts/PromptsView"
 
 const AppContent = () => {
 	const { didHydrateState, showWelcome, shouldShowAnnouncement } = useExtensionState()
 	const [showSettings, setShowSettings] = useState(false)
 	const [showHistory, setShowHistory] = useState(false)
 	const [showMcp, setShowMcp] = useState(false)
+	const [showPrompts, setShowPrompts] = useState(false)
 	const [showAnnouncement, setShowAnnouncement] = useState(false)
 
 	const handleMessage = useCallback((e: MessageEvent) => {
@@ -25,21 +27,31 @@ const AppContent = () => {
 						setShowSettings(true)
 						setShowHistory(false)
 						setShowMcp(false)
+						setShowPrompts(false)
 						break
 					case "historyButtonClicked":
 						setShowSettings(false)
 						setShowHistory(true)
 						setShowMcp(false)
+						setShowPrompts(false)
 						break
 					case "mcpButtonClicked":
 						setShowSettings(false)
 						setShowHistory(false)
 						setShowMcp(true)
+						setShowPrompts(false)
+						break
+					case "promptsButtonClicked":
+						setShowSettings(false)
+						setShowHistory(false)
+						setShowMcp(false)
+						setShowPrompts(true)
 						break
 					case "chatButtonClicked":
 						setShowSettings(false)
 						setShowHistory(false)
 						setShowMcp(false)
+						setShowPrompts(false)
 						break
 				}
 				break
@@ -68,14 +80,16 @@ const AppContent = () => {
 					{showSettings && <SettingsView onDone={() => setShowSettings(false)} />}
 					{showHistory && <HistoryView onDone={() => setShowHistory(false)} />}
 					{showMcp && <McpView onDone={() => setShowMcp(false)} />}
+					{showPrompts && <PromptsView onDone={() => setShowPrompts(false)} />}
 					{/* Do not conditionally load ChatView, it's expensive and there's state we don't want to lose (user input, disableInput, askResponse promise, etc.) */}
 					<ChatView
 						showHistoryView={() => {
 							setShowSettings(false)
 							setShowMcp(false)
+							setShowPrompts(false)
 							setShowHistory(true)
 						}}
-						isHidden={showSettings || showHistory || showMcp}
+						isHidden={showSettings || showHistory || showMcp || showPrompts}
 						showAnnouncement={showAnnouncement}
 						hideAnnouncement={() => {
 							setShowAnnouncement(false)

webview-ui/src/components/chat/Announcement.tsx

@@ -29,100 +29,39 @@ const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
 				style={{ position: "absolute", top: "8px", right: "8px" }}>
 				<span className="codicon codicon-close"></span>
 			</VSCodeButton>
+			<h2 style={{ margin: "0 0 8px" }}>
+				🎉{"  "}Introducing Roo Cline v{minorVersion}
+			</h2>
+
 			<h3 style={{ margin: "0 0 8px" }}>
-				🎉{"  "}New in Cline v{minorVersion}
+				Agent Modes Customization
 			</h3>
-			<p style={{ margin: "5px 0px", fontWeight: "bold" }}>Add custom tools to Cline using MCP!</p>
 			<p style={{ margin: "5px 0px" }}>
-				The Model Context Protocol allows agents like Cline to plug and play custom tools,{" "}
+				Click the new <span className="codicon codicon-notebook" style={{ fontSize: "10px" }}></span> icon in the menu bar to open the Prompts Settings and customize Agent Modes for new levels of productivity.
-				<VSCodeLink href="https://github.com/modelcontextprotocol/servers" style={{ display: "inline" }}>
-					e.g. a web-search tool or GitHub tool.
-				</VSCodeLink>
-			</p>
-			<p style={{ margin: "5px 0px" }}>
-				You can add and configure MCP servers by clicking the new{" "}
-				<span className="codicon codicon-server" style={{ fontSize: "10px" }}></span> icon in the menu bar.
-			</p>
-			<p style={{ margin: "5px 0px" }}>
-				To take things a step further, Cline also has the ability to create custom tools for himself. Just say
-				"add a tool that..." and watch as he builds and installs new capabilities specific to{" "}
-				<i>your workflow</i>. For example:
 				<ul style={{ margin: "4px 0 6px 20px", padding: 0 }}>
-					<li>"...fetches Jira tickets": Get ticket ACs and put Cline to work</li>
+					<li>Tailor how Roo Cline behaves in different modes: Code, Architect, and Ask.</li>
-					<li>"...manages AWS EC2s": Check server metrics and scale up or down</li>
+					<li>Preview and verify your changes using the Preview System Prompt button.</li>
-					<li>"...pulls PagerDuty incidents": Pulls details to help Cline fix bugs</li>
 				</ul>
-				Cline handles everything from creating the MCP server to installing it in the extension, ready to use in
-				future tasks. The servers are saved to <code>~/Documents/Cline/MCP</code> so you can easily share them
-				with others too.{" "}
 			</p>
+
+			<h3 style={{ margin: "0 0 8px" }}>
+				Prompt Enhancement Configuration
+			</h3>
 			<p style={{ margin: "5px 0px" }}>
-				Try it yourself by asking Cline to "add a tool that gets the latest npm docs", or
+				Now available for all providers! Access it directly in the chat box by clicking the <span className="codicon codicon-sparkle" style={{ fontSize: "10px" }}></span> sparkle icon next to the input field. From there, you can customize the enhancement logic and provider to best suit your workflow.
-				<VSCodeLink href="https://x.com/sdrzn/status/1867271665086074969" style={{ display: "inline" }}>
+				<ul style={{ margin: "4px 0 6px 20px", padding: 0 }}>
-					see a demo of MCP in action here.
+					<li>Customize how prompts are enhanced for better results in your workflow.</li>
-				</VSCodeLink>
+					<li>Use the sparkle icon in the chat box to select a API configuration and provider (e.g., GPT-4) and configure your own enhancement logic.</li>
+					<li>Test your changes instantly with the Preview Prompt Enhancement tool.</li>
+				</ul>
 			</p>
-			{/*<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
+
-				 <li>
+			<p style={{ margin: "5px 0px" }}>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
+				We're very excited to see what you build with this new feature! Join us at
-					so I recommend trying them out.
+				<VSCodeLink href="https://www.reddit.com/r/roocline" style={{ display: "inline" }}>
-					<br />
+					reddit.com/r/roocline
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li> 
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div
-				style={{
-					height: "1px",
-					background: "var(--vscode-foreground)",
-					opacity: 0.1,
-					margin: "8px 0",
-				}}
-			/>
-			<p style={{ margin: "0" }}>
-				Join
-				<VSCodeLink style={{ display: "inline" }} href="https://discord.gg/cline">
-					discord.gg/cline
 				</VSCodeLink>
-				for more updates!
+				to discuss and share feedback.
 			</p>
 		</div>
 	)

webview-ui/src/components/chat/ChatRow.tsx

@@ -1,6 +1,6 @@
 import { VSCodeBadge, VSCodeButton, VSCodeProgressRing } from "@vscode/webview-ui-toolkit/react"
 import deepEqual from "fast-deep-equal"
-import React, { memo, useEffect, useMemo, useRef } from "react"
+import React, { memo, useEffect, useMemo, useRef, useState } from "react"
 import { useSize } from "react-use"
 import {
 	ClineApiReqInfo,
@@ -154,6 +154,8 @@ export const ChatRowContent = ({
 						style={{ color: successColor, marginBottom: "-1.5px" }}></span>,
 					<span style={{ color: successColor, fontWeight: "bold" }}>Task Completed</span>,
 				]
+			case "api_req_retry_delayed":
+				return []
 			case "api_req_started":
 				const getIconSpan = (iconName: string, color: string) => (
 					<div
@@ -211,15 +213,7 @@ export const ChatRowContent = ({
 			default:
 				return [null, null]
 		}
-	}, [
+	}, [type, isCommandExecuting, message, isMcpServerResponding, apiReqCancelReason, cost, apiRequestFailedMessage])
-		type,
-		cost,
-		apiRequestFailedMessage,
-		isCommandExecuting,
-		apiReqCancelReason,
-		isMcpServerResponding,
-		message.text,
-	])
 
 	const headerStyle: React.CSSProperties = {
 		display: "flex",
@@ -557,7 +551,7 @@ export const ChatRowContent = ({
 				case "text":
 					return (
 						<div>
-							<Markdown markdown={message.text} />
+							<Markdown markdown={message.text} partial={message.partial} />
 						</div>
 					)
 				case "user_feedback":
@@ -709,7 +703,7 @@ export const ChatRowContent = ({
 								</div>
 							)}
 							<div style={{ paddingTop: 10 }}>
-								<Markdown markdown={message.text} />
+								<Markdown markdown={message.text} partial={message.partial} />
 							</div>
 						</>
 					)
@@ -882,7 +876,7 @@ export const ChatRowContent = ({
 									{title}
 								</div>
 								<div style={{ color: "var(--vscode-charts-green)", paddingTop: 10 }}>
-									<Markdown markdown={message.text} />
+									<Markdown markdown={message.text} partial={message.partial} />
 								</div>
 							</div>
 						)
@@ -924,10 +918,63 @@ export const ProgressIndicator = () => (
 	</div>
 )
 
-const Markdown = memo(({ markdown }: { markdown?: string }) => {
+const Markdown = memo(({ markdown, partial }: { markdown?: string; partial?: boolean }) => {
+	const [isHovering, setIsHovering] = useState(false);
+
 	return (
-		<div style={{ wordBreak: "break-word", overflowWrap: "anywhere", marginBottom: -15, marginTop: -15 }}>
+		<div
-			<MarkdownBlock markdown={markdown} />
+			onMouseEnter={() => setIsHovering(true)}
+			onMouseLeave={() => setIsHovering(false)}
+			style={{ position: "relative" }}
+		>
+			<div style={{ wordBreak: "break-word", overflowWrap: "anywhere", marginBottom: -15, marginTop: -15 }}>
+				<MarkdownBlock markdown={markdown} />
+			</div>
+			{markdown && !partial && isHovering && (
+				<div
+					style={{
+						position: "absolute",
+						bottom: "-4px",
+						right: "8px",
+						opacity: 0,
+						animation: "fadeIn 0.2s ease-in-out forwards",
+						borderRadius: "4px"
+					}}
+				>
+					<style>
+						{`
+							@keyframes fadeIn {
+								from { opacity: 0; }
+								to { opacity: 1.0; }
+							}
+						`}
+					</style>
+					<VSCodeButton
+						className="copy-button"
+						appearance="icon"
+						style={{
+							height: "24px",
+							border: "none",
+							background: "var(--vscode-editor-background)",
+							transition: "background 0.2s ease-in-out"
+						}}
+						onClick={() => {
+							navigator.clipboard.writeText(markdown);
+							// Flash the button background briefly to indicate success
+							const button = document.activeElement as HTMLElement;
+							if (button) {
+								button.style.background = "var(--vscode-button-background)";
+								setTimeout(() => {
+									button.style.background = "";
+								}, 200);
+							}
+						}}
+						title="Copy as markdown"
+					>
+						<span className="codicon codicon-copy"></span>
+					</VSCodeButton>
+				</div>
+			)}
 		</div>
 	)
 })

webview-ui/src/components/chat/ChatTextArea.tsx

@@ -14,6 +14,8 @@ import ContextMenu from "./ContextMenu"
 import Thumbnails from "../common/Thumbnails"
 import { vscode } from "../../utils/vscode"
 import { WebviewMessage } from "../../../../src/shared/WebviewMessage"
+import { Mode } from "../../../../src/core/prompts/types"
+import { CaretIcon } from "../common/CaretIcon"
 
 interface ChatTextAreaProps {
 	inputValue: string
@@ -26,6 +28,8 @@ interface ChatTextAreaProps {
 	onSelectImages: () => void
 	shouldDisableImages: boolean
 	onHeightChange?: (height: number) => void
+	mode: Mode
+	setMode: (value: Mode) => void
 }
 
 const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
@@ -41,19 +45,34 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			onSelectImages,
 			shouldDisableImages,
 			onHeightChange,
+			mode,
+			setMode,
 		},
 		ref,
 	) => {
-		const { filePaths, apiConfiguration } = useExtensionState()
+		const { filePaths, currentApiConfigName, listApiConfigMeta } = useExtensionState()
-		const [isTextAreaFocused, setIsTextAreaFocused] = useState(false)
 		const [gitCommits, setGitCommits] = useState<any[]>([])
+		const [showDropdown, setShowDropdown] = useState(false)
+
+		// Close dropdown when clicking outside
+		useEffect(() => {
+			const handleClickOutside = (event: MouseEvent) => {
+				if (showDropdown) {
+					setShowDropdown(false)
+				}
+			}
+			document.addEventListener("mousedown", handleClickOutside)
+			return () => document.removeEventListener("mousedown", handleClickOutside)
+		}, [showDropdown])
 
 		// Handle enhanced prompt response
 		useEffect(() => {
 			const messageHandler = (event: MessageEvent) => {
 				const message = event.data
-				if (message.type === 'enhancedPrompt' && message.text) {
+				if (message.type === 'enhancedPrompt') {
-					setInputValue(message.text)
+					if (message.text) {
+						setInputValue(message.text)
+					}
 					setIsEnhancingPrompt(false)
 				} else if (message.type === 'commitSearchResults') {
 					const commits = message.commits.map((commit: any) => ({
@@ -357,7 +376,6 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			if (!isMouseDownOnMenu) {
 				setShowContextMenu(false)
 			}
-			setIsTextAreaFocused(false)
 		}, [isMouseDownOnMenu])
 
 		const handlePaste = useCallback(
@@ -475,65 +493,97 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			[updateCursorPosition],
 		)
 
+		const selectStyle = {
+			fontSize: "11px",
+			cursor: textAreaDisabled ? "not-allowed" : "pointer",
+			backgroundColor: "transparent",
+			border: "none",
+			color: "var(--vscode-foreground)",
+			opacity: textAreaDisabled ? 0.5 : 0.8,
+			outline: "none",
+			paddingLeft: "20px",
+			paddingRight: "6px",
+			WebkitAppearance: "none" as const,
+			MozAppearance: "none" as const,
+			appearance: "none" as const
+		}
+
+		const caretContainerStyle = {
+			position: "absolute" as const,
+			left: 6,
+			top: "50%",
+			transform: "translateY(-45%)",
+			pointerEvents: "none" as const,
+			opacity: textAreaDisabled ? 0.5 : 0.8
+		}
+
 		return (
-			<div style={{
+			<div 
-				padding: "10px 15px",
+				className="chat-text-area"
-				opacity: textAreaDisabled ? 0.5 : 1,
+				style={{
-				position: "relative",
+					opacity: textAreaDisabled ? 0.5 : 1,
-				display: "flex",
+					position: "relative",
-			}}
+					display: "flex",
-			onDrop={async (e) => {
+					flexDirection: "column",
-				e.preventDefault()
+					gap: "8px",
-				const files = Array.from(e.dataTransfer.files)
+					backgroundColor: "var(--vscode-input-background)",
-				const text = e.dataTransfer.getData("text")
+					minHeight: "100px",
-				if (text) {
+					margin: "10px 15px",
-					const newValue =
+					padding: "8px"
-						inputValue.slice(0, cursorPosition) + text + inputValue.slice(cursorPosition)
+				}}
-					setInputValue(newValue)
+				onDrop={async (e) => {
-					const newCursorPosition = cursorPosition + text.length
+					e.preventDefault()
-					setCursorPosition(newCursorPosition)
+					const files = Array.from(e.dataTransfer.files)
-					setIntendedCursorPosition(newCursorPosition)
+					const text = e.dataTransfer.getData("text")
-					return
+					if (text) {
-				}
+						const newValue =
-				const acceptedTypes = ["png", "jpeg", "webp"]
+							inputValue.slice(0, cursorPosition) + text + inputValue.slice(cursorPosition)
-				const imageFiles = files.filter((file) => {
+						setInputValue(newValue)
-					const [type, subtype] = file.type.split("/")
+						const newCursorPosition = cursorPosition + text.length
-					return type === "image" && acceptedTypes.includes(subtype)
+						setCursorPosition(newCursorPosition)
-				})
+						setIntendedCursorPosition(newCursorPosition)
-				if (!shouldDisableImages && imageFiles.length > 0) {
+						return
-					const imagePromises = imageFiles.map((file) => {
-						return new Promise<string | null>((resolve) => {
-							const reader = new FileReader()
-							reader.onloadend = () => {
-								if (reader.error) {
-									console.error("Error reading file:", reader.error)
-									resolve(null)
-								} else {
-									const result = reader.result
-									resolve(typeof result === "string" ? result : null)
-								}
-							}
-							reader.readAsDataURL(file)
-						})
-					})
-					const imageDataArray = await Promise.all(imagePromises)
-					const dataUrls = imageDataArray.filter((dataUrl): dataUrl is string => dataUrl !== null)
-					if (dataUrls.length > 0) {
-						setSelectedImages((prevImages) => [...prevImages, ...dataUrls].slice(0, MAX_IMAGES_PER_MESSAGE))
-						if (typeof vscode !== 'undefined') {
-							vscode.postMessage({
-								type: 'draggedImages',
-								dataUrls: dataUrls
-							})
-						}
-					} else {
-						console.warn("No valid images were processed")
 					}
-				}
+					const acceptedTypes = ["png", "jpeg", "webp"]
-			}}
+					const imageFiles = files.filter((file) => {
-			onDragOver={(e) => {
+						const [type, subtype] = file.type.split("/")
-				e.preventDefault()
+						return type === "image" && acceptedTypes.includes(subtype)
-			}}>
+					})
+					if (!shouldDisableImages && imageFiles.length > 0) {
+						const imagePromises = imageFiles.map((file) => {
+							return new Promise<string | null>((resolve) => {
+								const reader = new FileReader()
+								reader.onloadend = () => {
+									if (reader.error) {
+										console.error("Error reading file:", reader.error)
+										resolve(null)
+									} else {
+										const result = reader.result
+										resolve(typeof result === "string" ? result : null)
+									}
+								}
+								reader.readAsDataURL(file)
+							})
+						})
+						const imageDataArray = await Promise.all(imagePromises)
+						const dataUrls = imageDataArray.filter((dataUrl): dataUrl is string => dataUrl !== null)
+						if (dataUrls.length > 0) {
+							setSelectedImages((prevImages) => [...prevImages, ...dataUrls].slice(0, MAX_IMAGES_PER_MESSAGE))
+							if (typeof vscode !== 'undefined') {
+								vscode.postMessage({
+									type: 'draggedImages',
+									dataUrls: dataUrls
+								})
+							}
+						} else {
+							console.warn("No valid images were processed")
+						}
+					}
+				}}
+				onDragOver={(e) => {
+					e.preventDefault()
+				}}
+			>
 				{showContextMenu && (
 					<div ref={contextMenuContainerRef}>
 						<ContextMenu
@@ -547,100 +597,87 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 						/>
 					</div>
 				)}
-				{!isTextAreaFocused && (
+				
+				<div style={{
+					position: "relative",
+					flex: "1 1 auto",
+					display: "flex",
+					flexDirection: "column-reverse",
+					minHeight: 0,
+					overflow: "hidden"
+				}}>
 					<div
+						ref={highlightLayerRef}
 						style={{
 							position: "absolute",
-							inset: "10px 15px",
+							inset: 0,
-							border: "1px solid var(--vscode-input-border)",
-							borderRadius: 2,
 							pointerEvents: "none",
-							zIndex: 5,
+							whiteSpace: "pre-wrap",
+							wordWrap: "break-word",
+							color: "transparent",
+							overflow: "hidden",
+							fontFamily: "var(--vscode-font-family)",
+							fontSize: "var(--vscode-editor-font-size)",
+							lineHeight: "var(--vscode-editor-line-height)",
+							padding: "8px",
+							marginBottom: thumbnailsHeight > 0 ? `${thumbnailsHeight + 16}px` : 0,
+							zIndex: 1
 						}}
 					/>
-				)}
+					<DynamicTextArea
-				<div
+						ref={(el) => {
-					ref={highlightLayerRef}
+							if (typeof ref === "function") {
-					style={{
+								ref(el)
-						position: "absolute",
+							} else if (ref) {
-						top: 10,
+								ref.current = el
-						left: 15,
+							}
-						right: 15,
+							textAreaRef.current = el
-						bottom: 10,
+						}}
-						pointerEvents: "none",
+						value={inputValue}
-						whiteSpace: "pre-wrap",
+						disabled={textAreaDisabled}
-						wordWrap: "break-word",
+						onChange={(e) => {
-						color: "transparent",
+							handleInputChange(e)
-						overflow: "hidden",
+							updateHighlights()
-						backgroundColor: "var(--vscode-input-background)",
+						}}
-						fontFamily: "var(--vscode-font-family)",
+						onKeyDown={handleKeyDown}
-						fontSize: "var(--vscode-editor-font-size)",
+						onKeyUp={handleKeyUp}
-						lineHeight: "var(--vscode-editor-line-height)",
+						onBlur={handleBlur}
-						borderRadius: 2,
+						onPaste={handlePaste}
-						borderLeft: 0,
+						onSelect={updateCursorPosition}
-						borderRight: 0,
+						onMouseUp={updateCursorPosition}
-						borderTop: 0,
+						onHeightChange={(height) => {
-						borderColor: "transparent",
+							if (textAreaBaseHeight === undefined || height < textAreaBaseHeight) {
-						borderBottom: `${thumbnailsHeight + 6}px solid transparent`,
+								setTextAreaBaseHeight(height)
-						padding: "9px 9px 25px 9px",
+							}
-					}}
+							onHeightChange?.(height)
-				/>
+						}}
-				<DynamicTextArea
+						placeholder={placeholderText}
-					ref={(el) => {
+						minRows={4}
-						if (typeof ref === "function") {
+						maxRows={20}
-							ref(el)
+						autoFocus={true}
-						} else if (ref) {
+						style={{
-							ref.current = el
+							width: "100%",
-						}
+							boxSizing: "border-box",
-						textAreaRef.current = el
+							backgroundColor: "transparent",
-					}}
+							color: "var(--vscode-input-foreground)",
-					value={inputValue}
+							borderRadius: 2,
-					disabled={textAreaDisabled}
+							fontFamily: "var(--vscode-font-family)",
-					onChange={(e) => {
+							fontSize: "var(--vscode-editor-font-size)",
-						handleInputChange(e)
+							lineHeight: "var(--vscode-editor-line-height)",
-						updateHighlights()
+							resize: "none",
-					}}
+							overflowX: "hidden",
-					onKeyDown={handleKeyDown}
+							overflowY: "auto",
-					onKeyUp={handleKeyUp}
+							border: "none",
-					onFocus={() => setIsTextAreaFocused(true)}
+							padding: "8px",
-					onBlur={handleBlur}
+							marginBottom: thumbnailsHeight > 0 ? `${thumbnailsHeight + 16}px` : 0,
-					onPaste={handlePaste}
+							cursor: textAreaDisabled ? "not-allowed" : undefined,
-					onSelect={updateCursorPosition}
+							flex: "0 1 auto",
-					onMouseUp={updateCursorPosition}
+							zIndex: 2
-					onHeightChange={(height) => {
+						}}
-						if (textAreaBaseHeight === undefined || height < textAreaBaseHeight) {
+						onScroll={() => updateHighlights()}
-							setTextAreaBaseHeight(height)
+					/>
-						}
+				</div>
-						onHeightChange?.(height)
+
-					}}
-					placeholder={placeholderText}
-					minRows={2}
-					maxRows={20}
-					autoFocus={true}
-					style={{
-						width: "100%",
-						boxSizing: "border-box",
-						backgroundColor: "transparent",
-						color: "var(--vscode-input-foreground)",
-						borderRadius: 2,
-						fontFamily: "var(--vscode-font-family)",
-						fontSize: "var(--vscode-editor-font-size)",
-						lineHeight: "var(--vscode-editor-line-height)",
-						resize: "none",
-						overflowX: "hidden",
-						overflowY: "scroll",
-						borderLeft: 0,
-						borderRight: 0,
-						borderTop: 0,
-						borderBottom: `${thumbnailsHeight + 6}px solid transparent`,
-						borderColor: "transparent",
-						padding: "9px 9px 25px 9px",
-						cursor: textAreaDisabled ? "not-allowed" : undefined,
-						flex: 1,
-						zIndex: 1,
-					}}
-					onScroll={() => updateHighlights()}
-				/>
 				{selectedImages.length > 0 && (
 					<Thumbnails
 						images={selectedImages}
@@ -648,32 +685,136 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 						onHeightChange={handleThumbnailsHeightChange}
 						style={{
 							position: "absolute",
-							paddingTop: 4,
+							bottom: "36px",
-							bottom: 14,
+							left: "16px",
-							left: 22,
-							right: 67,
 							zIndex: 2,
+							marginBottom: "8px"
 						}}
 					/>
 				)}
-				<div className="button-row" style={{ position: "absolute", right: 20, display: "flex", alignItems: "center", height: 31, bottom: 8, zIndex: 2, justifyContent: "flex-end" }}>
+
-				  <span style={{ display: "flex", alignItems: "center", gap: 12 }}>
+				<div style={{
-					{apiConfiguration?.apiProvider === "openrouter" && (
+					display: "flex",
-					  <div style={{ display: "flex", alignItems: "center" }}>
+					justifyContent: "space-between",
-						{isEnhancingPrompt && <span style={{ marginRight: 10, color: "var(--vscode-input-foreground)", opacity: 0.5 }}>Enhancing prompt...</span>}
+					alignItems: "center",
+					marginTop: "auto",
+					paddingTop: "8px"
+				}}>
+					<div style={{
+						display: "flex",
+						alignItems: "center"
+					}}>
+						<div style={{ position: "relative", display: "inline-block" }}>
+							<select
+								value={mode}
+								disabled={textAreaDisabled}
+								onChange={(e) => {
+									const newMode = e.target.value as Mode
+									setMode(newMode)
+									vscode.postMessage({
+										type: "mode",
+										text: newMode
+									})
+								}}
+								style={{
+									...selectStyle,
+									minWidth: "70px",
+									flex: "0 0 auto"
+								}}
+							>
+								<option value="code" style={{
+									backgroundColor: "var(--vscode-dropdown-background)",
+									color: "var(--vscode-dropdown-foreground)"
+								}}>Code</option>
+								<option value="architect" style={{
+									backgroundColor: "var(--vscode-dropdown-background)",
+									color: "var(--vscode-dropdown-foreground)"
+								}}>Architect</option>
+								<option value="ask" style={{
+									backgroundColor: "var(--vscode-dropdown-background)",
+									color: "var(--vscode-dropdown-foreground)"
+								}}>Ask</option>
+							</select>
+							<div style={caretContainerStyle}>
+								<CaretIcon />
+							</div>
+						</div>
+
+						<div style={{
+							position: "relative",
+							display: "inline-block",
+							flex: "1 1 auto",
+							minWidth: 0,
+							maxWidth: "150px",
+							overflow: "hidden"
+						}}>
+							<select
+								value={currentApiConfigName}
+								disabled={textAreaDisabled}
+								onChange={(e) => vscode.postMessage({
+									type: "loadApiConfiguration",
+									text: e.target.value
+								})}
+								style={{
+									...selectStyle,
+									width: "100%",
+									textOverflow: "ellipsis"
+								}}
+							>
+								{(listApiConfigMeta || [])?.map((config) => (
+									<option
+										key={config.name}
+										value={config.name}
+										style={{
+											backgroundColor: "var(--vscode-dropdown-background)",
+											color: "var(--vscode-dropdown-foreground)"
+										}}
+									>
+										{config.name}
+									</option>
+								))}
+							</select>
+							<div style={caretContainerStyle}>
+								<CaretIcon />
+							</div>
+						</div>
+					</div>
+
+					<div style={{
+						display: "flex",
+						alignItems: "center",
+						gap: "12px"
+					}}>
+						<div style={{ display: "flex", alignItems: "center" }}>
+							{isEnhancingPrompt ? (
+								<span className="codicon codicon-loading codicon-modifier-spin" style={{
+									color: "var(--vscode-input-foreground)",
+									opacity: 0.5,
+									fontSize: 16.5,
+									marginRight: 10
+								}} />
+							) : (
+								<span
+									role="button"
+									aria-label="enhance prompt"
+									data-testid="enhance-prompt-button"
+									className={`input-icon-button ${textAreaDisabled ? "disabled" : ""} codicon codicon-sparkle`}
+									onClick={() => !textAreaDisabled && handleEnhancePrompt()}
+									style={{ fontSize: 16.5 }}
+								/>
+							)}
+						</div>
 						<span 
-						  role="button"
+							className={`input-icon-button ${shouldDisableImages ? "disabled" : ""} codicon codicon-device-camera`}
-						  aria-label="enhance prompt"
+							onClick={() => !shouldDisableImages && onSelectImages()}
-						  data-testid="enhance-prompt-button"
+							style={{ fontSize: 16.5 }}
-						  className={`input-icon-button ${textAreaDisabled ? "disabled" : ""} codicon codicon-sparkle`}
-						  onClick={() => !textAreaDisabled && handleEnhancePrompt()}
-						  style={{ fontSize: 16.5 }}
 						/>
-					  </div>
+						<span 
-					)}
+							className={`input-icon-button ${textAreaDisabled ? "disabled" : ""} codicon codicon-send`}
-					<span className={`input-icon-button ${shouldDisableImages ? "disabled" : ""} codicon codicon-device-camera`} onClick={() => !shouldDisableImages && onSelectImages()} style={{ fontSize: 16.5 }} />
+							onClick={() => !textAreaDisabled && onSend()}
-					<span className={`input-icon-button ${textAreaDisabled ? "disabled" : ""} codicon codicon-send`} onClick={() => !textAreaDisabled && onSend()} style={{ fontSize: 15 }} />
+							style={{ fontSize: 15 }}
-				  </span>
+						/>
+					</div>
 				</div>
 			</div>
 		)

webview-ui/src/components/chat/ChatView.tsx

@@ -1,4 +1,4 @@
-import { VSCodeButton, VSCodeLink } from "@vscode/webview-ui-toolkit/react"
+import { VSCodeButton } from "@vscode/webview-ui-toolkit/react"
 import debounce from "debounce"
 import { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import { useDeepCompareEffect, useEvent, useMount } from "react-use"
@@ -38,7 +38,7 @@ interface ChatViewProps {
 export const MAX_IMAGES_PER_MESSAGE = 20 // Anthropic limits to 20 images
 
 const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryView }: ChatViewProps) => {
-	const { version, clineMessages: messages, taskHistory, apiConfiguration, mcpServers, alwaysAllowBrowser, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute, alwaysAllowMcp, allowedCommands, writeDelayMs } = useExtensionState()
+	const { version, clineMessages: messages, taskHistory, apiConfiguration, mcpServers, alwaysAllowBrowser, alwaysAllowReadOnly, alwaysAllowWrite, alwaysAllowExecute, alwaysAllowMcp, allowedCommands, writeDelayMs, mode, setMode } = useExtensionState()
 
 	//const task = messages.length > 0 ? (messages[0].say === "task" ? messages[0] : undefined) : undefined) : undefined
 	const task = useMemo(() => messages.at(0), [messages]) // leaving this less safe version here since if the first message is not a task, then the extension is in a bad state and needs to be debugged (see Cline.abort)
@@ -192,6 +192,9 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				case "say":
 					// don't want to reset since there could be a "say" after an "ask" while ask is waiting for response
 					switch (lastMessage.say) {
+						case "api_req_retry_delayed":
+							setTextAreaDisabled(true)
+							break
 						case "api_req_started":
 							if (secondLastMessage?.ask === "command_output") {
 								// if the last ask is a command_output, and we receive an api_req_started, then that means the command has finished and we don't need input from the user anymore (in every other case, the user has to interact with input field or buttons to continue, which does the following automatically)
@@ -294,11 +297,13 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 						// there is no other case that a textfield should be enabled
 					}
 				}
+				// Only reset message-specific state, preserving mode
 				setInputValue("")
 				setTextAreaDisabled(true)
 				setSelectedImages([])
 				setClineAsk(undefined)
 				setEnableButtons(false)
+				// Do not reset mode here as it should persist
 				// setPrimaryButtonText(undefined)
 				// setSecondaryButtonText(undefined)
 				disableAutoScrollRef.current = false
@@ -335,8 +340,6 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 		setTextAreaDisabled(true)
 		setClineAsk(undefined)
 		setEnableButtons(false)
-		// setPrimaryButtonText(undefined)
-		// setSecondaryButtonText(undefined)
 		disableAutoScrollRef.current = false
 	}, [clineAsk, startNewTask])
 
@@ -364,8 +367,6 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 		setTextAreaDisabled(true)
 		setClineAsk(undefined)
 		setEnableButtons(false)
-		// setPrimaryButtonText(undefined)
-		// setSecondaryButtonText(undefined)
 		disableAutoScrollRef.current = false
 	}, [clineAsk, startNewTask, isStreaming])
 
@@ -466,6 +467,9 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 				case "api_req_finished": // combineApiRequests removes this from modifiedMessages anyways
 				case "api_req_retried": // this message is used to update the latest api_req_started that the request was retried
 					return false
+				case "api_req_retry_delayed":
+					// Only show the retry message if it's the last message
+					return message === modifiedMessages.at(-1)
 				case "text":
 					// Sometimes cline returns an empty text message, we don't want to render these. (We also use a say text for user messages, so in case they just sent images we still render that)
 					if ((message.text ?? "") === "" && (message.images?.length ?? 0) === 0) {
@@ -773,9 +777,12 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 	useEvent("wheel", handleWheel, window, { passive: true }) // passive improves scrolling performance
 
 	const placeholderText = useMemo(() => {
-		const text = task ? "Type a message...\n(@ to add context, hold shift to drag in images)" : "Type your task here...\n(@ to add context, hold shift to drag in images)"
+		const baseText = task ? "Type a message..." : "Type your task here..."
-		return text
+		const contextText = "(@ to add context"
-	}, [task])
+		const imageText = shouldDisableImages ? "" : ", hold shift to drag in images"
+		const helpText = imageText ? `\n${contextText}${imageText})` : `\n${contextText})`
+		return baseText + helpText
+	}, [task, shouldDisableImages])
 
 	const itemContent = useCallback(
 		(index: number, messageOrGroup: ClineMessage | ClineMessage[]) => {
@@ -868,12 +875,7 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 					<div style={{ padding: "0 20px", flexShrink: 0 }}>
 						<h2>What can I do for you?</h2>
 						<p>
-							Thanks to{" "}
+							Thanks to the latest breakthroughs in agentic coding capabilities,
-							<VSCodeLink
-								href="https://www-cdn.anthropic.com/fed9cc193a14b84131812372d8d5857f8f304c52/Model_Card_Claude_3_Addendum.pdf"
-								style={{ display: "inline" }}>
-								Claude 3.5 Sonnet's agentic coding capabilities,
-							</VSCodeLink>{" "}
 							I can handle complex software development tasks step-by-step. With tools that let me create
 							& edit files, explore complex projects, use the browser, and execute terminal commands
 							(after you grant permission), I can assist you in ways that go beyond code completion or
@@ -982,6 +984,8 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 						scrollToBottomAuto()
 					}
 				}}
+				mode={mode}
+				setMode={setMode}
 			/>
 		</div>
 	)

webview-ui/src/components/chat/__tests__/ChatTextArea.test.tsx

@@ -3,6 +3,7 @@ import '@testing-library/jest-dom';
 import ChatTextArea from '../ChatTextArea';
 import { useExtensionState } from '../../../context/ExtensionStateContext';
 import { vscode } from '../../../utils/vscode';
+import { codeMode } from '../../../../../src/shared/modes';
 
 // Mock modules
 jest.mock('../../../utils/vscode', () => ({
@@ -32,6 +33,8 @@ describe('ChatTextArea', () => {
     selectedImages: [],
     setSelectedImages: jest.fn(),
     onHeightChange: jest.fn(),
+    mode: codeMode,
+    setMode: jest.fn(),
   };
 
   beforeEach(() => {
@@ -46,37 +49,9 @@ describe('ChatTextArea', () => {
   });
 
   describe('enhance prompt button', () => {
-    it('should show enhance prompt button only when apiProvider is openrouter', () => {
-      // Test with non-openrouter provider
-      (useExtensionState as jest.Mock).mockReturnValue({
-        filePaths: [],
-        apiConfiguration: {
-          apiProvider: 'anthropic',
-        },
-      });
-
-      const { rerender } = render(<ChatTextArea {...defaultProps} />);
-      expect(screen.queryByTestId('enhance-prompt-button')).not.toBeInTheDocument();
-
-      // Test with openrouter provider
-      (useExtensionState as jest.Mock).mockReturnValue({
-        filePaths: [],
-        apiConfiguration: {
-          apiProvider: 'openrouter',
-        },
-      });
-
-      rerender(<ChatTextArea {...defaultProps} />);
-      const enhanceButton = screen.getByRole('button', { name: /enhance prompt/i });
-      expect(enhanceButton).toBeInTheDocument();
-    });
-
     it('should be disabled when textAreaDisabled is true', () => {
       (useExtensionState as jest.Mock).mockReturnValue({
         filePaths: [],
-        apiConfiguration: {
-          apiProvider: 'openrouter',
-        },
       });
 
       render(<ChatTextArea {...defaultProps} textAreaDisabled={true} />);
@@ -137,7 +112,8 @@ describe('ChatTextArea', () => {
       const enhanceButton = screen.getByRole('button', { name: /enhance prompt/i });
       fireEvent.click(enhanceButton);
 
-      expect(screen.getByText('Enhancing prompt...')).toBeInTheDocument();
+      const loadingSpinner = screen.getByText('', { selector: '.codicon-loading' });
+      expect(loadingSpinner).toBeInTheDocument();
     });
   });
 

webview-ui/src/components/chat/__tests__/ChatView.test.tsx

@@ -263,6 +263,7 @@ describe('ChatView - Auto Approval Tests', () => {
       // First hydrate state with initial task
       mockPostMessage({
         alwaysAllowWrite: true,
+        writeDelayMs: 0,
         clineMessages: [
           {
             type: 'say',
@@ -276,6 +277,7 @@ describe('ChatView - Auto Approval Tests', () => {
       // Then send the write tool ask message
       mockPostMessage({
         alwaysAllowWrite: true,
+        writeDelayMs: 0,
         clineMessages: [
           {
             type: 'say',