changeset

* gemini caching

* changeset

.changeset/bright-zebras-sip.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add markdown copy to chat

.changeset/custom-timeout-setting.md

@@ -1,5 +0,0 @@
----
-"cline": minor
----
-
-Add support for custom API request timeout. Previously, timeouts were hardcoded to 30 seconds for providers like Ollama or 15 seconds for OpenRouter and Cline. Now users can set a custom timeout value in milliseconds through the settings interface.

.changeset/kind-pears-invent.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add dependsOn to more blocks in the tasks.json

.changeset/long-cheetahs-love.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Adding args to allow Cursor to open workspaces (for checkpoint testing/development)

.changeset/loud-spies-deny.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-add truncation notice when truncating manually

.changeset/nervous-dolphins-greet.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Add a timeout setting for the terminal connection, allowing users to adjust this if they are having timeout issues

.changeset/quiet-cups-tie.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+updated gemini caching for OR and cline provider

.changeset/rare-ladybugs-talk.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-add newrule slash command

.changeset/serious-baboons-train.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-protobus migration for openImage

.changeset/shy-buckets-itch.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-add cache ui for open router and cline provider

.changeset/six-hairs-rush.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-showing expanded task by default

.changeset/sweet-toes-bake.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Refactor to not pass a message for showing the MCP View from the servers modal

.changeset/tall-ghosts-help.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Migrate the addRemoteServer to protobus

.changeset/thick-rice-rush.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Lowering Gemini cache TTL time

.changeset/thirty-feet-rule.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Adding UI to show openrouter balance next to provider

.changeset/twenty-comics-enjoy.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix cost calculation

.changeset/two-jobs-notice.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+add ui for windsurf and cursor rules

.changeset/warm-gorillas-beam.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Batch selection and deletion of tasks in history

.github/workflows/codespell.yml

@@ -13,6 +13,7 @@ permissions:
 
 jobs:
     codespell:
+        if: false
         name: Check for spelling errors
         runs-on: ubuntu-latest
 

.github/workflows/publish.yml

@@ -34,7 +34,7 @@ jobs:
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
-                  node-version: 20.15.1
+                  node-version: "lts/*"
 
             # Cache root dependencies - only reuse if package-lock.json exactly matches
             - name: Cache root dependencies
@@ -54,14 +54,14 @@ jobs:
 
             - name: Install root dependencies
               if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm ci
+              run: npm ci --include=optional
 
             - name: Install webview-ui dependencies
               if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm ci
+              run: cd webview-ui && npm ci --include=optional
 
             - name: Install Publishing Tools
-              run: npm install -g vsce ovsx
+              run: npm install -g @vscode/vsce ovsx
 
             - name: Get Version
               id: get_version

.github/workflows/pull-request.yml

@@ -1,177 +0,0 @@
-name: Create Linear Issue on Pull Request
-
-on:
-    workflow_dispatch:
-    pull_request:
-        branches: [main]
-        types: [opened]
-
-permissions:
-    pull-requests: write
-
-jobs:
-    create-linear-issue-on-pull-request:
-        runs-on: ubuntu-latest
-        steps:
-            - name: Check for existing Linear link
-              id: check-linear
-              uses: actions/github-script@v6
-              with:
-                  result-encoding: string
-                  script: |
-                      const pr = context.payload.pull_request;
-                      // 1) PR body
-                      if (/https?:\/\/linear\.app/.test(pr.body||"")) {
-                        return "true";
-                      }
-                      // 2) Any linked GitHub issues?
-                      const res = await github.graphql(
-                        `query($owner:String!,$repo:String!,$prNumber:Int!){
-                           repository(owner:$owner,name:$repo){
-                             pullRequest(number:$prNumber){
-                               closingIssuesReferences(first:10){
-                                 nodes{number}
-                               }
-                             }
-                           }
-                         }`,
-                        {
-                          owner: context.repo.owner,
-                          repo: context.repo.repo,
-                          prNumber: pr.number
-                        }
-                      );
-                      for (const {number} of res.repository.pullRequest.closingIssuesReferences.nodes) {
-                        const comments = await github.rest.issues.listComments({
-                          owner: context.repo.owner,
-                          repo: context.repo.repo,
-                          issue_number: number
-                        });
-                        if (comments.data.some(c=>/https?:\/\/linear\.app/.test(c.body))) {
-                          return "true";
-                        }
-                      }
-                      return "false";
-
-            - name: Find or create Linear issue via GraphQL
-              if: steps.check-linear.outputs.result == 'false'
-              id: linear
-              uses: actions/github-script@v6
-              env:
-                  LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
-              with:
-                  result-encoding: string
-                  script: |
-                      const API = 'https://api.linear.app/graphql';
-                      const apiKey = process.env.LINEAR_API_KEY;
-
-                      // Check if API key exists
-                      if (!apiKey) {
-                        core.setFailed('LINEAR_API_KEY is not set. Please add it to your repository secrets.');
-                        core.setOutput('error', 'true');
-                        core.setOutput('error-message', 'LINEAR_API_KEY is not set. Please add it to your repository secrets.');
-                        return;
-                      }
-
-                      // Helper to call Linear with error handling
-                      async function gql(q, v) {
-                        try {
-                          const r = await fetch(API, {
-                            method:'POST',
-                            headers:{
-                              'Content-Type':'application/json',
-                              'Authorization': apiKey
-                            },
-                            body: JSON.stringify({ query: q, variables: v })
-                          });
-                          
-                          if (!r.ok) {
-                            throw new Error(`Linear API responded with status ${r.status}: ${await r.text()}`);
-                          }
-                          
-                          const json = await r.json();
-                          
-                          // Check for GraphQL errors
-                          if (json.errors && json.errors.length > 0) {
-                            const errorMessages = json.errors.map(e => e.message).join(', ');
-                            throw new Error(`Linear GraphQL errors: ${errorMessages}`);
-                          }
-                          
-                          return json.data;
-                        } catch (error) {
-                          core.error(`Error calling Linear API: ${error.message}`);
-                          throw error;
-                        }
-                      }
-
-                      try {
-                        // 1) Set team ID
-                        const teamId = "19b9c1b2-5f58-498c-b1bf-23ee8f52a677"
-
-                        // 2) Look for existing issue by PR URL
-                        const pr = context.payload.pull_request;
-                        const searchData = await gql(
-                          `query($team:ID!,$q:String!){
-                              issues(filter: { team: { id: { eq: $team } } attachments: { some: { url: { eq: $q } } } }){nodes{id,url}}
-                            }`,
-                          { team: teamId, q: pr.html_url }
-                        );
-                        let issue = searchData.issues.nodes[0];
-
-                        // 3) Create if missing
-                        if (!issue) {
-                          const createData = await gql(
-                            `mutation($input:IssueCreateInput!){
-                                issueCreate(input:$input){issue{id,url}}
-                              }`,
-                            {
-                              input: {
-                                teamId,
-                                title: `[GITHUB] ${pr.title}`,
-                                description: `${pr.body||''}\n\n${pr.html_url}`,
-                                stateId: "4d9bcba2-6712-47e3-b577-6ec1ee023dc2",
-                                labelIds: ["504e7d60-5037-483f-a9b8-7e298bdf116f"]
-                              }
-                            }
-                          );
-                          issue = createData.issueCreate.issue;
-                        }
-
-                        // Set output for next steps
-                        core.setOutput('linear-issue-url', issue.url);
-                        core.setOutput('error', 'false');
-                      } catch (error) {
-                        core.setOutput('error', 'true');
-                        core.setOutput('error-message', error.message);
-                        core.setFailed(`Failed to create or find Linear issue: ${error.message}`);
-                      }
-
-            - name: Comment PR with Linear link
-              if: steps.check-linear.outputs.result == 'false'
-              uses: actions/github-script@v6
-              with:
-                  script: |
-                      const pr = context.payload.pull_request;
-                      const url = `${{ steps.linear.outputs.linear-issue-url }}`;
-                      const body = `🔗 Linear issue created: ${url}`;
-                      // Fetch existing comments
-                      const { data: comments } = await github.rest.issues.listComments({
-                        ...context.repo,
-                        issue_number: pr.number
-                      });
-                      const botComment = comments.find(c =>
-                        c.user.type === "Bot" && c.body.startsWith("🔗 Linear issue created:")
-                      );
-                      if (botComment) {
-                        await github.rest.issues.updateComment({
-                          ...context.repo,
-                          comment_id: botComment.id,
-                          body
-                        });
-                      } else {
-                        await github.rest.issues.createComment({
-                          ...context.repo,
-                          issue_number: pr.number,
-                          body
-                        });
-                      }

.github/workflows/test.yml

@@ -70,8 +70,8 @@ jobs:
               run: npm run format
 
             # Build the extension before running tests
-            - name: Build Extension
-              run: npm run compile
+            - name: Build Tests and Extension
+              run: npm run pretest
 
             - name: Unit Tests
               run: npm run test:unit
@@ -81,7 +81,7 @@ jobs:
               id: extension_coverage
               continue-on-error: true
               run: |
-                  xvfb-run -a npm run test:coverage > extension_coverage.txt 2>&1 || true
+                  xvfb-run -a npm run test:coverage > extension_coverage.txt 2>&1
                   PYTHONPATH=.github/scripts python -m coverage_check extract-coverage extension_coverage.txt --type=extension --github-output --verbose
 
             # Run webview tests with coverage
@@ -106,6 +106,18 @@ jobs:
                       webview-ui/webview_coverage.txt
                   retention-period: workflow # Artifacts are automatically deleted when the workflow completes
 
+            # Set the check as failed if any of the tests failed
+            - name: Check for test failures
+              run: |
+                  # Check if any of the test steps failed
+                  # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#steps-context
+                  if [ "${{ steps.extension_coverage.outcome }}" != "success" ] || [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
+                      echo "Tests failed."
+                      cat extension_coverage.txt
+                      cat webview-ui/webview_coverage.txt
+                      exit 1
+                  fi
+
     coverage:
         needs: test
         runs-on: ubuntu-latest

.vscode-test.mjs

@@ -6,6 +6,10 @@ export default defineConfig({
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing
+		/** Set up alias path resolution during tests
+		 * @See {@link file://./test-setup.js}
+		 */
+		require: ["./test-setup.js"],
 	},
 	workspaceFolder: "test-workspace",
 	version: "stable",

.vscode/launch.json

@@ -12,7 +12,6 @@
 			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
 			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "${defaultBuildTask}",
-			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"

.vscodeignore

@@ -37,8 +37,12 @@ docs/**
 !node_modules/@vscode/codicons/dist/codicon.css
 !node_modules/@vscode/codicons/dist/codicon.ttf
 
+# Include KaTeX CSS and fonts for LaTeX rendering
+!webview-ui/node_modules/katex/dist/katex.min.css
+!webview-ui/node_modules/katex/dist/fonts/**
+
 # Include default themes JSON files used in getTheme
 !src/integrations/theme/default-themes/**
 
 # Include icons
-!assets/icons/**
+!assets/icons/**

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [3.14.0]
+
+-   Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile (Thanks @clicube!)
+-   Add more robust caching & cache tracking for gemini & vertex providers
+-   Add support for LaTeX rendering
+-   Add support for custom API request timeout. Timeouts were 15-30s, but can now be configured via settings for OpenRouter/Cline & Ollama (Thanks @WingsDrafterwork!)
+-   Add truncation notice when truncating manually
+-   Add a timeout setting for the terminal connection, allowing users to set a time to wait for terminal startup
+-   Add copy button to code blocks
+-   Add copy button to markdown blocks (Thanks @weshoke!)
+-   Add checkpoints to more messages
+-   Add slash command to create a new rules file (/newrule)
+-   Add cache ui for open router and cline provider
+-   Add Amazon Nova Premier model to Bedrock (Thanks @watany!)
+-   Add support for cursorrules and windsurfrules
+-   Add support for batch history deletion (Thanks @danix800!)
+-   Improve Drag & Drop experience
+-   Create clinerules folder when creating new rule if it's needed
+-   Enable pricing calculation for gemini and vertex providers
+-   Refactor message handling to not show the MCP View of the server modal
+-   Migrate the addRemoteServer to protobus (Thanks @DaveFres!)
+-   Update task header to be expanded by default
+-   Update Gemini cache TTL time to 15 minutes
+-   Fix race condition in terminal command usage
+-   Fix to correctly handle `import.meta.url`, avoiding leading slash in pathname for Windows (Thanks @DaveFres!)
+-   Fix @withRetry() decoration syntax error when running extension locally (Thanks @DaveFres!)
+-   Fix for git commit mentions in repos with no git commits
+-   Fix cost calculation (Thanks @BarreiroT!)
+
 ## [3.13.3]
 
 -   Add download counts to MCP marketplace items

docs/docs.json

@@ -0,0 +1,83 @@
+{
+	"$schema": "https://mintlify.com/docs.json",
+	"theme": "linden",
+	"name": "Cline",
+	"description": "AI-powered coding assistant for VSCode",
+	"colors": {
+		"primary": "#9D4EDD",
+		"light": "#F0E6FF",
+		"dark": "#000000"
+	},
+	"logo": {
+		"light": "/assets/robot_panel_light.png",
+		"dark": "/assets/robot_panel_dark.png"
+	},
+	"favicon": {
+		"light": "/assets/robot_panel_light.png",
+		"dark": "/assets/robot_panel_dark.png"
+	},
+	"background": {
+		"color": {
+			"light": "#F0E6FF",
+			"dark": "#000000"
+		},
+		"decoration": "gradient"
+	},
+	"styling": {
+		"eyebrows": "breadcrumbs",
+		"codeblocks": "system"
+	},
+	"appearance": {
+		"default": "system",
+		"strict": false
+	},
+	"fonts": {
+		"family": "Roboto",
+		"weight": 400
+	},
+	"navbar": {
+		"links": [
+			{
+				"label": "GitHub",
+				"href": "https://github.com/cline/cline"
+			},
+			{
+				"label": "Discord",
+				"href": "https://discord.gg/cline"
+			}
+		],
+		"primary": {
+			"type": "button",
+			"label": "Install Cline",
+			"href": "https://cline.bot/install?utm_source=website&utm_medium=header"
+		}
+	},
+	"navigation": {
+		"groups": [
+			{
+				"group": "Exploring Cline's Tools",
+				"pages": [
+					"exploring-clines-tools/cline-tools-guide",
+					"exploring-clines-tools/plan-and-act-modes-a-guide-to-effective-ai-development",
+					"exploring-clines-tools/checkpoints",
+					"exploring-clines-tools/new-task-tool",
+					"exploring-clines-tools/remote-browser-support",
+					"exploring-clines-tools/slash-commands"
+				]
+			}
+		]
+	},
+	"footer": {
+		"socials": {
+			"x": "https://x.com/cline",
+			"github": "https://github.com/cline/cline",
+			"discord": "https://discord.gg/cline"
+		}
+	},
+	"search": {
+		"prompt": "Search Cline documentation..."
+	},
+	"contextual": {
+		"options": ["copy"]
+	}
+}

docs/exploring-clines-tools/checkpoints.mdx

@@ -0,0 +1,108 @@
+---
+title: "Checkpoints and Messages"
+description: "When working with AI coding assistants, it's easy to lose control as they make rapid changes to your codebase. That's why we built Checkpoints - your safety net for experimenting confidently."
+---
+
+Checkpoints automatically save snapshots of your workspace after each step in a task. This powerful feature lets you:
+
+-   Track and review changes made during a task
+-   Roll back to any previous point if needed
+-   Experiment confidently with auto-approve mode
+-   Maintain full control over your workspace
+
+### ⚙️ How Checkpoints Work
+
+Cline creates a checkpoint after each tool use (file edits, commands, etc.). These checkpoints:
+
+-   Work alongside your Git workflow without interference
+-   Maintain context between restores
+-   Use a shadow Git repository to track changes
+
+For example, if you're working on a feature and Cline makes multiple file changes, each change creates a checkpoint. This means you can review each modification and, if needed, roll back to any point without affecting your main Git repository.
+
+#### Viewing Changes & Restoring to Checkpoint
+
+After each tool use, you can:
+
+1. Click the "Compare" button to see modified files
+2. Click the "Restore" button to open restore options
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Checkpoint comparison and restore options" />
+</Frame>
+
+#### Rolling Back
+
+To restore to a previous point:
+
+1. Click the "Restore" button next to any step
+2. Choose from three options:
+    - **Restore Task and Workspace**: Reset both codebase and task to that point
+    - **Restore Task Only**: Keep codebase changes but revert task context
+    - **Restore Workspace Only**: Reset codebase while preserving task context
+
+Example: If Cline makes changes you don't like while styling a component, you can use "Restore Workspace Only" to revert the code changes while keeping the conversation context, allowing you to try a different approach.
+
+### 💡 Use Cases
+
+Checkpoints let you be more experimental with Cline. While human coding is often methodical and iterative, AI can make substantial changes quickly. Checkpoints help you track these changes and revert if needed.
+
+#### 1. Using Auto-Approve Mode
+
+-   Provides safety net for rapid iterations
+-   Makes it easy to undo unexpected results
+
+#### 2. Testing Different Approaches
+
+-   Try multiple solutions confidently
+-   Compare different implementations
+-   Quickly revert to working states
+-   Ideal for exploring different design patterns or architectural approaches
+
+<Frame caption="In this case, I didn't like the changes Cline made to my robot dog-walking website (still working on the robots) and I wanted to revert both the codebase and the task to before any changes were made so I could start fresh.">
+	<img src="/assets/robot_panel_dark.png" alt="Checkpoint restore demo" />
+</Frame>
+
+### ✨ Best Practices
+
+1. Use checkpoints as safety nets when experimenting
+2. Leverage auto-approve mode more confidently, knowing you can always roll back
+3. Restore selectively based on needs:
+
+    - Use "Restore Task and Workspace" for a fresh start, reversing changes to files and the task conversation.
+    - Use "Restore Task Only" to try different prompts, but leave all files as they exist
+    - Use "Restore Workspace Only" to attempt different implementations, or prune context from the task
+
+🛟 Checkpoints are your safety net when working with Cline, enabling you to experiment freely while maintaining full control over your codebase. Whether you're refactoring a complex component, trying different implementation approaches, or using auto-approve mode for rapid development, checkpoints ensure you can always review changes and roll back if needed.
+
+#### 🗑️ Deleting Checkpoints
+
+You can delete all checkpoints by using the **"Delete All History"** button in the task history menu. Note that this will also delete all tasks. Checkpoints are stored in VS Code's globalStorage.
+
+---
+
+## Editing Messages
+
+Cline allows you to edit chat messages in a task after they've been submitted (with the exception of the message that started the task).
+
+Perhaps you didn't get the results you wanted, thought of a better way to phrase your request, or need to add more information. Editing your message allows you to re-submit a request without starting over or restoring your files or workspace with checkpoints. There are two Restore options:
+
+-   **"Restore Chat"** restores just the task state and re-submits an API request to your provider with your edited message.
+
+-   **"Restore All"** restores both the task state and workspace state before re-submitting an API request. "Workspace state" refers to the condition of your workspace (files, content, etc.) at different points in the conversation.
+
+**Interactive Editing:**
+
+-   Messages can be clicked to enter edit mode
+-   Cline automatically selects all text when entering edit mode
+
+**Keyboard Shortcuts:**
+
+-   Escape: Exit edit mode
+-   Enter: Restore just the task
+-   Cmd/Ctrl + Enter: Restore the task and workspace
+-   Shift + Enter: Insert new line / line break
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Message editing interface" />
+</Frame>

docs/exploring-clines-tools/cline-tools-guide.mdx

@@ -0,0 +1,139 @@
+---
+title: "Cline Tools Reference Guide"
+---
+
+## What Can Cline Do?
+
+Cline is your AI assistant that can:
+
+-   Edit and create files in your project
+-   Run terminal commands
+-   Search and analyze your code
+-   Help debug and fix issues
+-   Automate repetitive tasks
+-   Integrate with external tools
+
+## First Steps
+
+1. **Start a Task**
+
+    - Type your request in the chat
+    - Example: "Create a new React component called Header"
+
+2. **Provide Context**
+
+    - Use @ mentions to add files, folders, or URLs
+    - Example: "@file:src/components/App.tsx"
+
+3. **Review Changes**
+    - Cline will show diffs before making changes
+    - You can edit or reject changes
+
+## Key Features
+
+1. **File Editing**
+
+    - Create new files
+    - Modify existing code
+    - Search and replace across files
+
+2. **Terminal Commands**
+
+    - Run npm commands
+    - Start development servers
+    - Install dependencies
+
+3. **Code Analysis**
+
+    - Find and fix errors
+    - Refactor code
+    - Add documentation
+
+4. **Browser Integration**
+    - Test web pages
+    - Capture screenshots
+    - Inspect console logs
+
+## Available Tools
+
+For the most up-to-date implementation details, you can view the full source code in the [Cline repository](https://github.com/cline/cline/blob/main/src/core/Cline.ts).
+
+Cline has access to the following tools for various tasks:
+
+1. **File Operations**
+
+    - `write_to_file`: Create or overwrite files
+    - `read_file`: Read file contents
+    - `replace_in_file`: Make targeted edits to files
+    - `search_files`: Search files using regex
+    - `list_files`: List directory contents
+
+2. **Terminal Operations**
+
+    - `execute_command`: Run CLI commands
+    - `list_code_definition_names`: List code definitions
+
+3. **MCP Tools**
+
+    - `use_mcp_tool`: Use tools from MCP servers
+    - `access_mcp_resource`: Access MCP server resources
+    - Users can create custom MCP tools that Cline can then access
+    - Example: Create a weather API tool that Cline can use to fetch forecasts
+
+4. **Interaction Tools**
+    - `ask_followup_question`: Ask user for clarification
+    - `attempt_completion`: Present final results
+
+Each tool has specific parameters and usage patterns. Here are some examples:
+
+-   Create a new file (write_to_file):
+
+    ```xml
+    <write_to_file>
+    <path>src/components/Header.tsx</path>
+    <content>
+    // Header component code
+    </content>
+    </write_to_file>
+    ```
+
+-   Search for a pattern (search_files):
+
+    ```xml
+    <search_files>
+    <path>src</path>
+    <regex>function\s+\w+\(</regex>
+    <file_pattern>*.ts</file_pattern>
+    </search_files>
+    ```
+
+-   Run a command (execute_command):
+    ```xml
+    <execute_command>
+    <command>npm install axios</command>
+    <requires_approval>false</requires_approval>
+    </execute_command>
+    ```
+
+## Common Tasks
+
+1. **Create a New Component**
+
+    - "Create a new React component called Footer"
+
+2. **Fix a Bug**
+
+    - "Fix the error in src/utils/format.ts"
+
+3. **Refactor Code**
+
+    - "Refactor the Button component to use TypeScript"
+
+4. **Run Commands**
+    - "Run npm install to add axios"
+
+## Getting Help
+
+-   [Join the Discord community](https://discord.gg/cline)
+-   Check the documentation
+-   Provide feedback to improve Cline

docs/exploring-clines-tools/new-task-tool.mdx

@@ -0,0 +1,381 @@
+---
+title: "New Task Tool"
+---
+
+### The `new_task` Tool & Context Management Strategies
+
+#### Overview
+
+Cline includes a powerful internal tool, `new_task`, designed to help manage workflow continuity and context preservation, especially during complex or long-running tasks. This tool, combined with Cline's awareness of its own context window usage and the flexibility of `.clinerules`, enables sophisticated strategies for breaking down work and ensuring seamless transitions between task sessions.
+
+Understanding the core capabilities and how they interact with custom rules is key to leveraging this feature effectively.
+
+#### Core Capabilities
+
+Two fundamental capabilities enable advanced context management:
+
+1. **The `new_task` Tool:**
+    - **Function:** Allows Cline, upon user approval, to end the current task session and immediately start a new one.
+    - **Context Preloading:** Crucially, Cline can **preload** this new task session with specific context provided within the tool's `<context>` block. This context can be anything Cline or a `.clinerules` file defines – summaries, code snippets, next steps, project state, etc.
+2. **Context Window Awareness:**
+    - **Tracking:** Cline internally tracks the percentage of its available context window currently being used during a task.
+    - **Visibility:** This information is visible in the `environment_details` provided to Cline in its prompt.
+
+#### Using the `/newtask` Slash Command
+
+As a quick alternative to Cline suggesting the `newtask` tool or defining complex rules, you can directly initiate the process using a Slash Command.
+
+-   **How:** Simply type `/newtask` in the chat input field.
+-   **Action:** Cline will propose creating a new task, typically suggesting context based on the current session (similar to its default behavior when using the tool). You will still get the `ask_followup_question` prompt to confirm and potentially modify the context before the new task is created.
+-   **Benefit:** Provides a fast, user-initiated way to leverage the `new_task` functionality for branching explorations or managing long sessions without waiting for Cline to suggest it.
+
+#### Default Behavior (Without `.clinerules`)
+
+By default, without specific `.clinerules` dictating its behavior:
+
+-   **Tool Availability:** The `new_task` tool exists, and Cline _can_ choose to use it.
+-   **Context Awareness:** Cline _is_ aware of its context usage percentage.
+-   **No Automatic Trigger:** Cline **will not** automatically initiate a task handoff _solely_ based on context usage reaching a specific percentage (like 50%). The decision to suggest using `new_task` comes from the AI model's reasoning based on the overall task progress and prompt instructions.
+-   **Basic Context Preloading:** If `new_task` is used without specific rules defining the `<context>` block structure, Cline will attempt to preload relevant information based on its current understanding (e.g., a basic summary of progress and next steps), but this may be less comprehensive than a rule-driven approach.
+
+#### The Power of `.clinerules`: Enabling Custom Workflows
+
+While the core capabilities exist by default, the true power, automation, and customization emerge when you combine `new_task` and context awareness with custom workflows defined in `.clinerules`. This allows you to precisely control _when_ and _how_ Cline manages context and task continuity.
+
+Key benefits of using `.clinerules` with `new_task`:
+
+-   **Automated Context Management:** Define rules to automatically trigger handoffs at specific context percentages (e.g., >50%, >70%) or token counts, ensuring optimal performance and preventing context loss.
+-   **Model-Specific Optimization:** Tailor handoff triggers based on known thresholds for different LLMs (e.g., trigger earlier for models known to degrade past a certain token count).
+-   **Intelligent Breakpoints:** Instruct Cline via rules to find logical stopping points (e.g., after completing a function or test) _after_ a context threshold is passed, ensuring cleaner handoffs.
+-   **Structured Task Decomposition:** Use Plan Mode to define subtasks, then use `.clinerules` to have Cline automatically create a new task via `new_task` upon completing each subtask, preloading the context for the _next_ subtask.
+-   **Custom Context Packaging:** Mandate the exact structure and content of the `<context>` block in `.clinerules` for highly detailed and consistent handoffs (see example below).
+-   **Improved Memory Persistence:** Use `new_task` context blocks as a primary, integrated way to persist information across sessions, potentially replacing or supplementing file-based memory systems.
+-   **Workflow Automation:** Define rules for specific scenarios, like always preloading certain setup instructions or project boilerplate when starting tasks of a particular type.
+
+#### Example Rule-Driven Workflow: Task Handoff Process
+
+A common workflow, **driven by specific `.clinerules` like the example below**, involves these steps:
+
+1. **Trigger Identification (Rule-Based):** Cline monitors for handoff points defined in the rules (e.g., context usage > 50%, task completion).
+2. **User Confirmation:** Cline uses `ask_followup_question` to propose creating a new task, often showing the intended context defined by the rules.
+
+    ```xml
+    <ask_followup_question>
+    <question>I've completed [specific accomplishment] and context usage is high (XX%). Would you like me to create a new task to continue with [remaining work], preloading the following context?</question>
+    <options>["Yes, create new task", "Modify context first", "No, continue this session"]</options>
+    </ask_followup_question>
+    ```
+
+3. **User Control:** You can approve, deny, or ask Cline to modify the context before the new task is created.
+4. **Context Packaging (`new_task` Tool):** If approved, Cline uses `new_task`, packaging the context according to the structure mandated by the `.clinerules`.
+5. **New Task Creation:** The current task ends, and a new session begins immediately, preloaded with the specified context.
+
+#### The Handoff Context Block (Rule-Defined Structure)
+
+The effectiveness of rule-driven handoffs depends heavily on how `.clinerules` define the `<context>` block. A comprehensive structure often includes:
+
+-   **`## Completed Work`**: Detailed list of accomplishments, files modified/created, key decisions.
+-   **`## Current State`**: Project status, running processes, key file states.
+-   **`## Next Steps`**: Clear, prioritized list of remaining tasks, implementation details, known challenges.
+-   **`## Reference Information`**: Links, code snippets, patterns, user preferences.
+-   **Actionable Start:** A clear instruction for the immediate next action.
+
+#### Potential Use Cases & Workflows
+
+The flexibility of `new_task` combined with `.clinerules` opens up many possibilities:
+
+-   **Proactive Context Window Management:** Automatically trigger handoffs at specific percentages (e.g., 50%, 70%) or token counts to maintain optimal performance.
+-   **Intelligent Breakpoints:** Instruct Cline to find logical stopping points (e.g., after completing a function or test) _after_ a context threshold is passed, ensuring cleaner handoffs.
+-   **Structured Task Decomposition:** Use Plan Mode to define subtasks, then use `.clinerules` to have Cline automatically create a new task via `new_task` upon completing each subtask.
+-   **Automated Session Summaries:** Configure the `<context>` block to always include a summary of the previous session's key discussion points.
+-   **Preloading Boilerplate/Setup:** Start new tasks related to specific projects preloaded with standard setup instructions or file templates.
+-   **"Memory Bank" Alternative:** Use `new_task` context blocks as the primary way to persist information across sessions, potentially replacing file-based memory systems.
+
+Experimenting with `.clinerules` is encouraged to discover workflows that best suit your needs!
+
+#### Example `.clinerules`: Task Handoff Strategy Guide
+
+Below is an example `.clinerules` file focused specifically on using `new_task` for context window management. **Remember, this is just one specific strategy; the core `new_task` tool can be used differently with other custom rules.**
+
+````markdown
+# You MUST use the `new_task` tool: Task Handoff Strategy Guide
+
+**⚠️ CRITICAL INSTRUCTIONS - YOU MUST FOLLOW THESE GUIDELINES ⚠️**
+
+This guide provides **MANDATORY** instructions for effectively breaking down complex tasks and implementing a smooth handoff process between tasks. You **MUST** follow these guidelines to ensure continuity, context preservation, and efficient task completion.
+
+## ⚠️ CONTEXT WINDOW MONITORING - MANDATORY ACTION REQUIRED ⚠️
+
+You **MUST** monitor the context window usage displayed in the environment details. When usage exceeds 50% of the available context window, you **MUST** initiate a task handoff using the `new_task` tool.
+
+Example of context window usage over 50% with a 200K context window:
+
+\`\`\`text
+
+# Context Window Usage
+
+105,000 / 200,000 tokens (53%)
+Model: anthropic/claude-3.7-sonnet (200K context window)
+\`\`\`
+
+**IMPORTANT**: When you see context window usage at or above 50%, you MUST:
+
+1. Complete your current logical step
+2. Use the `ask_followup_question` tool to offer creating a new task
+3. If approved, use the `new_task` tool with comprehensive handoff instructions
+
+## Task Breakdown in Plan Mode - REQUIRED PROCESS
+
+Plan Mode is specifically designed for analyzing complex tasks and breaking them into manageable subtasks. When in Plan Mode, you **MUST**:
+
+### 1. Initial Task Analysis - REQUIRED
+
+-   **MUST** begin by thoroughly understanding the full scope of the user's request
+-   **MUST** identify all major components and dependencies of the task
+-   **MUST** consider potential challenges, edge cases, and prerequisites
+
+### 2. Strategic Task Decomposition - REQUIRED
+
+-   **MUST** break the overall task into logical, discrete subtasks
+-   **MUST** prioritize subtasks based on dependencies (what must be completed first)
+-   **MUST** aim for subtasks that can be completed within a single session (15-30 minutes of work)
+-   **MUST** consider natural breaking points where context switching makes sense
+
+### 3. Creating a Task Roadmap - REQUIRED
+
+-   **MUST** present a clear, numbered list of subtasks to the user
+-   **MUST** explain dependencies between subtasks
+-   **MUST** provide time estimates for each subtask when possible
+-   **MUST** use Mermaid diagrams to visualize task flow and dependencies when helpful
+
+\`\`\`mermaid
+graph TD
+A[Main Task] --> B[Subtask 1: Setup]
+A --> C[Subtask 2: Core Implementation]
+A --> D[Subtask 3: Testing]
+A --> E[Subtask 4: Documentation]
+B --> C
+C --> D
+\`\`\`
+
+### 4. Getting User Approval - REQUIRED
+
+-   **MUST** ask for user feedback on the proposed task breakdown
+-   **MUST** adjust the plan based on user priorities or additional requirements
+-   **MUST** confirm which subtask to begin with
+-   **MUST** request the user to toggle to Act Mode when ready to implement
+
+## Task Implementation and Handoff Process - MANDATORY PROCEDURES
+
+When implementing tasks in Act Mode, you **MUST** follow these guidelines for effective task handoff:
+
+### 1. Focused Implementation - REQUIRED
+
+-   **MUST** focus on completing the current subtask fully
+-   **MUST** document progress clearly through comments and commit messages
+-   **MUST** create checkpoints at logical completion points
+
+### 2. Recognizing Completion Points - CRITICAL
+
+You **MUST** identify natural handoff points when:
+
+-   The current subtask is fully completed
+-   You've reached a logical stopping point in a larger subtask
+-   The implementation is taking longer than expected and can be continued later
+-   The task scope has expanded beyond the original plan
+-   **CRITICAL**: The context window usage exceeds 50% (e.g., 100,000+ tokens for a 200K context window)
+
+### 3. Initiating the Handoff Process - MANDATORY ACTION
+
+When you've reached a completion point, you **MUST**:
+
+1. Summarize what has been accomplished so far
+2. Clearly state what remains to be done
+3. **MANDATORY**: Use the `ask_followup_question` tool to offer creating a new task:
+
+\`\`\`xml
+<ask_followup_question>
+<question>I've completed [specific accomplishment]. Would you like me to create a new task to continue with [remaining work]?</question>
+<options>["Yes, create a new task", "No, continue in this session", "Let me think about it"]</options>
+</ask_followup_question>
+\`\`\`
+
+### 4. Creating a New Task with Context - REQUIRED ACTION
+
+If the user agrees to create a new task, you **MUST** use the `new_task` tool with comprehensive handoff instructions:
+
+\`\`\`xml
+<new_task>
+<context>
+
+# Task Continuation: [Brief Task Title]
+
+## Completed Work
+
+-   [Detailed list of completed items]
+-   [Include specific files modified/created]
+-   [Note any important decisions made]
+
+## Current State
+
+-   [Description of the current state of the project]
+-   [Any running processes or environment setup]
+-   [Key files and their current state]
+
+## Next Steps
+
+-   [Detailed list of remaining tasks]
+-   [Specific implementation details to address]
+-   [Any known challenges to be aware of]
+
+## Reference Information
+
+-   [Links to relevant documentation]
+-   [Important code snippets or patterns to follow]
+-   [Any user preferences noted during the current session]
+
+Please continue the implementation by [specific next action].
+</context>
+</new_task>
+\`\`\`
+
+### 5. Detailed Context Transfer - MANDATORY COMPONENTS
+
+When creating a new task, you **MUST** always include:
+
+#### Project Context - REQUIRED
+
+-   **MUST** include the overall goal and purpose of the project
+-   **MUST** include key architectural decisions and patterns
+-   **MUST** include technology stack and dependencies
+
+#### Implementation Details - REQUIRED
+
+-   **MUST** list files created or modified in the current session
+-   **MUST** describe specific functions, classes, or components implemented
+-   **MUST** explain design patterns being followed
+-   **MUST** outline testing approach
+
+#### Progress Tracking - REQUIRED
+
+-   **MUST** provide checklist of completed items
+-   **MUST** provide checklist of remaining items
+-   **MUST** note any blockers or challenges encountered
+
+#### User Preferences - REQUIRED
+
+-   **MUST** note coding style preferences mentioned by the user
+-   **MUST** document specific approaches requested by the user
+-   **MUST** highlight priority areas identified by the user
+
+## Best Practices for Effective Handoffs - MANDATORY GUIDELINES
+
+### 1. Maintain Continuity - REQUIRED
+
+-   **MUST** use consistent terminology between tasks
+-   **MUST** reference previous decisions and their rationale
+-   **MUST** maintain the same architectural approach unless explicitly changing direction
+
+### 2. Preserve Context - REQUIRED
+
+-   **MUST** include relevant code snippets in the handoff
+-   **MUST** summarize key discussions from the previous session
+-   **MUST** reference specific files and line numbers when applicable
+
+### 3. Set Clear Next Actions - REQUIRED
+
+-   **MUST** begin the handoff with a clear, actionable next step
+-   **MUST** prioritize remaining tasks
+-   **MUST** highlight any decisions that need to be made
+
+### 4. Document Assumptions - REQUIRED
+
+-   **MUST** clearly state any assumptions made during implementation
+-   **MUST** note areas where user input might be needed
+-   **MUST** identify potential alternative approaches
+
+### 5. Optimize for Resumability - REQUIRED
+
+-   **MUST** structure the handoff so the next session can begin working immediately
+-   **MUST** include setup instructions if environment configuration is needed
+-   **MUST** provide a quick summary at the top for rapid context restoration
+
+## Example Task Handoff
+
+### Example #1 of an effective task handoff:
+
+\`\`\`xml
+<new_task>
+<context>
+
+# Task Continuation: Implement User Authentication System
+
+## Completed Work
+
+-   Created basic Express.js server structure
+-   Implemented MongoDB connection and user schema
+-   Completed user registration endpoint with password hashing
+-   Added input validation using Joi
+-   Created initial test suite for registration endpoint
+
+## Current State
+
+-   Server runs successfully on port 3000
+-   MongoDB connection is established
+-   Registration endpoint (/api/users/register) is fully functional
+-   Test suite passes for all registration scenarios
+
+## Next Steps
+
+1. Implement login endpoint (/api/users/login)
+    - Use bcrypt to compare passwords
+    - Generate JWT token upon successful login
+    - Add proper error handling for invalid credentials
+2. Create authentication middleware
+    - Verify JWT tokens
+    - Extract user information
+    - Handle expired tokens
+3. Add protected routes that require authentication
+4. Implement password reset functionality
+
+## Reference Information
+
+-   JWT secret should be stored in .env file
+-   Follow the existing error handling pattern in routes/users.js
+-   User schema is defined in models/User.js
+-   Test patterns are established in tests/auth.test.js
+
+Please continue by implementing the login endpoint following the same patterns established in the registration endpoint.
+</context>
+</new_task>
+\`\`\`
+
+### Example #2 of an ineffective task handoff:
+
+_(Note: The example provided in the original rules showing "YOLO MODE Implementation" seems less like a direct handoff context block and more like a general status update with future considerations. A true ineffective handoff might lack detail in 'Current State' or 'Next Steps')._
+
+## When to Use Task Handoffs - MANDATORY TRIGGERS
+
+You **MUST** initiate task handoffs in these scenarios:
+
+1. **CRITICAL**: When context window usage exceeds 50% (e.g., 100,000+ tokens for a 200K context window)
+2. **Long-running projects** that exceed a single session
+3. **Complex implementations** with multiple distinct phases
+4. **When context window limitations** are approaching
+5. **When switching focus areas** within a larger project
+6. **When different expertise** might be beneficial for different parts of the task
+
+**⚠️ FINAL REMINDER - CRITICAL INSTRUCTION ⚠️**
+
+You **MUST** monitor the context window usage in the environment details section. When it exceeds 50% (e.g., "105,000 / 200,000 tokens (53%)"), you **MUST** proactively initiate the task handoff process using the `ask_followup_question` tool followed by the `new_task` tool. You MUST use the `new_task` tool.
+
+By strictly following these guidelines, you'll ensure smooth transitions between tasks, maintain project momentum, and provide the best possible experience for users working on complex, multi-session projects.
+
+```markdown
+## User Interaction & Workflow Considerations
+
+-   **Linear Flow:** Currently, using `new_task` creates a linear sequence. The old task ends, and the new one begins. The old task history remains accessible for backtracking.
+-   **User Approval:** You always have control, approving the handoff and having the chance to modify the context Cline proposes to carry forward.
+-   **Flexibility:** The core `new_task` tool is a flexible building block. Experiment with `.clinerules` to create workflows that best suit your needs, whether for strict context management, task decomposition, or other creative uses.
+```
+````

docs/exploring-clines-tools/plan-and-act-modes-a-guide-to-effective-ai-development.mdx

@@ -0,0 +1,136 @@
+---
+title: "Plan & Act Modes: A Guide to Effective AI Development"
+---
+
+## Overview
+
+Plan & Act modes represent Cline's approach to structured AI development, emphasizing thoughtful planning before implementation. This dual-mode system helps developers create more maintainable, accurate code while reducing iteration time.
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Use Plan to gather context before using Act to implement the plan" />
+</Frame>
+
+### Understanding the Modes
+
+#### Plan Mode
+
+-   Optimized for context gathering and strategy
+-   Cannot make changes to your codebase
+-   Focused on understanding requirements and creating implementation plans
+-   Enables full file reading for comprehensive project understanding
+
+#### Act Mode
+
+-   Streamlined for implementation based on established plans
+-   Has access to all of Cline's building capabilities
+-   Maintains context from the planning phase
+-   Can execute changes to your codebase
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Act mode capabilities" />
+</Frame>
+
+### Workflow Guide
+
+#### 1. Start with Plan Mode
+
+Begin every significant development task in Plan mode:
+
+In this mode:
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Plan mode workflow" />
+</Frame>
+
+-   Share your requirements
+-   Let Cline analyze relevant files
+-   Engage in dialogue to clarify objectives
+-   Develop implementation strategy
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Planning phase" />
+</Frame>
+
+#### 2. Switch to Act Mode
+
+Once you have a clear plan, switch to Act mode:
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Switching to Act mode" />
+</Frame>
+
+Act mode allows Cline to:
+
+-   Execute against the agreed plan
+-   Make changes to your codebase
+-   Maintain context from planning phase
+
+#### 3. Iterate as Needed
+
+Complex projects often require multiple plan-act cycles:
+
+-   Return to Plan mode when encountering unexpected complexity
+-   Use Act mode for implementing solutions
+-   Maintain development momentum while ensuring quality
+
+### Best Practices
+
+#### Planning Phase
+
+1. Be comprehensive with requirements
+2. Share relevant context upfront
+3. Point Cline to relevant files if he hasn't read them
+4. Validate approach before implementation
+
+#### Implementation Phase
+
+1. Follow the established plan
+2. Monitor progress against objectives
+3. Track changes and their impact
+4. Document significant decisions
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Implementation best practices" />
+</Frame>
+
+### Power User Tips
+
+#### Enhancing Planning
+
+-   Use Plan mode to explore edge cases before implementation
+-   Switch back to Plan when encountering unexpected complexity
+-   Leverage file reading to validate assumptions early
+-   Have Cline write markdown files of the plan for future reference
+
+### Common Patterns
+
+#### When to Use Plan Mode
+
+-   Starting new features
+-   Debugging complex issues
+-   Architectural decisions
+-   Requirements analysis
+
+#### When to Use Act Mode
+
+-   Implementing agreed solutions
+-   Making routine changes
+-   Following established patterns
+-   Executing test cases
+
+<Frame>
+	<img src="/assets/robot_panel_dark.png" alt="Mode usage patterns" />
+</Frame>
+
+### Contributing
+
+Share your experiences and improvements:
+
+-   Join our [Discord community](https://discord.gg/cline)
+-   Participate in discussions
+-   Submit feature requests
+-   Report issues
+
+---
+
+Remember: The time invested in planning pays dividends in implementation quality and maintenance efficiency

docs/exploring-clines-tools/remote-browser-support.mdx

@@ -0,0 +1,114 @@
+---
+title: "Remote Browser Support"
+description: "Remote browser support allows Cline to utilize a remote Chrome instance, leveraging authentication tokens and session cookies relevant to certain web development test cases."
+icon: globe-pointer
+---
+
+The Remote Browser feature in Cline allows the AI assistant to interact with web content directly through a controlled browser instance. This enables several powerful capabilities:
+
+-   Viewing and interacting with websites
+-   Testing locally running web applications
+-   Monitoring console logs and errors
+-   Performing browser actions like clicking, typing, and scrolling
+
+## Remote Browser in Cline
+
+### What is Remote Browser?
+
+Remote Browser allows Cline to view and interact with websites directly. This feature enables Cline to:
+
+-   Visit websites and view their content
+-   Test your locally running web applications
+-   Fill out forms and click on elements
+-   Capture screenshots of what it sees
+-   Scroll through pages to see more content
+
+### How to Use Remote Browser
+
+#### Basic Commands
+
+You can ask Cline to use the browser with simple instructions:
+
+-   **Open a website**: "Use the browser to check the website at [https://example.com](https://example.com/)"
+-   **Click on elements**: "Click the login button"
+-   **Type text**: "Type 'Hello world' in the search box"
+-   **Scroll the page**: "Scroll down to see more content"
+-   **Close the browser**: "Close the browser now"
+
+#### Example Workflows
+
+**Testing a Web Application:**
+
+```javascript
+Can you start my React app with "npm start" and then check if it's working properly at http://localhost:3000?
+```
+
+**Analyzing a Website:**
+
+```javascript
+Can you visit https://example.com and tell me what you think about its design and layout?
+```
+
+**Filling Out a Form:**
+
+```javascript
+Please go to https://example.com/contact, fill out the contact form with some test data, and submit it.
+```
+
+### Important Things to Know
+
+#### One Browser at a Time
+
+Cline can only use one browser at a time. If you want to visit a different website, you can either:
+
+-   Ask Cline to navigate to a new URL within the same browser session
+-   Ask Cline to close the current browser and open a new one
+
+#### Browser Must Be Closed Before Using Other Tools
+
+If you want Cline to edit files or run commands after using the browser, you must first ask it to close the browser:
+
+```javascript
+Close the browser and then update the CSS file to fix the alignment issue we saw.
+```
+
+#### What Cline Sees
+
+The browser has a fixed viewport size (900x600 pixels by default), similar to a small laptop screen. Cline will share screenshots after each action so you can see exactly what it sees.
+
+#### Console Logs
+
+Cline captures browser console logs, which can be helpful for debugging web applications. These logs are included with each screenshot.
+
+### Common Use Cases
+
+-   **Web Development**: Test your websites and web applications
+-   **UI/UX Review**: Get feedback on website design and usability
+-   **Content Research**: Have Cline browse websites to gather information
+-   **Form Testing**: Verify that forms work correctly
+-   **Responsive Design Testing**: Check how websites look at different screen sizes
+
+### Troubleshooting
+
+-   **If a website doesn't load**: Try providing a direct URL with the http:// or https:// prefix
+-   **If clicking doesn't work**: Try describing the location of the element more precisely
+-   **If the browser seems stuck**: Ask Cline to close the browser and try again
+
+### Using Remote Browser with VS Code in WSL
+
+When running VS Code in WSL, you'll need to configure Windows to allow WSL to connect to Chrome. Follow these steps:
+
+#### Open PowerShell as Administrator and Run:
+
+```powershell
+# Allow WSL to connect to Chrome's debugging port
+New-NetFirewallRule -DisplayName "WSL Chrome Debug" -Direction Inbound -LocalPort 9222 -Protocol TCP -Action Allow
+```
+
+#### Configure Cline in VS Code:
+
+1. Open VS Code settings
+2. Search for "Cline: Chrome Executable Path"
+3. Set the value to the path of your Chrome executable (e.g., `C:\Program Files\Google\Chrome\Application\chrome.exe`)
+
+Cline should now be able to use the Remote Browser feature from within WSL.

docs/exploring-clines-tools/slash-commands.mdx

@@ -0,0 +1,57 @@
+---
+title: "Slash Commands"
+---
+
+#### Overview
+
+Cline provides slash commands as a quick way to invoke specific tools or actions directly from the chat input, offering shortcuts for common operations. This page details the available slash commands and their usage.
+
+#### /newtask
+
+The `/newtask` slash command provides a fast, user-initiated way to leverage the `new_task` tool's functionality for branching explorations or managing long sessions without waiting for Cline to suggest it.
+
+**Functionality:**
+
+1. **Initiation:** Typing `/newtask` in the chat input signals Cline to prepare for starting a new task session.
+2. **Context Proposal:** Cline proposes creating a new task and typically suggests context to preload based on the current session (summarizing key aspects like current work, technical concepts, relevant files, problems solved, and next steps).
+3. **User Confirmation:** You will receive a confirmation prompt (via the `ask_followup_question` tool) displaying the proposed context. You can approve it directly or modify the context before the new task begins.
+4. **New Session:** Upon confirmation, Cline ends the current task session and immediately starts a new one, preloaded with the approved context.
+
+**Benefit:** Allows you to cleanly branch your work or start a new phase while carrying over essential background information ("knowledge transfer") without manual copying or losing the thread of the previous session.
+
+#### /smol (alias /compact)
+
+The `/smol` slash command (with `/compact` as an alias) allows you to condense the chat history **within your current task**. This is useful when a conversation becomes very long, potentially impacting performance or making it harder for the model to maintain focus.
+
+**Functionality:**
+
+1. **Initiation:** Typing `/smol` or `/compact` tells Cline you want to condense the current chat history. You can optionally add instructions after the command to guide the summarization process (e.g., `/smol focus only on the database changes` or `/smol be concise, use bullet points`).
+2. **Summarization:** Cline analyzes the conversation history, considering any additional instructions provided, and generates a summary focusing on key elements: recent discussion points, important decisions, technical concepts, relevant files, problems solved, and planned next steps. Cline determines the appropriate length and detail for the summary. It retains the beginning and very recent parts of the chat while summarizing the middle sections.
+3. **User Confirmation:** Cline presents this generated summary to you via a confirmation prompt and asks if it accurately reflects the essential context.
+4. **Condensing:** If you approve the summary, Cline replaces the summarized middle portion of the chat history in its active context with the generated summary. This reduces the overall token count for subsequent interactions within the _same task_.
+5. **Feedback:** If you reject the summary or provide feedback, Cline will retain the original history and incorporate your feedback for future actions.
+
+**Benefit:** Helps maintain focus and manage token usage during very long, continuous tasks (like deep debugging or extended feature development) without needing to start an entirely new task session. Allows user guidance on the summarization focus.
+
+#### When to Use Which?
+
+Choosing between `/newtask` and `/smol` depends on your goal:
+
+-   Use `/smol` (or `/compact`) when:
+    -   You want to continue the **same task**, but the chat history has become very long or costly.
+    -   You need to reduce token usage for upcoming interactions within the current workflow.
+    -   Example: Deep debugging session where you want to summarize previous steps before continuing.
+-   Use `/newtask` when:
+    -   You have finished one phase of work and want to start a **fresh, related task**.
+    -   You want to branch your exploration while preserving key context from the previous session.
+    -   Example: Moving from developing Feature A to starting work on Feature B, carrying over relevant architectural decisions.
+
+#### Why Manage Context?
+
+While Cline supports large context windows, actively managing context using tools and commands like `/newtask` and `/smol` is often beneficial:
+
+-   **Performance:** Large language models can sometimes experience performance degradation or lose focus when context windows become extremely full (e.g., over 50-75% capacity, depending on the model). Condensing or resetting context can help maintain optimal performance.
+-   **Relevance:** Summarizing or starting fresh ensures the most relevant information is prioritized in the context window.
+-   **Cost:** Reducing the number of tokens sent to the model in each turn can help manage costs, especially with more expensive models.
+
+Using `/newtask` and `/smol` provides you with direct control over the conversation context, allowing for more efficient and effective interaction with Cline.

esbuild.js

@@ -19,6 +19,7 @@ const aliasResolverPlugin = {
 			"@services": path.resolve(__dirname, "src/services"),
 			"@shared": path.resolve(__dirname, "src/shared"),
 			"@utils": path.resolve(__dirname, "src/utils"),
+			"@packages": path.resolve(__dirname, "src/packages"),
 		}
 
 		// For each alias entry, create a resolver
@@ -124,6 +125,7 @@ const extensionConfig = {
 	define: {
 		"process.env.IS_DEV": JSON.stringify(!production),
 	},
+	tsconfig: path.resolve(__dirname, "tsconfig.json"),
 	plugins: [
 		copyWasmFiles,
 		aliasResolverPlugin,

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.13.3",
+	"version": "3.14.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -292,7 +292,7 @@
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
 		"package": "npm run build:webview && npm run check-types && npm run lint && node esbuild.js --production",
 		"protos": "node proto/build-proto.js && prettier src/shared/proto --write && prettier src/core/controller --write",
-		"compile-tests": "tsc -p ./tsconfig.test.json --outDir out",
+		"compile-tests": "node ./scripts/build-tests.js",
 		"watch-tests": "tsc -p . -w --outDir out",
 		"pretest": "npm run compile-tests && npm run compile && npm run lint",
 		"check-types": "tsc --noEmit",
@@ -312,7 +312,8 @@
 		"publish:marketplace:prerelease": "vsce publish --pre-release && ovsx publish --pre-release",
 		"prepare": "husky",
 		"changeset": "changeset",
-		"version-packages": "changeset version"
+		"version-packages": "changeset version",
+		"docs:preview": "cd docs && mintlify dev"
 	},
 	"devDependencies": {
 		"@changesets/cli": "^2.27.12",
@@ -338,6 +339,7 @@
 		"eslint": "^8.57.0",
 		"grpc-tools": "^1.13.0",
 		"husky": "^9.1.7",
+		"mintlify": "^4.0.515",
 		"npm-run-all": "^4.1.5",
 		"prettier": "^3.3.3",
 		"protoc-gen-ts": "^0.8.7",
@@ -387,6 +389,7 @@
 		"jschardet": "^3.1.4",
 		"mammoth": "^1.8.0",
 		"monaco-vscode-textmate-theme-converter": "^0.1.7",
+		"node-cache": "^5.1.2",
 		"ollama": "^0.5.13",
 		"open-graph-scraper": "^6.9.0",
 		"openai": "^4.83.0",

proto/build-proto.js

@@ -2,6 +2,7 @@
 
 import * as fs from "fs/promises"
 import * as path from "path"
+import { fileURLToPath } from "url"
 import { execSync } from "child_process"
 import { globby } from "globby"
 import chalk from "chalk"
@@ -12,7 +13,8 @@ const protoc = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 const tsProtoPlugin = require.resolve("ts-proto/protoc-gen-ts_proto")
 
 // Get script directory and root directory
-const SCRIPT_DIR = path.dirname(new URL(import.meta.url).pathname)
+const __filename = fileURLToPath(import.meta.url)
+const SCRIPT_DIR = path.dirname(__filename)
 const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
 
 async function main() {
@@ -83,6 +85,7 @@ async function generateMethodRegistrations() {
 		path.join(ROOT_DIR, "src", "core", "controller", "file"),
 		path.join(ROOT_DIR, "src", "core", "controller", "mcp"),
 		path.join(ROOT_DIR, "src", "core", "controller", "task"),
+		path.join(ROOT_DIR, "src", "core", "controller", "web-content"),
 		// Add more service directories here as needed
 	]
 

proto/file.proto

@@ -10,7 +10,46 @@ import "common.proto";
 service FileService {
   // Opens a file in the editor
   rpc openFile(StringRequest) returns (Empty);
-  
+ 
   // Opens an image in the system viewer
   rpc openImage(StringRequest) returns (Empty);
+
+  // Deletes a rule file from either global or workspace rules directory
+  rpc deleteRuleFile(RuleFileRequest) returns (RuleFile);
+
+  // Creates a rule file from either global or workspace rules directory
+  rpc createRuleFile(RuleFileRequest) returns (RuleFile);
+  
+  // Search git commits in the workspace
+  rpc searchCommits(StringRequest) returns (GitCommits);
 }
+
+// Response for searchCommits
+message GitCommits {
+  repeated GitCommit commits = 1;
+}
+
+// Represents a Git commit
+message GitCommit {
+  string hash = 1;
+  string short_hash = 2;
+  string subject = 3;
+  string author = 4;
+  string date = 5;
+}
+
+// Unified request for all rule file operations
+message RuleFileRequest {
+  Metadata metadata = 1;
+  bool is_global = 2;            // Common field for all operations
+  optional string rule_path = 3; // Path field for deleteRuleFile (optional)
+  optional string filename = 4;  // Filename field for createRuleFile (optional)
+}
+
+// Result for rule file operations with meaningful data only
+message RuleFile {
+  string file_path = 1;     // Path to the rule file
+  string display_name = 2;  // Filename for display purposes
+  bool already_exists = 3;  // For createRuleFile, indicates if file already existed
+}
+

proto/web_content.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package cline;
+option java_package = "bot.cline.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+service WebContentService {
+  rpc checkIsImageUrl(StringRequest) returns (IsImageUrl);
+}
+
+message IsImageUrl {
+  bool is_image = 1;
+  string url = 2;
+}

scripts/build-tests.js

@@ -0,0 +1,61 @@
+const { execSync } = require("child_process")
+const esbuild = require("esbuild")
+
+const watch = process.argv.includes("--watch")
+
+/**
+ * @type {import('esbuild').Plugin}
+ */
+const esbuildProblemMatcherPlugin = {
+	name: "esbuild-problem-matcher",
+
+	setup(build) {
+		build.onStart(() => {
+			console.log("[watch] build started")
+		})
+		build.onEnd((result) => {
+			result.errors.forEach(({ text, location }) => {
+				console.error(`✘ [ERROR] ${text}`)
+				console.error(`    ${location.file}:${location.line}:${location.column}:`)
+			})
+			console.log("[watch] build finished")
+		})
+	},
+}
+
+const srcConfig = {
+	bundle: true,
+	minify: false,
+	sourcemap: true,
+	sourcesContent: true,
+	logLevel: "silent",
+	entryPoints: ["src/packages/**/*.ts"],
+	outdir: "out/packages",
+	format: "cjs",
+	platform: "node",
+	define: {
+		"process.env.IS_DEV": "true",
+		"process.env.IS_TEST": "true",
+	},
+	external: ["vscode"],
+	plugins: [esbuildProblemMatcherPlugin],
+}
+
+async function main() {
+	const srcCtx = await esbuild.context(srcConfig)
+
+	if (watch) {
+		await srcCtx.watch()
+	} else {
+		await srcCtx.rebuild()
+
+		await srcCtx.dispose()
+	}
+}
+
+execSync("tsc -p ./tsconfig.test.json --outDir out", { encoding: "utf-8" })
+
+main().catch((e) => {
+	console.error(e)
+	process.exit(1)
+})

src/api/providers/bedrock.ts

@@ -28,20 +28,26 @@ export class AwsBedrockHandler implements ApiHandler {
 		const modelId = await this.getModelId()
 		const model = this.getModel()
 
+		// This baseModelId is used to indicate the capabilities of the model.
+		// If the user selects a custom model, baseModelId will be set to the base model ID of the custom model.
+		// Otherwise, baseModelId will be the same as modelId.
+		const baseModelId =
+			(this.options.awsBedrockCustomSelected ? this.options.awsBedrockCustomModelBaseId : modelId) || modelId
+
 		// Check if this is an Amazon Nova model
-		if (modelId.includes("amazon.nova")) {
+		if (baseModelId.includes("amazon.nova")) {
 			yield* this.createNovaMessage(systemPrompt, messages, modelId, model)
 			return
 		}
 
 		// Check if this is a Deepseek model
-		if (modelId.includes("deepseek")) {
+		if (baseModelId.includes("deepseek")) {
 			yield* this.createDeepseekMessage(systemPrompt, messages, modelId, model)
 			return
 		}
 
 		const budget_tokens = this.options.thinkingBudgetTokens || 0
-		const reasoningOn = modelId.includes("3-7") && budget_tokens !== 0 ? true : false
+		const reasoningOn = baseModelId.includes("3-7") && budget_tokens !== 0 ? true : false
 
 		// Get model info and message indices for caching
 		const userMsgIndices = messages.reduce((acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc), [] as number[])
@@ -167,12 +173,23 @@ export class AwsBedrockHandler implements ApiHandler {
 		}
 	}
 
-	getModel(): { id: BedrockModelId; info: ModelInfo } {
+	getModel(): { id: string; info: ModelInfo } {
 		const modelId = this.options.apiModelId
 		if (modelId && modelId in bedrockModels) {
 			const id = modelId as BedrockModelId
 			return { id, info: bedrockModels[id] }
 		}
+
+		const customSelected = this.options.awsBedrockCustomSelected
+		const baseModel = this.options.awsBedrockCustomModelBaseId
+		if (customSelected && modelId && baseModel && baseModel in bedrockModels) {
+			// Use the user-input model ID but inherit capabilities from the base model
+			return {
+				id: modelId,
+				info: bedrockModels[baseModel],
+			}
+		}
+
 		return {
 			id: bedrockDefaultModelId,
 			info: bedrockModels[bedrockDefaultModelId],
@@ -290,7 +307,7 @@ export class AwsBedrockHandler implements ApiHandler {
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
 		modelId: string,
-		model: { id: BedrockModelId; info: ModelInfo },
+		model: { id: string; info: ModelInfo },
 	): ApiStream {
 		// Get Bedrock client with proper credentials
 		const client = await this.getBedrockClient()
@@ -476,13 +493,13 @@ export class AwsBedrockHandler implements ApiHandler {
 
 	/**
 	 * Creates a message using Amazon Nova models through AWS Bedrock
-	 * Implements support for Nova Micro, Nova Lite, and Nova Pro models
+	 * Implements support for Amazon Nova models
 	 */
 	private async *createNovaMessage(
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
 		modelId: string,
-		model: { id: BedrockModelId; info: ModelInfo },
+		model: { id: string; info: ModelInfo },
 	): ApiStream {
 		// Get Bedrock client with proper credentials
 		const client = await this.getBedrockClient()

src/api/providers/gemini.ts

@@ -1,6 +1,7 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
 // Restore GenerateContentConfig import and add GenerateContentResponseUsageMetadata
 import { GoogleGenAI, type Content, type GenerateContentConfig, type GenerateContentResponseUsageMetadata } from "@google/genai"
+import NodeCache from "node-cache"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
 import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "@shared/api"
@@ -10,100 +11,183 @@ import { ApiStream } from "../transform/stream"
 // Define a default TTL for the cache (e.g., 15 minutes in seconds)
 const DEFAULT_CACHE_TTL_SECONDS = 900
 
+interface GeminiHandlerOptions extends ApiHandlerOptions {
+	isVertex?: boolean
+}
+
+/**
+ * Handler for Google's Gemini API with optimized caching strategy and accurate cost accounting.
+ *
+ * Key features:
+ * - One cache per task: Creates a single cache per task and reuses it for subsequent turns
+ * - Stable cache keys: Uses taskId as a stable identifier for caches
+ * - Efficient cache updates: Only updates caches when there's new content to add
+ * - Split cost accounting: Separates immediate costs from ongoing cache storage costs
+ *
+ * Cost accounting approach:
+ * - Immediate costs (per message): Input tokens, output tokens, and cache read costs
+ * - Ongoing costs (per task): Cache storage costs for the TTL period
+ *
+ * Gemini's caching system is unique in that it charges for holding tokens in cache by the hour.
+ * This implementation optimizes for both performance and cost by:
+ * 1. Minimizing redundant cache creations
+ * 2. Properly accounting for cache costs in the billing calculations
+ * 3. Using a stable cache key to ensure cache reuse across turns
+ * 4. Separating immediate costs from ongoing costs to avoid double-counting
+ */
 export class GeminiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: GoogleGenAI // Updated client type
+	private client: GoogleGenAI
 
-	// Internal state for caching
-	private cacheName: string | null = null
-	private cacheExpireTime: number | null = null
-	private isFirstApiCall = true
+	// Enhanced caching system
+	private contentCaches: NodeCache // Stores cache details (key, count, etc.)
+	private isCacheBusy = false
+	private taskCacheNames: Map<string, string> = new Map() // Maps taskId to cache name for stable lookup
+	private taskCacheTokens: Map<string, number> = new Map() // Maps taskId to total tokens in cache
 
-	constructor(options: ApiHandlerOptions) {
-		if (!options.geminiApiKey) {
-			throw new Error("API key is required for Google Gemini")
-		}
+	constructor(options: GeminiHandlerOptions) {
+		// Store the options
 		this.options = options
-		// Updated client initialization
-		this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
+
+		if (options.isVertex) {
+			// Initialize with Vertex AI configuration
+			const project = this.options.vertexProjectId ?? "not-provided"
+			const location = this.options.vertexRegion ?? "not-provided"
+
+			this.client = new GoogleGenAI({
+				vertexai: true,
+				project,
+				location,
+			})
+		} else {
+			// Initialize with standard API key
+			if (!options.geminiApiKey) {
+				throw new Error("API key is required for Google Gemini when not using Vertex AI")
+			}
+
+			this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
+		}
+
+		// Initialize cache with TTL and check period
+		this.contentCaches = new NodeCache({
+			stdTTL: DEFAULT_CACHE_TTL_SECONDS,
+			checkperiod: DEFAULT_CACHE_TTL_SECONDS,
+		})
 	}
 
+	/**
+	 * Creates a message using the Gemini API with optimized caching and split cost accounting.
+	 *
+	 * This method implements a task-based caching strategy:
+	 * 1. Each task gets its own cache, identified by taskId
+	 * 2. On first call for a task, a new cache is created
+	 * 3. On subsequent calls, the existing cache is reused and only new messages are sent
+	 * 4. Cache operations are tracked for accurate cost accounting
+	 *
+	 * Cost accounting:
+	 * - Immediate costs (returned in the usage object): Input tokens, output tokens, cache read costs
+	 * - Ongoing costs (tracked at task level): Cache storage costs for the TTL period
+	 *
+	 * @param systemPrompt The system prompt to use for the message
+	 * @param messages The conversation history to include in the message
+	 * @returns An async generator that yields chunks of the response with accurate immediate costs
+	 */
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const { id: modelId, info: modelInfo } = this.getModel()
+		const { id: model, info } = this.getModel()
+		const contents = messages.map(convertAnthropicMessageToGemini)
 
-		// --- Cache Handling Logic ---
-		const isCacheValid = this.cacheName && this.cacheExpireTime && Date.now() < this.cacheExpireTime
-		let useCache = !this.isFirstApiCall && isCacheValid
+		// Ensure we have a stable cache key (taskId)
+		if (!this.options.taskId) {
+			console.warn("[GeminiHandler] No taskId provided, caching will be disabled")
+		}
 
-		if (this.isFirstApiCall && !isCacheValid && systemPrompt) {
-			// It's the first call, no valid cache exists, and we have a system prompt. Attempt cache creation.
-			this.isFirstApiCall = false
+		const taskId = this.options.taskId
 
-			// Minimum token check heuristic (simple length check for now, could be improved)
-			// Gemini requires minimum 4096 tokens. A simple length check isn't accurate but avoids complex token counting here.
-			// Let's assume a generous average of 4 chars/token. 4096 tokens * 4 chars/token = 16384 chars.
-			const MIN_SYSTEM_PROMPT_LENGTH_FOR_CACHE = 16384
-			if (systemPrompt.length >= MIN_SYSTEM_PROMPT_LENGTH_FOR_CACHE) {
-				// Start cache creation asynchronously, don't block the main request
-				this.createCacheInBackground(modelId, systemPrompt)
+		// Calculate total content length for cache eligibility check
+		const contentsLength = systemPrompt.length + this.getMessagesLength(contents)
+
+		// Minimum token threshold for caching (approx 4096 tokens)
+		const CONTEXT_CACHE_TOKEN_MINIMUM = 4096
+
+		let uncachedContent: Content[] | undefined = undefined
+		let cachedContent: string | undefined = undefined
+
+		// Check if caching is available and content is large enough to benefit from caching
+		// We only enable caching for conversations above a certain size to avoid overhead for small requests
+		const isCacheAvailable = info.supportsPromptCache && contentsLength > 4 * CONTEXT_CACHE_TOKEN_MINIMUM && taskId
+
+		// This flag tracks whether this operation involves a cache write/update
+		// It's used to track task-level ongoing costs, not immediate costs
+		let cacheWrite = false
+
+		if (isCacheAvailable) {
+			// Check if we already have a cache for this task
+			const existingCacheName = this.taskCacheNames.get(taskId)
+			const cacheEntry = existingCacheName ? this.contentCaches.get<{ key: string; count: number }>(taskId) : undefined
+
+			if (cacheEntry) {
+				// Use existing cache
+				uncachedContent = contents.slice(cacheEntry.count, contents.length)
+				cachedContent = cacheEntry.key
+				console.log(
+					`[GeminiHandler] using existing cache for task ${taskId}: ${cacheEntry.count} cached messages (${cacheEntry.key}) and ${uncachedContent.length} uncached messages`,
+				)
 			}
-			// Proceed with the first request *without* using the cache, as it's being created.
-			useCache = false
-		} else if (!isCacheValid && this.cacheName) {
-			// Cache exists but has expired
-			this.cacheName = null
-			this.cacheExpireTime = null
-			useCache = false
-		}
-		// --- End Cache Handling Logic ---
 
-		// Re-implement thinking budget logic based on new SDK structure
+			// Create or update cache only if there's new content to add
+			const shouldUpdateCache = !existingCacheName || (cacheEntry && uncachedContent && uncachedContent.length > 0)
+
+			if (shouldUpdateCache) {
+				// If we should update the cache, then there will be a cache write
+				cacheWrite = true
+			}
+		}
+		const isCacheUsed = !!cachedContent
+
+		// Configure thinking budget if supported
 		const thinkingBudget = this.options.thinkingBudgetTokens ?? 0
-		const maxBudget = modelInfo.thinkingConfig?.maxBudget ?? 0
+		const maxBudget = info.thinkingConfig?.maxBudget ?? 0
 
-		// port add baseUrl configuration for gemini api requests (#2843)
-		const httpOptions = this.options.geminiBaseUrl ? { baseUrl: this.options.geminiBaseUrl } : undefined
-
-		// Base generation config - Conditionally include systemInstruction based on cache usage
-		const generationConfig: GenerateContentConfig = {
-			httpOptions,
-			temperature: 0, // Default temperature
-			// Only include systemInstruction if NOT using the cache
-			...(useCache ? {} : { systemInstruction: systemPrompt }),
-		}
-
-		// Convert messages to the format expected by @google/genai
-		// Note: convertAnthropicMessageToGemini might need adjustments
-		const contents: Content[] = messages.map(convertAnthropicMessageToGemini)
-
-		// Construct the main request config - Type as GenerateContentConfig
+		// Set up base generation config
 		const requestConfig: GenerateContentConfig = {
-			...generationConfig,
+			// Add base URL if configured
+			httpOptions: this.options.geminiBaseUrl ? { baseUrl: this.options.geminiBaseUrl } : undefined,
+
+			// Only include systemInstruction if NOT using the cache
+			...(isCacheUsed ? {} : { systemInstruction: systemPrompt }),
+
+			// Set temperature (default to 0)
+			temperature: 0,
 		}
 
 		// Add thinking config if the model supports it
-		if (modelInfo.thinkingConfig?.outputPrice !== undefined && maxBudget > 0) {
+		if (info.thinkingConfig?.outputPrice !== undefined && maxBudget > 0) {
 			requestConfig.thinkingConfig = {
 				thinkingBudget: thinkingBudget,
 			}
 		}
 
-		// Generate content using the new SDK structure via client.models
+		// Generate content using the configured parameters
 		const result = await this.client.models.generateContentStream({
-			model: modelId, // Pass model ID directly
-			contents,
-			// Add cachedContent if using the cache
+			model,
+			contents: uncachedContent ?? contents,
 			config: {
 				...requestConfig,
-				...(useCache ? { cachedContent: this.cacheName! } : {}),
+				...(isCacheUsed ? { cachedContent } : {}),
 			},
 		})
 
-		// Declare variable to hold the last usage metadata found
+		// Update the cache after the LLM request is already sent to avoid blocking
+		// We only update the cache if we have a taskId and the cache write flag is set
+		// This is a non-blocking operation and will not affect the response time
+		if (cacheWrite && taskId) {
+			this.updateCacheContent(taskId, model, contents, systemPrompt)
+		}
+		// Track usage metadata
 		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined
 
-		// Iterate directly over the stream
+		// Process the stream
 		for await (const chunk of result) {
 			if (chunk.text) {
 				yield {
@@ -111,47 +195,337 @@ export class GeminiHandler implements ApiHandler {
 					text: chunk.text,
 				}
 			}
+
 			if (chunk.usageMetadata) {
 				lastUsageMetadata = chunk.usageMetadata
 			}
 		}
 
+		// Yield usage information at the end
 		if (lastUsageMetadata) {
+			const inputTokens = lastUsageMetadata.promptTokenCount ?? 0
+			const outputTokens = lastUsageMetadata.candidatesTokenCount ?? 0
+			const cacheReadTokens = lastUsageMetadata.cachedContentTokenCount
+
+			// Calculate immediate costs only (excluding cache write/storage costs)
+			const totalCost = this.calculateCost({
+				info,
+				inputTokens,
+				outputTokens,
+				cacheReadTokens,
+			})
+
+			// Store the token count for task-level ongoing cost tracking
+			// This is not included in the immediate costs returned to the user
+			const cacheWriteTokens = cacheWrite ? inputTokens : undefined
+
+			// If this is a cache write operation, update the task's ongoing costs
+			if (cacheWrite && this.options.taskId && inputTokens > 0) {
+				// Log the ongoing costs for debugging
+				const ongoingCosts = this.getTaskOngoingCosts(this.options.taskId)
+				console.log(
+					`[GeminiHandler] Task ${this.options.taskId} ongoing costs: $${ongoingCosts?.toFixed(6) ?? "unknown"}`,
+				)
+			}
+
 			yield {
 				type: "usage",
-				inputTokens: lastUsageMetadata.promptTokenCount ?? 0,
-				outputTokens: lastUsageMetadata.candidatesTokenCount ?? 0,
-				cacheWriteTokens: lastUsageMetadata.cachedContentTokenCount ?? 0,
-				cacheReadTokens: useCache ? (lastUsageMetadata.promptTokenCount ?? 0) : 0, // If cache used, prompt tokens are read from cache
+				inputTokens,
+				outputTokens,
+				cacheReadTokens,
+				cacheWriteTokens,
+				totalCost,
 			}
 		}
 	}
 
-	private async createCacheInBackground(modelId: string, systemInstruction: string): Promise<void> {
+	/**
+	 * Lists all caches for the current API key.
+	 *
+	 * According to the Gemini API documentation, you can retrieve metadata for all uploaded caches
+	 * using the caches.list() method. This is useful for monitoring cache usage and cleanup.
+	 *
+	 * @param pageSize Optional number of caches to return per page (default: 10)
+	 * @returns A promise that resolves to an array of cache metadata objects
+	 */
+	public async listCaches(pageSize: number = 10): Promise<any[]> {
 		try {
-			const cache = await this.client.caches.create({
-				model: modelId,
+			const caches: any[] = []
+			const pager = await this.client.caches.list({ config: { pageSize } })
+
+			let page = pager.page
+			while (true) {
+				for (const cache of page) {
+					caches.push(cache)
+				}
+
+				if (!pager.hasNextPage()) {
+					break
+				}
+				page = await pager.nextPage()
+			}
+
+			return caches
+		} catch (error) {
+			console.error(`[GeminiHandler] Failed to list caches:`, error)
+			return []
+		}
+	}
+
+	/**
+	 * Updates the content of a cache for a specific task.
+	 *
+	 * Since the Gemini API doesn't support incremental updates to cache content,
+	 * this method:
+	 * 1. Creates a new cache with the full content (old + new)
+	 * 2. Deletes the old cache if it exists
+	 * 3. Updates our local tracking to point to the new cache
+	 *
+	 * @param taskId The ID of the task whose cache should be updated
+	 * @param model The model to use for the cache
+	 * @param contents The full content to cache (including both old and new messages)
+	 * @param systemInstruction The system instruction to include in the cache
+	 */
+	private async updateCacheContent(
+		taskId: string,
+		model: string,
+		contents: Content[],
+		systemInstruction: string,
+	): Promise<void> {
+		if (this.isCacheBusy) {
+			console.log(`[GeminiHandler] Cache is busy, skipping update for task ${taskId}`)
+			return
+		}
+
+		this.isCacheBusy = true
+		const timestamp = Date.now()
+		const existingCacheName = this.taskCacheNames.get(taskId)
+
+		try {
+			// 1. Create a new cache with the full content
+			const result = await this.client.caches.create({
+				model,
 				config: {
-					systemInstruction: systemInstruction,
+					contents,
+					systemInstruction,
 					ttl: `${DEFAULT_CACHE_TTL_SECONDS}s`,
+					httpOptions: { timeout: 120_000 },
 				},
 			})
 
-			if (cache?.name) {
-				this.cacheName = cache.name
-				// Calculate expiry timestamp using the default TTL, as the response object might not contain it directly.
-				this.cacheExpireTime = Date.now() + DEFAULT_CACHE_TTL_SECONDS * 1000
-			} else {
-				console.warn("Gemini cache creation call succeeded but returned no cache name.")
+			const { name, usageMetadata } = result
+
+			if (name) {
+				// 2. Delete the old cache if it exists (non-blocking)
+				// We don't await this operation to avoid blocking the main flow if deletion fails
+				if (existingCacheName) {
+					// Schedule cache deletion in the background
+					setTimeout(() => {
+						this.client.caches
+							.delete({ name: existingCacheName })
+							.then(() => {
+								console.log(`[GeminiHandler] Deleted old cache ${existingCacheName} for task ${taskId}`)
+							})
+							.catch((error) => {
+								console.error(`[GeminiHandler] Failed to delete old cache ${existingCacheName}:`, error)
+								console.log(`[GeminiHandler] Continuing without deleting old cache. It will expire after TTL.`)
+							})
+					}, 1000)
+				}
+
+				// 3. Update our local tracking
+				this.contentCaches.set<{ key: string; count: number }>(taskId, {
+					key: name,
+					count: contents.length,
+				})
+				this.taskCacheNames.set(taskId, name)
+
+				// Track total tokens in cache for ongoing cost calculation
+				const totalTokens = usageMetadata?.totalTokenCount ?? 0
+				this.taskCacheTokens.set(taskId, totalTokens)
+
+				const operation = existingCacheName ? "Updated" : "Created new"
+				console.log(
+					`[GeminiHandler] ${operation} cache for task ${taskId}: ${contents.length} messages (${totalTokens} tokens) in ${Date.now() - timestamp}ms`,
+				)
+
+				return // Indicate that a cache write occurred
 			}
+
+			return
 		} catch (error) {
-			console.error("Failed to create Gemini cache in background:", error)
-			// Reset state if creation failed definitively
-			this.cacheName = null
-			this.cacheExpireTime = null
+			console.error(`[GeminiHandler] Failed to update cache for task ${taskId}:`, error)
+			return
+		} finally {
+			this.isCacheBusy = false
 		}
 	}
 
+	/**
+	 * Updates the TTL of an existing cache.
+	 *
+	 * According to the Gemini API documentation, you can update the TTL of a cache
+	 * using the caches.update() method. This is useful for extending the lifetime
+	 * of a cache that's still being used.
+	 *
+	 * @param taskId The ID of the task whose cache TTL should be updated
+	 * @param ttlSeconds The new TTL in seconds
+	 * @returns A promise that resolves to the updated cache, or undefined if the update fails
+	 */
+	public async updateCacheTTL(taskId: string, ttlSeconds: number = DEFAULT_CACHE_TTL_SECONDS): Promise<any> {
+		const cacheName = this.taskCacheNames.get(taskId)
+		if (!cacheName) {
+			console.warn(`[GeminiHandler] No cache found for task ${taskId}, cannot update TTL`)
+			return
+		}
+
+		try {
+			const updatedCache = await this.client.caches.update({
+				name: cacheName,
+				config: { ttl: `${ttlSeconds}s` },
+			})
+
+			console.log(`[GeminiHandler] Updated TTL for cache ${cacheName} to ${ttlSeconds}s`)
+			return updatedCache
+		} catch (error) {
+			console.error(`[GeminiHandler] Failed to update TTL for cache ${cacheName}:`, error)
+		}
+	}
+
+	/**
+	 * Calculate the ongoing costs for a task based on cache storage.
+	 *
+	 * This method calculates the cost of holding tokens in cache for the TTL period.
+	 * These costs are separate from the immediate costs of API calls and should be
+	 * tracked at the task level rather than the message level.
+	 *
+	 * TODO: Surface these ongoing costs to the user in the UI, possibly in:
+	 * - The task header/summary
+	 * - A dedicated "costs" panel or tooltip
+	 * - As part of the total cost calculation for the task
+	 *
+	 * @param taskId The ID of the task to calculate ongoing costs for
+	 * @returns The ongoing cost in dollars, or undefined if no cache exists for the task
+	 */
+	public getTaskOngoingCosts(taskId: string): number | undefined {
+		const tokens = this.taskCacheTokens.get(taskId)
+		if (!tokens) {
+			return undefined
+		}
+
+		const { info } = this.getModel()
+		if (!info.cacheWritesPrice) {
+			return undefined
+		}
+
+		// Calculate the cost of holding tokens in cache for the TTL period
+		// (tokens / 1M) * (price per 1M tokens) * (cache TTL in hours)
+		return info.cacheWritesPrice * (tokens / 1_000_000) * (DEFAULT_CACHE_TTL_SECONDS / 3600)
+	}
+
+	/**
+	 * Calculate the immediate dollar cost of the API call based on token usage and model pricing.
+	 *
+	 * This method accounts for the immediate costs of the API call:
+	 * - Input token costs (for uncached tokens)
+	 * - Output token costs
+	 * - Cache read costs
+	 *
+	 * It does NOT include ongoing costs like cache storage, which are tracked separately
+	 * at the task level through getTaskOngoingCosts().
+	 */
+	public calculateCost({
+		info,
+		inputTokens,
+		outputTokens,
+		cacheWriteTokens = 0,
+		cacheReadTokens = 0,
+	}: {
+		info: ModelInfo
+		inputTokens: number
+		outputTokens: number
+		cacheWriteTokens?: number
+		cacheReadTokens?: number
+	}) {
+		// Exit early if any required pricing information is missing
+		if (!info.inputPrice || !info.outputPrice) {
+			return undefined
+		}
+
+		let inputPrice = info.inputPrice
+		let outputPrice = info.outputPrice
+		let cacheWritesPrice = info.cacheWritesPrice ?? 0
+		// Right now, we only show the immediate costs of caching and not the ongoing costs of storing the cache
+		cacheWritesPrice = 0
+		let cacheReadsPrice = info.cacheReadsPrice ?? 0
+
+		// If there's tiered pricing then adjust prices based on the input tokens used
+		if (info.tiers) {
+			const tier = info.tiers.find((tier) => inputTokens <= tier.contextWindow)
+			if (tier) {
+				inputPrice = tier.inputPrice ?? inputPrice
+				outputPrice = tier.outputPrice ?? outputPrice
+				cacheWritesPrice = tier.cacheWritesPrice ?? cacheWritesPrice
+				cacheReadsPrice = tier.cacheReadsPrice ?? cacheReadsPrice
+			}
+		}
+
+		// Subtract the cached input tokens from the total input tokens
+		const uncachedInputTokens = inputTokens - (cacheReadTokens ?? 0)
+
+		// Calculate immediate costs only
+
+		// 1. Input token costs (for uncached tokens)
+		const inputTokensCost = inputPrice * (uncachedInputTokens / 1_000_000)
+
+		// 2. Output token costs
+		const outputTokensCost = outputPrice * (outputTokens / 1_000_000)
+
+		// 3. Cache read costs (immediate)
+		const cacheReadCost = (cacheReadTokens ?? 0) > 0 ? cacheReadsPrice * ((cacheReadTokens ?? 0) / 1_000_000) : 0
+
+		// Calculate total immediate cost (excluding cache write/storage costs)
+		const totalCost = inputTokensCost + outputTokensCost + cacheReadCost
+
+		// Create the trace object for debugging
+		const trace: Record<string, { price: number; tokens: number; cost: number }> = {
+			input: { price: inputPrice, tokens: uncachedInputTokens, cost: inputTokensCost },
+			output: { price: outputPrice, tokens: outputTokens, cost: outputTokensCost },
+		}
+
+		// Only include cache read costs in the trace (cache write costs are tracked separately)
+		if ((cacheReadTokens ?? 0) > 0) {
+			trace.cacheRead = { price: cacheReadsPrice, tokens: cacheReadTokens ?? 0, cost: cacheReadCost }
+		}
+
+		// console.log(`[GeminiHandler] calculateCost -> ${totalCost}`, trace)
+		return totalCost
+	}
+
+	/**
+	 * Calculate the total length of all messages for cache eligibility check
+	 */
+	private getMessagesLength(contents: Content[]): number {
+		return contents.reduce((total, content) => {
+			if (!content.parts) {
+				return total
+			}
+
+			return (
+				total +
+				content.parts.reduce((partTotal, part) => {
+					if (typeof part.text === "string") {
+						return partTotal + part.text.length
+					}
+					return partTotal
+				}, 0)
+			)
+		}, 0)
+	}
+
+	/**
+	 * Get the model ID and info for the current configuration
+	 */
 	getModel(): { id: GeminiModelId; info: ModelInfo } {
 		const modelId = this.options.apiModelId
 		if (modelId && modelId in geminiModels) {
@@ -163,4 +537,61 @@ export class GeminiHandler implements ApiHandler {
 			info: geminiModels[geminiDefaultModelId],
 		}
 	}
+
+	/**
+	 * Count tokens in content using the Gemini API
+	 */
+	async countTokens(content: Array<any>): Promise<number> {
+		try {
+			const { id: model } = this.getModel()
+
+			// Convert content to Gemini format
+			const geminiContent = content.map((block) => {
+				if (typeof block === "string") {
+					return { text: block }
+				}
+				return { text: JSON.stringify(block) }
+			})
+
+			// Use Gemini's token counting API
+			const response = await this.client.models.countTokens({
+				model,
+				contents: [{ parts: geminiContent }],
+			})
+
+			if (response.totalTokens === undefined) {
+				console.warn("Gemini token counting returned undefined, using fallback")
+				return this.estimateTokens(content)
+			}
+
+			return response.totalTokens
+		} catch (error) {
+			console.warn("Gemini token counting failed, using fallback", error)
+			return this.estimateTokens(content)
+		}
+	}
+
+	/**
+	 * Fallback token estimation method
+	 */
+	private estimateTokens(content: Array<any>): number {
+		// Simple estimation: ~4 characters per token
+		const totalChars = content.reduce((total, block) => {
+			if (typeof block === "string") {
+				return total + block.length
+			} else if (block && typeof block === "object") {
+				// Safely stringify the object
+				try {
+					const jsonStr = JSON.stringify(block)
+					return total + jsonStr.length
+				} catch (e) {
+					console.warn("Failed to stringify block for token estimation", e)
+					return total
+				}
+			}
+			return total
+		}, 0)
+
+		return Math.ceil(totalChars / 4)
+	}
 }

src/api/providers/vertex.ts

@@ -4,26 +4,28 @@ import { withRetry } from "../retry"
 import { ApiHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, vertexDefaultModelId, VertexModelId, vertexModels } from "@shared/api"
 import { ApiStream } from "@api/transform/stream"
-import { VertexAI } from "@google-cloud/vertexai"
-import { calculateApiCostOpenAI } from "@utils/cost"
+import { GeminiHandler } from "./gemini"
 
-// https://docs.anthropic.com/en/api/claude-on-vertex-ai
 export class VertexHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private geminiHandler: GeminiHandler
 	private clientAnthropic: AnthropicVertex
-	private clientVertex: VertexAI
+	private options: ApiHandlerOptions
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
+
+		// Create a GeminiHandler with isVertex flag for Gemini models
+		this.geminiHandler = new GeminiHandler({
+			...options,
+			isVertex: true,
+		})
+
+		// Initialize Anthropic client for Claude models
 		this.clientAnthropic = new AnthropicVertex({
 			projectId: this.options.vertexProjectId,
 			// https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude#regions
 			region: this.options.vertexRegion,
 		})
-		this.clientVertex = new VertexAI({
-			project: this.options.vertexProjectId,
-			location: this.options.vertexRegion,
-		})
 	}
 
 	@withRetry()
@@ -31,66 +33,46 @@ export class VertexHandler implements ApiHandler {
 		const model = this.getModel()
 		const modelId = model.id
 
-		if (modelId.includes("claude")) {
-			let budget_tokens = this.options.thinkingBudgetTokens || 0
-			const reasoningOn = modelId.includes("3-7") && budget_tokens !== 0 ? true : false
+		// For Gemini models, use the GeminiHandler
+		if (!modelId.includes("claude")) {
+			yield* this.geminiHandler.createMessage(systemPrompt, messages)
+			return
+		}
 
-			let stream
-			switch (modelId) {
-				case "claude-3-7-sonnet@20250219":
-				case "claude-3-5-sonnet-v2@20241022":
-				case "claude-3-5-sonnet@20240620":
-				case "claude-3-5-haiku@20241022":
-				case "claude-3-opus@20240229":
-				case "claude-3-haiku@20240307": {
-					// Find indices of user messages for cache control
-					const userMsgIndices = messages.reduce(
-						(acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc),
-						[] as number[],
-					)
-					const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
-					const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
+		// Claude implementation
+		let budget_tokens = this.options.thinkingBudgetTokens || 0
+		const reasoningOn = modelId.includes("3-7") && budget_tokens !== 0 ? true : false
+		let stream
 
-					stream = await this.clientAnthropic.beta.messages.create(
-						{
-							model: modelId,
-							max_tokens: model.info.maxTokens || 8192,
-							thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
-							temperature: reasoningOn ? undefined : 0,
-							system: [
-								{
-									text: systemPrompt,
-									type: "text",
-									cache_control: { type: "ephemeral" },
-								},
-							],
-							messages: messages.map((message, index) => {
-								if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
-									return {
-										...message,
-										content:
-											typeof message.content === "string"
-												? [
-														{
-															type: "text",
-															text: message.content,
-															cache_control: {
-																type: "ephemeral",
-															},
-														},
-													]
-												: message.content.map((content, contentIndex) =>
-														contentIndex === message.content.length - 1
-															? {
-																	...content,
-																	cache_control: {
-																		type: "ephemeral",
-																	},
-																}
-															: content,
-													),
-									}
-								}
+		switch (modelId) {
+			case "claude-3-7-sonnet@20250219":
+			case "claude-3-5-sonnet-v2@20241022":
+			case "claude-3-5-sonnet@20240620":
+			case "claude-3-5-haiku@20241022":
+			case "claude-3-opus@20240229":
+			case "claude-3-haiku@20240307": {
+				// Find indices of user messages for cache control
+				const userMsgIndices = messages.reduce(
+					(acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc),
+					[] as number[],
+				)
+				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
+				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
+				stream = await this.clientAnthropic.beta.messages.create(
+					{
+						model: modelId,
+						max_tokens: model.info.maxTokens || 8192,
+						thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
+						temperature: reasoningOn ? undefined : 0,
+						system: [
+							{
+								text: systemPrompt,
+								type: "text",
+								cache_control: { type: "ephemeral" },
+							},
+						],
+						messages: messages.map((message, index) => {
+							if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
 								return {
 									...message,
 									content:
@@ -99,184 +81,142 @@ export class VertexHandler implements ApiHandler {
 													{
 														type: "text",
 														text: message.content,
+														cache_control: {
+															type: "ephemeral",
+														},
 													},
 												]
-											: message.content,
+											: message.content.map((content, contentIndex) =>
+													contentIndex === message.content.length - 1
+														? {
+																...content,
+																cache_control: {
+																	type: "ephemeral",
+																},
+															}
+														: content,
+												),
 								}
-							}),
-							stream: true,
-						},
-						{
-							headers: {},
-						},
-					)
-					break
-				}
-				default: {
-					stream = await this.clientAnthropic.beta.messages.create({
-						model: modelId,
-						max_tokens: model.info.maxTokens || 8192,
-						temperature: 0,
-						system: [
-							{
-								text: systemPrompt,
-								type: "text",
-							},
-						],
-						messages: messages.map((message) => ({
-							...message,
-							content:
-								typeof message.content === "string"
-									? [
-											{
-												type: "text",
-												text: message.content,
-											},
-										]
-									: message.content,
-						})),
-						stream: true,
-					})
-					break
-				}
-			}
-			for await (const chunk of stream) {
-				switch (chunk.type) {
-					case "message_start":
-						const usage = chunk.message.usage
-						yield {
-							type: "usage",
-							inputTokens: usage.input_tokens || 0,
-							outputTokens: usage.output_tokens || 0,
-							cacheWriteTokens: usage.cache_creation_input_tokens || undefined,
-							cacheReadTokens: usage.cache_read_input_tokens || undefined,
-						}
-						break
-					case "message_delta":
-						yield {
-							type: "usage",
-							inputTokens: 0,
-							outputTokens: chunk.usage.output_tokens || 0,
-						}
-						break
-					case "message_stop":
-						break
-					case "content_block_start":
-						switch (chunk.content_block.type) {
-							case "thinking":
-								yield {
-									type: "reasoning",
-									reasoning: chunk.content_block.thinking || "",
-								}
-								break
-							case "redacted_thinking":
-								// Handle redacted thinking blocks - we still mark it as reasoning
-								// but note that the content is encrypted
-								yield {
-									type: "reasoning",
-									reasoning: "[Redacted thinking block]",
-								}
-								break
-
-							case "text":
-								if (chunk.index > 0) {
-									yield {
-										type: "text",
-										text: "\n",
-									}
-								}
-								yield {
-									type: "text",
-									text: chunk.content_block.text,
-								}
-								break
-						}
-						break
-					case "content_block_delta":
-						switch (chunk.delta.type) {
-							case "thinking_delta":
-								yield {
-									type: "reasoning",
-									reasoning: chunk.delta.thinking,
-								}
-								break
-							case "text_delta":
-								yield {
-									type: "text",
-									text: chunk.delta.text,
-								}
-								break
-						}
-						break
-					case "content_block_stop":
-						break
-				}
-			}
-		} else {
-			// gemini
-			const generativeModel = this.clientVertex.getGenerativeModel({
-				model: this.getModel().id,
-				systemInstruction: {
-					role: "system",
-					parts: [{ text: systemPrompt }],
-				},
-			})
-			const request = {
-				contents: [
-					{
-						role: "user",
-						parts: messages.map((m) => {
-							if (typeof m.content === "string") {
-								return { text: m.content }
-							} else if (Array.isArray(m.content)) {
-								return {
-									text: m.content
-										.map((block) => {
-											if (typeof block === "string") {
-												return block
-											} else if (block.type === "text") {
-												return block.text
-											} else {
-												console.log("Unsupported block type", block)
-												return ""
-											}
-										})
-										.join(" "),
-								}
-							} else {
-								return { text: "" }
+							}
+							return {
+								...message,
+								content:
+									typeof message.content === "string"
+										? [
+												{
+													type: "text",
+													text: message.content,
+												},
+											]
+										: message.content,
 							}
 						}),
+						stream: true,
 					},
-				],
+					{
+						headers: {},
+					},
+				)
+				break
 			}
-			const streamingResult = await generativeModel.generateContentStream(request)
-			for await (const chunk of streamingResult.stream) {
-				// If usage data is available, yield it similarly:
-				// yield { type: "usage", inputTokens: 0, outputTokens: 0 }
-				// Otherwise, just yield text:
-				const candidates = chunk.candidates || []
-				for (const candidate of candidates) {
-					for (const part of candidate.content?.parts || []) {
-						if (part.text) {
+			default: {
+				stream = await this.clientAnthropic.beta.messages.create({
+					model: modelId,
+					max_tokens: model.info.maxTokens || 8192,
+					temperature: 0,
+					system: [
+						{
+							text: systemPrompt,
+							type: "text",
+						},
+					],
+					messages: messages.map((message) => ({
+						...message,
+						content:
+							typeof message.content === "string"
+								? [
+										{
+											type: "text",
+											text: message.content,
+										},
+									]
+								: message.content,
+					})),
+					stream: true,
+				})
+				break
+			}
+		}
+
+		for await (const chunk of stream) {
+			switch (chunk.type) {
+				case "message_start":
+					const usage = chunk.message.usage
+					yield {
+						type: "usage",
+						inputTokens: usage.input_tokens || 0,
+						outputTokens: usage.output_tokens || 0,
+						cacheWriteTokens: usage.cache_creation_input_tokens || undefined,
+						cacheReadTokens: usage.cache_read_input_tokens || undefined,
+					}
+					break
+				case "message_delta":
+					yield {
+						type: "usage",
+						inputTokens: 0,
+						outputTokens: chunk.usage?.output_tokens || 0,
+					}
+					break
+				case "message_stop":
+					break
+				case "content_block_start":
+					switch (chunk.content_block.type) {
+						case "thinking":
+							yield {
+								type: "reasoning",
+								reasoning: chunk.content_block.thinking || "",
+							}
+							break
+						case "redacted_thinking":
+							// Handle redacted thinking blocks - we still mark it as reasoning
+							// but note that the content is encrypted
+							yield {
+								type: "reasoning",
+								reasoning: "[Redacted thinking block]",
+							}
+							break
+						case "text":
+							if (chunk.index > 0) {
+								yield {
+									type: "text",
+									text: "\n",
+								}
+							}
 							yield {
 								type: "text",
-								text: part.text,
+								text: chunk.content_block.text,
 							}
-						}
+							break
 					}
-				}
-			}
-			// Handle token usage metadata
-			const { usageMetadata } = await streamingResult.response
-			if (usageMetadata) {
-				const { promptTokenCount = 0, candidatesTokenCount = 0 } = usageMetadata
-				yield {
-					type: "usage",
-					inputTokens: promptTokenCount,
-					outputTokens: candidatesTokenCount,
-					totalCost: calculateApiCostOpenAI(model.info, promptTokenCount, candidatesTokenCount, 0, 0),
-				}
+					break
+				case "content_block_delta":
+					switch (chunk.delta.type) {
+						case "thinking_delta":
+							yield {
+								type: "reasoning",
+								reasoning: chunk.delta.thinking,
+							}
+							break
+						case "text_delta":
+							yield {
+								type: "text",
+								text: chunk.delta.text,
+							}
+							break
+					}
+					break
+				case "content_block_stop":
+					break
 			}
 		}
 	}

src/api/transform/openrouter-stream.ts

@@ -21,7 +21,7 @@ export async function createOpenRouterStream(
 
 	// prompt caching: https://openrouter.ai/docs/prompt-caching
 	// this was initially specifically for claude models (some models may 'support prompt caching' automatically without this)
-	// gemini models only use the last breakpoint for caching, so the others will be ignored
+	// includes custom support for gemini which does not have iterative caching
 	switch (model.id) {
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":
@@ -40,10 +40,6 @@ export async function createOpenRouterStream(
 		case "anthropic/claude-3-haiku:beta":
 		case "anthropic/claude-3-opus":
 		case "anthropic/claude-3-opus:beta":
-		case "google/gemini-2.5-pro-preview-03-25":
-		case "google/gemini-2.0-flash-001":
-		case "google/gemini-flash-1.5":
-		case "google/gemini-pro-1.5":
 			openAiMessages[0] = {
 				role: "system",
 				content: [
@@ -75,6 +71,52 @@ export async function createOpenRouterStream(
 				}
 			})
 			break
+		case "google/gemini-2.5-pro-preview-03-25":
+		case "google/gemini-2.0-flash-001":
+		case "google/gemini-flash-1.5":
+		case "google/gemini-pro-1.5":
+			// gemini only uses the last breakpoint for caching, so the others will be ignored
+			openAiMessages[0] = {
+				role: "system",
+				content: [
+					{
+						type: "text",
+						text: systemPrompt,
+						// @ts-ignore-next-line
+						cache_control: { type: "ephemeral" },
+					},
+				],
+			}
+
+			const GEMINI_CACHE_USER_MESSAGE_INTERVAL = 4 // add new breakpoint every 4 turns
+			const userMessages = openAiMessages.filter((msg) => msg.role === "user")
+
+			const userMessageCount = userMessages.length
+			const targetUserMessageNumber =
+				Math.floor(userMessageCount / GEMINI_CACHE_USER_MESSAGE_INTERVAL) * GEMINI_CACHE_USER_MESSAGE_INTERVAL
+
+			if (targetUserMessageNumber > 0) {
+				// otherwise dont need to add a breakpoint
+				const msg = userMessages[targetUserMessageNumber - 1]
+
+				if (msg) {
+					if (typeof msg.content === "string") {
+						msg.content = [{ type: "text", text: msg.content }]
+					}
+					if (Array.isArray(msg.content)) {
+						// NOTE: this is fine since env details will always be added at the end. but if it weren't there, and the user added a image_url type message, it would pop a text part before it and then move it after to the end.
+						let lastTextPart = msg.content.filter((part) => part.type === "text").pop()
+
+						if (!lastTextPart) {
+							lastTextPart = { type: "text", text: "..." }
+							msg.content.push(lastTextPart)
+						}
+						// @ts-ignore-next-line
+						lastTextPart["cache_control"] = { type: "ephemeral" }
+					}
+				}
+			}
+			break
 		default:
 			break
 	}

src/core/context/context-tracking/ModelContextTracker.test.ts

@@ -76,26 +76,6 @@ describe("ModelContextTracker", () => {
 		}
 	})
 
-	it("should throw an error when controller is dereferenced", async () => {
-		// Create a new tracker with a controller that will be garbage collected
-		const weakTracker = new ModelContextTracker(mockContext, taskId)
-
-		// Force the WeakRef to return null by overriding the deref method
-		const weakRef = { deref: sandbox.stub().returns(null) }
-		sandbox.stub(WeakRef.prototype, "deref").callsFake(() => weakRef.deref())
-
-		try {
-			// Try to call the method - this should throw
-			await weakTracker.recordModelUsage("any-provider", "any-model", "any-mode")
-
-			// If we get here, the test should fail
-			expect.fail("Expected an error to be thrown")
-		} catch (error) {
-			// Verify the error message
-			expect(error.message).to.equal("Unable to access extension context")
-		}
-	})
-
 	it("should append model usage to existing entries", async () => {
 		// Add an existing model usage entry
 		const existingTimestamp = 1617200000000

src/core/context/instructions/user-instructions/cline-rules.ts

@@ -6,6 +6,7 @@ import fs from "fs/promises"
 import { ClineRulesToggles } from "@shared/cline-rules"
 import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceState } from "@core/storage/state"
 import * as vscode from "vscode"
+import { synchronizeRuleToggles, getRuleFilesTotalContent } from "@core/context/instructions/user-instructions/rule-helpers"
 
 /**
  * Converts .clinerules file to directory and places old .clinerule file inside directory, renaming it
@@ -51,11 +52,7 @@ export const getGlobalClineRules = async (globalClineRulesFilePath: string, togg
 		if (await isDirectory(globalClineRulesFilePath)) {
 			try {
 				const rulesFilePaths = await readDirectory(globalClineRulesFilePath)
-				const rulesFilesTotalContent = await getClineRulesFilesTotalContent(
-					rulesFilePaths,
-					globalClineRulesFilePath,
-					toggles,
-				)
+				const rulesFilesTotalContent = await getRuleFilesTotalContent(rulesFilePaths, globalClineRulesFilePath, toggles)
 				if (rulesFilesTotalContent) {
 					const clineRulesFileInstructions = formatResponse.clineRulesGlobalDirectoryInstructions(
 						globalClineRulesFilePath,
@@ -84,7 +81,7 @@ export const getLocalClineRules = async (cwd: string, toggles: ClineRulesToggles
 		if (await isDirectory(clineRulesFilePath)) {
 			try {
 				const rulesFilePaths = await readDirectory(clineRulesFilePath)
-				const rulesFilesTotalContent = await getClineRulesFilesTotalContent(rulesFilePaths, cwd, toggles)
+				const rulesFilesTotalContent = await getRuleFilesTotalContent(rulesFilePaths, cwd, toggles)
 				if (rulesFilesTotalContent) {
 					clineRulesFileInstructions = formatResponse.clineRulesLocalDirectoryInstructions(cwd, rulesFilesTotalContent)
 				}
@@ -108,86 +105,6 @@ export const getLocalClineRules = async (cwd: string, toggles: ClineRulesToggles
 	return clineRulesFileInstructions
 }
 
-const getClineRulesFilesTotalContent = async (rulesFilePaths: string[], basePath: string, toggles: ClineRulesToggles) => {
-	const ruleFilesTotalContent = await Promise.all(
-		rulesFilePaths.map(async (filePath) => {
-			const ruleFilePath = path.resolve(basePath, filePath)
-			const ruleFilePathRelative = path.relative(basePath, ruleFilePath)
-
-			if (ruleFilePath in toggles && toggles[ruleFilePath] === false) {
-				return null
-			}
-
-			return `${ruleFilePathRelative}\n` + (await fs.readFile(ruleFilePath, "utf8")).trim()
-		}),
-	).then((contents) => contents.filter(Boolean).join("\n\n"))
-	return ruleFilesTotalContent
-}
-
-export async function synchronizeRuleToggles(
-	rulesDirectoryPath: string,
-	currentToggles: ClineRulesToggles,
-): Promise<ClineRulesToggles> {
-	// Create a copy of toggles to modify
-	const updatedToggles = { ...currentToggles }
-
-	try {
-		const pathExists = await fileExistsAtPath(rulesDirectoryPath)
-
-		if (pathExists) {
-			const isDir = await isDirectory(rulesDirectoryPath)
-
-			if (isDir) {
-				// DIRECTORY CASE
-				const filePaths = await readDirectory(rulesDirectoryPath)
-				const existingRulePaths = new Set<string>()
-
-				for (const filePath of filePaths) {
-					const ruleFilePath = path.resolve(rulesDirectoryPath, filePath)
-					existingRulePaths.add(ruleFilePath)
-
-					const pathHasToggle = ruleFilePath in updatedToggles
-					if (!pathHasToggle) {
-						updatedToggles[ruleFilePath] = true
-					}
-				}
-
-				// Clean up toggles for non-existent files
-				for (const togglePath in updatedToggles) {
-					const pathExists = existingRulePaths.has(togglePath)
-					if (!pathExists) {
-						delete updatedToggles[togglePath]
-					}
-				}
-			} else {
-				// FILE CASE
-				// Add toggle for this file
-				const pathHasToggle = rulesDirectoryPath in updatedToggles
-				if (!pathHasToggle) {
-					updatedToggles[rulesDirectoryPath] = true
-				}
-
-				// Remove toggles for any other paths
-				for (const togglePath in updatedToggles) {
-					if (togglePath !== rulesDirectoryPath) {
-						delete updatedToggles[togglePath]
-					}
-				}
-			}
-		} else {
-			// PATH DOESN'T EXIST CASE
-			// Clear all toggles since the path doesn't exist
-			for (const togglePath in updatedToggles) {
-				delete updatedToggles[togglePath]
-			}
-		}
-	} catch (error) {
-		console.error(`Failed to synchronize rule toggles for path: ${rulesDirectoryPath}`, error)
-	}
-
-	return updatedToggles
-}
-
 export async function refreshClineRulesToggles(
 	context: vscode.ExtensionContext,
 	workingDirectory: string,
@@ -221,7 +138,14 @@ export const createRuleFile = async (isGlobal: boolean, filename: string, cwd: s
 			filePath = path.join(globalClineRulesFilePath, filename)
 		} else {
 			const localClineRulesFilePath = path.resolve(cwd, GlobalFileNames.clineRules)
+
+			const hasError = await ensureLocalClinerulesDirExists(cwd)
+			if (hasError === true) {
+				return { filePath: null, fileExists: false }
+			}
+
 			await fs.mkdir(localClineRulesFilePath, { recursive: true })
+
 			filePath = path.join(localClineRulesFilePath, filename)
 		}
 

src/core/context/instructions/user-instructions/external-rules.ts

@@ -0,0 +1,120 @@
+import path from "path"
+import fs from "fs/promises"
+import { GlobalFileNames } from "@core/storage/disk"
+import { fileExistsAtPath, isDirectory } from "@utils/fs"
+import { formatResponse } from "@core/prompts/responses"
+import { getWorkspaceState, updateWorkspaceState } from "@core/storage/state"
+import {
+	synchronizeRuleToggles,
+	combineRuleToggles,
+	getRuleFilesTotalContent,
+	readDirectoryRecursive,
+} from "@core/context/instructions/user-instructions/rule-helpers"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import * as vscode from "vscode"
+
+/**
+ * Refreshes the toggles for windsurf and cursor rules
+ */
+export async function refreshExternalRulesToggles(
+	context: vscode.ExtensionContext,
+	workingDirectory: string,
+): Promise<{
+	windsurfLocalToggles: ClineRulesToggles
+	cursorLocalToggles: ClineRulesToggles
+}> {
+	// local windsurf toggles
+	const localWindsurfRulesToggles = ((await getWorkspaceState(context, "localWindsurfRulesToggles")) as ClineRulesToggles) || {}
+	const localWindsurfRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.windsurfRules)
+	const updatedLocalWindsurfToggles = await synchronizeRuleToggles(localWindsurfRulesFilePath, localWindsurfRulesToggles)
+	await updateWorkspaceState(context, "localWindsurfRulesToggles", updatedLocalWindsurfToggles)
+
+	// local cursor toggles
+	const localCursorRulesToggles = ((await getWorkspaceState(context, "localCursorRulesToggles")) as ClineRulesToggles) || {}
+
+	// cursor has two valid locations for rules files, so we need to check both and combine
+	// synchronizeRuleToggles will drop whichever rules files are not in each given path, but combining the results will result in no data loss
+	let localCursorRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.cursorRulesDir)
+	const updatedLocalCursorToggles1 = await synchronizeRuleToggles(localCursorRulesFilePath, localCursorRulesToggles, ".mdc")
+
+	localCursorRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.cursorRulesFile)
+	const updatedLocalCursorToggles2 = await synchronizeRuleToggles(localCursorRulesFilePath, localCursorRulesToggles)
+
+	const updatedLocalCursorToggles = combineRuleToggles(updatedLocalCursorToggles1, updatedLocalCursorToggles2)
+	await updateWorkspaceState(context, "localCursorRulesToggles", updatedLocalCursorToggles)
+
+	return {
+		windsurfLocalToggles: updatedLocalWindsurfToggles,
+		cursorLocalToggles: updatedLocalCursorToggles,
+	}
+}
+
+/**
+ * Gather formatted windsurf rules
+ */
+export const getLocalWindsurfRules = async (cwd: string, toggles: ClineRulesToggles) => {
+	const windsurfRulesFilePath = path.resolve(cwd, GlobalFileNames.windsurfRules)
+
+	let windsurfRulesFileInstructions: string | undefined
+
+	if (await fileExistsAtPath(windsurfRulesFilePath)) {
+		if (!(await isDirectory(windsurfRulesFilePath))) {
+			try {
+				if (windsurfRulesFilePath in toggles && toggles[windsurfRulesFilePath] !== false) {
+					const ruleFileContent = (await fs.readFile(windsurfRulesFilePath, "utf8")).trim()
+					if (ruleFileContent) {
+						windsurfRulesFileInstructions = formatResponse.windsurfRulesLocalFileInstructions(cwd, ruleFileContent)
+					}
+				}
+			} catch {
+				console.error(`Failed to read .windsurfrules file at ${windsurfRulesFilePath}`)
+			}
+		}
+	}
+
+	return windsurfRulesFileInstructions
+}
+
+/**
+ * Gather formatted cursor rules, which can come from two sources
+ */
+export const getLocalCursorRules = async (cwd: string, toggles: ClineRulesToggles) => {
+	// we first check for the .cursorrules file
+	const cursorRulesFilePath = path.resolve(cwd, GlobalFileNames.cursorRulesFile)
+	let cursorRulesFileInstructions: string | undefined
+
+	if (await fileExistsAtPath(cursorRulesFilePath)) {
+		if (!(await isDirectory(cursorRulesFilePath))) {
+			try {
+				if (cursorRulesFilePath in toggles && toggles[cursorRulesFilePath] !== false) {
+					const ruleFileContent = (await fs.readFile(cursorRulesFilePath, "utf8")).trim()
+					if (ruleFileContent) {
+						cursorRulesFileInstructions = formatResponse.cursorRulesLocalFileInstructions(cwd, ruleFileContent)
+					}
+				}
+			} catch {
+				console.error(`Failed to read .cursorrules file at ${cursorRulesFilePath}`)
+			}
+		}
+	}
+
+	// we then check for the .cursor/rules dir
+	const cursorRulesDirPath = path.resolve(cwd, GlobalFileNames.cursorRulesDir)
+	let cursorRulesDirInstructions: string | undefined
+
+	if (await fileExistsAtPath(cursorRulesDirPath)) {
+		if (await isDirectory(cursorRulesDirPath)) {
+			try {
+				const rulesFilePaths = await readDirectoryRecursive(cursorRulesDirPath, ".mdc")
+				const rulesFilesTotalContent = await getRuleFilesTotalContent(rulesFilePaths, cwd, toggles)
+				if (rulesFilesTotalContent) {
+					cursorRulesDirInstructions = formatResponse.cursorRulesLocalDirectoryInstructions(cwd, rulesFilesTotalContent)
+				}
+			} catch {
+				console.error(`Failed to read .cursor/rules directory at ${cursorRulesDirPath}`)
+			}
+		}
+	}
+
+	return [cursorRulesFileInstructions, cursorRulesDirInstructions]
+}

src/core/context/instructions/user-instructions/rule-helpers.ts

@@ -0,0 +1,121 @@
+import { fileExistsAtPath, isDirectory, readDirectory } from "@utils/fs"
+import * as path from "path"
+import fs from "fs/promises"
+import { ClineRulesToggles } from "@shared/cline-rules"
+
+/**
+ * Recursively traverses directory and finds all files, including checking for optional whitelisted file extension
+ */
+export async function readDirectoryRecursive(directoryPath: string, allowedFileExtension: string): Promise<string[]> {
+	try {
+		const entries = await readDirectory(directoryPath)
+		let results: string[] = []
+		for (const entry of entries) {
+			if (allowedFileExtension !== "") {
+				const fileExtension = path.extname(entry)
+				if (fileExtension !== allowedFileExtension) {
+					continue
+				}
+			}
+			results.push(entry)
+		}
+		return results
+	} catch (error) {
+		console.error(`Error reading directory ${directoryPath}: ${error}`)
+		return []
+	}
+}
+
+/**
+ * Gets the up to date toggles
+ */
+export async function synchronizeRuleToggles(
+	rulesDirectoryPath: string,
+	currentToggles: ClineRulesToggles,
+	allowedFileExtension: string = "",
+): Promise<ClineRulesToggles> {
+	// Create a copy of toggles to modify
+	const updatedToggles = { ...currentToggles }
+
+	try {
+		const pathExists = await fileExistsAtPath(rulesDirectoryPath)
+
+		if (pathExists) {
+			const isDir = await isDirectory(rulesDirectoryPath)
+
+			if (isDir) {
+				// DIRECTORY CASE
+				const filePaths = await readDirectoryRecursive(rulesDirectoryPath, allowedFileExtension)
+				const existingRulePaths = new Set<string>()
+
+				for (const filePath of filePaths) {
+					const ruleFilePath = path.resolve(rulesDirectoryPath, filePath)
+					existingRulePaths.add(ruleFilePath)
+
+					const pathHasToggle = ruleFilePath in updatedToggles
+					if (!pathHasToggle) {
+						updatedToggles[ruleFilePath] = true
+					}
+				}
+
+				// Clean up toggles for non-existent files
+				for (const togglePath in updatedToggles) {
+					const pathExists = existingRulePaths.has(togglePath)
+					if (!pathExists) {
+						delete updatedToggles[togglePath]
+					}
+				}
+			} else {
+				// FILE CASE
+				// Add toggle for this file
+				const pathHasToggle = rulesDirectoryPath in updatedToggles
+				if (!pathHasToggle) {
+					updatedToggles[rulesDirectoryPath] = true
+				}
+
+				// Remove toggles for any other paths
+				for (const togglePath in updatedToggles) {
+					if (togglePath !== rulesDirectoryPath) {
+						delete updatedToggles[togglePath]
+					}
+				}
+			}
+		} else {
+			// PATH DOESN'T EXIST CASE
+			// Clear all toggles since the path doesn't exist
+			for (const togglePath in updatedToggles) {
+				delete updatedToggles[togglePath]
+			}
+		}
+	} catch (error) {
+		console.error(`Failed to synchronize rule toggles for path: ${rulesDirectoryPath}`, error)
+	}
+
+	return updatedToggles
+}
+
+/**
+ * Certain project rules have more than a single location where rules are allowed to be stored
+ */
+export function combineRuleToggles(toggles1: ClineRulesToggles, toggles2: ClineRulesToggles): ClineRulesToggles {
+	return { ...toggles1, ...toggles2 }
+}
+
+/**
+ * Read the content of rules files
+ */
+export const getRuleFilesTotalContent = async (rulesFilePaths: string[], basePath: string, toggles: ClineRulesToggles) => {
+	const ruleFilesTotalContent = await Promise.all(
+		rulesFilePaths.map(async (filePath) => {
+			const ruleFilePath = path.resolve(basePath, filePath)
+			const ruleFilePathRelative = path.relative(basePath, ruleFilePath)
+
+			if (ruleFilePath in toggles && toggles[ruleFilePath] === false) {
+				return null
+			}
+
+			return `${ruleFilePathRelative}\n` + (await fs.readFile(ruleFilePath, "utf8")).trim()
+		}),
+	).then((contents) => contents.filter(Boolean).join("\n\n"))
+	return ruleFilesTotalContent
+}

src/core/controller/file/createRuleFile.ts

@@ -0,0 +1,55 @@
+import { Controller } from ".."
+import { RuleFileRequest, RuleFile } from "@shared/proto/file"
+import { FileMethodHandler } from "./index"
+import {
+	createRuleFile as createRuleFileImpl,
+	refreshClineRulesToggles,
+} from "@core/context/instructions/user-instructions/cline-rules"
+import * as vscode from "vscode"
+import * as path from "path"
+import { handleFileServiceRequest } from "./index"
+import { cwd } from "@core/task"
+
+/**
+ * Creates a rule file in either global or workspace rules directory
+ * @param controller The controller instance
+ * @param request The request containing filename and isGlobal flag
+ * @returns Result with file path and display name
+ * @throws Error if operation fails
+ */
+export const createRuleFile: FileMethodHandler = async (controller: Controller, request: RuleFileRequest): Promise<RuleFile> => {
+	if (typeof request.isGlobal !== "boolean" || typeof request.filename !== "string" || !request.filename) {
+		console.error("createRuleFile: Missing or invalid parameters", {
+			isGlobal: typeof request.isGlobal === "boolean" ? request.isGlobal : `Invalid: ${typeof request.isGlobal}`,
+			filename: typeof request.filename === "string" ? request.filename : `Invalid: ${typeof request.filename}`,
+		})
+		throw new Error("Missing or invalid parameters")
+	}
+
+	const { filePath, fileExists } = await createRuleFileImpl(request.isGlobal, request.filename, cwd)
+
+	if (!filePath) {
+		throw new Error("Failed to create rule file.")
+	}
+
+	if (fileExists) {
+		vscode.window.showWarningMessage(`Rule file "${request.filename}" already exists.`)
+		// Still open it for editing
+		await handleFileServiceRequest(controller, "openFile", { value: filePath })
+	} else {
+		await refreshClineRulesToggles(controller.context, cwd)
+		await controller.postStateToWebview()
+
+		await handleFileServiceRequest(controller, "openFile", { value: filePath })
+
+		vscode.window.showInformationMessage(
+			`Created new ${request.isGlobal ? "global" : "workspace"} rule file: ${request.filename}`,
+		)
+	}
+
+	return RuleFile.create({
+		filePath: filePath,
+		displayName: path.basename(filePath),
+		alreadyExists: fileExists,
+	})
+}

src/core/controller/file/deleteRuleFile.ts

@@ -0,0 +1,47 @@
+import { Controller } from ".."
+import { RuleFileRequest, RuleFile } from "@shared/proto/file"
+import { FileMethodHandler } from "./index"
+import {
+	deleteRuleFile as deleteRuleFileImpl,
+	refreshClineRulesToggles,
+} from "@core/context/instructions/user-instructions/cline-rules"
+import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
+import * as vscode from "vscode"
+import * as path from "path"
+import { cwd } from "@core/task"
+
+/**
+ * Deletes a rule file from either global or workspace rules directory
+ * @param controller The controller instance
+ * @param request The request containing rule path and isGlobal flag
+ * @returns Result with file path and display name
+ * @throws Error if operation fails
+ */
+export const deleteRuleFile: FileMethodHandler = async (controller: Controller, request: RuleFileRequest): Promise<RuleFile> => {
+	if (typeof request.isGlobal !== "boolean" || typeof request.rulePath !== "string" || !request.rulePath) {
+		console.error("deleteRuleFile: Missing or invalid parameters", {
+			isGlobal: typeof request.isGlobal === "boolean" ? request.isGlobal : `Invalid: ${typeof request.isGlobal}`,
+			rulePath: typeof request.rulePath === "string" ? request.rulePath : `Invalid: ${typeof request.rulePath}`,
+		})
+		throw new Error("Missing or invalid parameters")
+	}
+
+	const result = await deleteRuleFileImpl(controller.context, request.rulePath, request.isGlobal)
+
+	if (!result.success) {
+		throw new Error(result.message || "Failed to delete rule file")
+	}
+
+	await refreshClineRulesToggles(controller.context, cwd)
+	await refreshExternalRulesToggles(controller.context, cwd)
+	await controller.postStateToWebview()
+
+	const fileName = path.basename(request.rulePath)
+	vscode.window.showInformationMessage(`Rule file "${fileName}" deleted successfully`)
+
+	return RuleFile.create({
+		filePath: request.rulePath,
+		displayName: fileName,
+		alreadyExists: false,
+	})
+}

src/core/controller/file/methods.ts

@@ -3,12 +3,18 @@
 
 // Import all method implementations
 import { registerMethod } from "./index"
+import { createRuleFile } from "./createRuleFile"
+import { deleteRuleFile } from "./deleteRuleFile"
 import { openFile } from "./openFile"
 import { openImage } from "./openImage"
+import { searchCommits } from "./searchCommits"
 
 // Register all file service methods
 export function registerAllMethods(): void {
 	// Register each method with the registry
+	registerMethod("createRuleFile", createRuleFile)
+	registerMethod("deleteRuleFile", deleteRuleFile)
 	registerMethod("openFile", openFile)
 	registerMethod("openImage", openImage)
+	registerMethod("searchCommits", searchCommits)
 }

src/core/controller/file/searchCommits.ts

@@ -0,0 +1,31 @@
+import { Controller } from ".."
+import { GitCommits } from "@shared/proto/file"
+import { StringRequest } from "@shared/proto/common"
+import { searchCommits as searchCommitsUtil } from "@utils/git"
+import { getWorkspacePath } from "@utils/path"
+import { FileMethodHandler } from "./index"
+import { convertGitCommitsToProtoGitCommits } from "@shared/proto-conversions/file/git-commit-conversion"
+
+/**
+ * Searches for git commits in the workspace repository
+ * @param controller The controller instance
+ * @param request The request message containing the search query in the 'value' field
+ * @returns GitCommits containing the matching commits
+ */
+export const searchCommits: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<GitCommits> => {
+	const cwd = getWorkspacePath()
+	if (!cwd) {
+		return GitCommits.create({ commits: [] })
+	}
+
+	try {
+		const commits = await searchCommitsUtil(request.value || "", cwd)
+
+		const protoCommits = convertGitCommitsToProtoGitCommits(commits)
+
+		return GitCommits.create({ commits: protoCommits })
+	} catch (error) {
+		console.error(`Error searching commits: ${JSON.stringify(error)}`)
+		return GitCommits.create({ commits: [] })
+	}
+}

src/core/controller/grpc-handler.ts

@@ -5,6 +5,7 @@ import { handleFileServiceRequest } from "./file"
 import { handleTaskServiceRequest } from "./task"
 import { handleCheckpointsServiceRequest } from "./checkpoints"
 import { handleMcpServiceRequest } from "./mcp"
+import { handleWebContentServiceRequest } from "./web-content"
 
 /**
  * Handles gRPC requests from the webview
@@ -62,6 +63,11 @@ export class GrpcHandler {
 						message: await handleMcpServiceRequest(this.controller, method, message),
 						request_id: requestId,
 					}
+				case "cline.WebContentService":
+					return {
+						message: await handleWebContentServiceRequest(this.controller, method, message),
+						request_id: requestId,
+					}
 				default:
 					throw new Error(`Unknown service: ${service}`)
 			}

src/core/controller/index.ts

@@ -11,7 +11,7 @@ import { handleGrpcRequest } from "./grpc-handler"
 import { buildApiHandler } from "@api/index"
 import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
 import { downloadTask } from "@integrations/misc/export-markdown"
-import { fetchOpenGraphData, isImageUrl } from "@integrations/misc/link-preview"
+import { fetchOpenGraphData } from "@integrations/misc/link-preview"
 import { handleFileServiceRequest } from "./file"
 import { selectImages } from "@integrations/misc/process-images"
 import { getTheme } from "@integrations/theme/getTheme"
@@ -48,7 +48,8 @@ import {
 } from "../storage/state"
 import { Task, cwd } from "../task"
 import { ClineRulesToggles } from "@shared/cline-rules"
-import { createRuleFile, deleteRuleFile, refreshClineRulesToggles } from "../context/instructions/user-instructions/cline-rules"
+import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
+import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
 
 /*
 https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -64,7 +65,7 @@ export class Controller {
 	workspaceTracker: WorkspaceTracker
 	mcpHub: McpHub
 	accountService: ClineAccountService
-	private latestAnnouncementId = "april-18-2025_21:15::00" // update to some unique identifier when we add a new announcement
+	private latestAnnouncementId = "may-02-2025_16:27:00" // update to some unique identifier when we add a new announcement
 
 	constructor(
 		readonly context: vscode.ExtensionContext,
@@ -335,8 +336,8 @@ export class Controller {
 			case "showTaskWithId":
 				this.showTaskWithId(message.text!)
 				break
-			case "deleteTaskWithId":
-				this.deleteTaskWithId(message.text!)
+			case "deleteTasksWithIds":
+				this.deleteTasksWithIds(message.text!)
 				break
 			case "exportTaskWithId":
 				this.exportTaskWithId(message.text!)
@@ -375,6 +376,7 @@ export class Controller {
 				break
 			case "refreshClineRules":
 				await refreshClineRulesToggles(this.context, cwd)
+				await refreshExternalRulesToggles(this.context, cwd)
 				await this.postStateToWebview()
 				break
 			case "openInBrowser":
@@ -384,39 +386,6 @@ export class Controller {
 				break
 			case "fetchOpenGraphData":
 				this.fetchOpenGraphData(message.text!)
-				break
-			case "checkIsImageUrl":
-				this.checkIsImageUrl(message.text!)
-				break
-			case "createRuleFile":
-				if (typeof message.isGlobal !== "boolean" || typeof message.filename !== "string" || !message.filename) {
-					console.error("createRuleFile: Missing or invalid parameters", {
-						isGlobal:
-							typeof message.isGlobal === "boolean" ? message.isGlobal : `Invalid: ${typeof message.isGlobal}`,
-						filename: typeof message.filename === "string" ? message.filename : `Invalid: ${typeof message.filename}`,
-					})
-					return
-				}
-				const { filePath, fileExists } = await createRuleFile(message.isGlobal, message.filename, cwd)
-				if (fileExists && filePath) {
-					vscode.window.showWarningMessage(`Rule file "${message.filename}" already exists.`)
-					// Still open it for editing
-					await handleFileServiceRequest(this, "openFile", { value: filePath })
-					return
-				} else if (filePath && !fileExists) {
-					await refreshClineRulesToggles(this.context, cwd)
-					await this.postStateToWebview()
-
-					await handleFileServiceRequest(this, "openFile", { value: filePath })
-
-					vscode.window.showInformationMessage(
-						`Created new ${message.isGlobal ? "global" : "workspace"} rule file: ${message.filename}`,
-					)
-				} else {
-					// null filePath
-					vscode.window.showErrorMessage(`Failed to create rule file.`)
-				}
-
 				break
 			case "openMention":
 				openMention(message.text)
@@ -549,21 +518,29 @@ export class Controller {
 				}
 				break
 			}
-			case "deleteClineRule": {
-				const { isGlobal, rulePath } = message
-				if (rulePath && typeof isGlobal === "boolean") {
-					const result = await deleteRuleFile(this.context, rulePath, isGlobal)
-					if (result.success) {
-						await refreshClineRulesToggles(this.context, cwd)
-						await this.postStateToWebview()
-					} else {
-						console.error("Failed to delete rule file:", result.message)
-					}
+			case "toggleWindsurfRule": {
+				const { rulePath, enabled } = message
+				if (rulePath && typeof enabled === "boolean") {
+					const toggles =
+						((await getWorkspaceState(this.context, "localWindsurfRulesToggles")) as ClineRulesToggles) || {}
+					toggles[rulePath] = enabled
+					await updateWorkspaceState(this.context, "localWindsurfRulesToggles", toggles)
+					await this.postStateToWebview()
 				} else {
-					console.error("deleteClineRule: Missing or invalid parameters", {
-						rulePath,
-						isGlobal: typeof isGlobal === "boolean" ? isGlobal : `Invalid: ${typeof isGlobal}`,
-					})
+					console.error("toggleWindsurfRule: Missing or invalid parameters")
+				}
+				break
+			}
+			case "toggleCursorRule": {
+				const { rulePath, enabled } = message
+				if (rulePath && typeof enabled === "boolean") {
+					const toggles =
+						((await getWorkspaceState(this.context, "localCursorRulesToggles")) as ClineRulesToggles) || {}
+					toggles[rulePath] = enabled
+					await updateWorkspaceState(this.context, "localCursorRulesToggles", toggles)
+					await this.postStateToWebview()
+				} else {
+					console.error("toggleCursorRule: Missing or invalid parameters")
 				}
 				break
 			}
@@ -589,21 +566,6 @@ export class Controller {
 				this.mcpHub?.sendLatestMcpServers()
 				break
 			}
-			case "searchCommits": {
-				const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
-				if (cwd) {
-					try {
-						const commits = await searchCommits(message.text || "", cwd)
-						await this.postMessageToWebview({
-							type: "commitSearchResults",
-							commits,
-						})
-					} catch (error) {
-						console.error(`Error searching commits: ${JSON.stringify(error)}`)
-					}
-				}
-				break
-			}
 			case "openExtensionSettings": {
 				const settingsFilter = message.text || ""
 				await vscode.commands.executeCommand(
@@ -832,6 +794,8 @@ export class Controller {
 			previousModeVsCodeLmModelSelector: newVsCodeLmModelSelector,
 			previousModeThinkingBudgetTokens: newThinkingBudgetTokens,
 			previousModeReasoningEffort: newReasoningEffort,
+			previousModeAwsBedrockCustomSelected: newAwsBedrockCustomSelected,
+			previousModeAwsBedrockCustomModelBaseId: newAwsBedrockCustomModelBaseId,
 			planActSeparateModelsSetting,
 		} = await getAllExtensionState(this.context)
 
@@ -844,7 +808,6 @@ export class Controller {
 			await updateGlobalState(this.context, "previousModeReasoningEffort", apiConfiguration.reasoningEffort)
 			switch (apiConfiguration.apiProvider) {
 				case "anthropic":
-				case "bedrock":
 				case "vertex":
 				case "gemini":
 				case "asksage":
@@ -854,6 +817,19 @@ export class Controller {
 				case "xai":
 					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
 					break
+				case "bedrock":
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(
+						this.context,
+						"previousModeAwsBedrockCustomSelected",
+						apiConfiguration.awsBedrockCustomSelected,
+					)
+					await updateGlobalState(
+						this.context,
+						"previousModeAwsBedrockCustomModelBaseId",
+						apiConfiguration.awsBedrockCustomModelBaseId,
+					)
+					break
 				case "openrouter":
 				case "cline":
 					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
@@ -899,7 +875,6 @@ export class Controller {
 				await updateGlobalState(this.context, "reasoningEffort", newReasoningEffort)
 				switch (newApiProvider) {
 					case "anthropic":
-					case "bedrock":
 					case "vertex":
 					case "gemini":
 					case "asksage":
@@ -909,6 +884,11 @@ export class Controller {
 					case "xai":
 						await updateGlobalState(this.context, "apiModelId", newModelId)
 						break
+					case "bedrock":
+						await updateGlobalState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
+						await updateGlobalState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
+						break
 					case "openrouter":
 					case "cline":
 						await updateGlobalState(this.context, "openRouterModelId", newModelId)
@@ -1760,6 +1740,12 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 		this.refreshTotalTasksSize()
 	}
 
+	async deleteTasksWithIds(ids: string) {
+		for (const id of JSON.parse(ids) as string[]) {
+			await this.deleteTaskWithId(id)
+		}
+	}
+
 	async deleteTaskFromState(id: string) {
 		// Remove the task from history
 		const taskHistory = ((await getGlobalState(this.context, "taskHistory")) as HistoryItem[] | undefined) || []
@@ -1797,6 +1783,12 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 		const localClineRulesToggles =
 			((await getWorkspaceState(this.context, "localClineRulesToggles")) as ClineRulesToggles) || {}
 
+		const localWindsurfRulesToggles =
+			((await getWorkspaceState(this.context, "localWindsurfRulesToggles")) as ClineRulesToggles) || {}
+
+		const localCursorRulesToggles =
+			((await getWorkspaceState(this.context, "localCursorRulesToggles")) as ClineRulesToggles) || {}
+
 		return {
 			version: this.context.extension?.packageJSON?.version ?? "",
 			apiConfiguration,
@@ -1821,6 +1813,8 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 			vscMachineId: vscode.env.machineId,
 			globalClineRulesToggles: globalClineRulesToggles || {},
 			localClineRulesToggles: localClineRulesToggles || {},
+			localWindsurfRulesToggles: localWindsurfRulesToggles || {},
+			localCursorRulesToggles: localCursorRulesToggles || {},
 			shellIntegrationTimeout,
 		}
 	}
@@ -1918,29 +1912,6 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 		}
 	}
 
-	// Check if a URL is an image
-	async checkIsImageUrl(url: string) {
-		try {
-			// Check if the URL is an image
-			const isImage = await isImageUrl(url)
-
-			// Send the result back to the webview
-			await this.postMessageToWebview({
-				type: "isImageUrlResult",
-				isImage,
-				url,
-			})
-		} catch (error) {
-			console.error(`Error checking if URL is an image: ${url}`, error)
-			// Send an error response
-			await this.postMessageToWebview({
-				type: "isImageUrlResult",
-				isImage: false,
-				url,
-			})
-		}
-	}
-
 	// dev
 
 	async resetState() {

src/core/controller/web-content/checkIsImageUrl.ts

@@ -0,0 +1,29 @@
+import { Controller } from "../index"
+import { StringRequest } from "../../../shared/proto/common"
+import { IsImageUrl } from "../../../shared/proto/web_content"
+import { detectImageUrl } from "@integrations/misc/link-preview"
+
+/**
+ * Checks if a URL is an image URL
+ * @param controller The controller instance
+ * @param request The request containing the URL to check
+ * @returns A result indicating if the URL is an image and the URL that was checked
+ */
+export async function checkIsImageUrl(controller: Controller, request: StringRequest): Promise<IsImageUrl> {
+	try {
+		const url = request.value || ""
+		// Check if the URL is an image
+		const isImage = await detectImageUrl(url)
+
+		return {
+			isImage,
+			url,
+		}
+	} catch (error) {
+		console.error(`Error checking if URL is an image: ${request.value}`, error)
+		return {
+			isImage: false,
+			url: request.value || "",
+		}
+	}
+}

src/core/controller/web-content/index.ts

@@ -0,0 +1,15 @@
+import { createServiceRegistry, ServiceMethodHandler } from "../grpc-service"
+import { registerAllMethods } from "./methods"
+
+// Create web content service registry
+const webContentService = createServiceRegistry("web-content")
+
+// Export the method handler type and registration function
+export type WebContentMethodHandler = ServiceMethodHandler
+export const registerMethod = webContentService.registerMethod
+
+// Export the request handler
+export const handleWebContentServiceRequest = webContentService.handleRequest
+
+// Register all web content methods
+registerAllMethods()

src/core/controller/web-content/methods.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+// Generated by proto/build-proto.js
+
+// Import all method implementations
+import { registerMethod } from "./index"
+import { checkIsImageUrl } from "./checkIsImageUrl"
+
+// Register all web-content service methods
+export function registerAllMethods(): void {
+	// Register each method with the registry
+	registerMethod("checkIsImageUrl", checkIsImageUrl)
+}

src/core/prompts/responses.ts

@@ -215,6 +215,15 @@ Otherwise, if you have not completed the task and do not need additional informa
 
 	clineRulesLocalFileInstructions: (cwd: string, content: string) =>
 		`# .clinerules\n\nThe following is provided by a root-level .clinerules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	windsurfRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# .windsurfrules\n\nThe following is provided by a root-level .windsurfrules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	cursorRulesLocalFileInstructions: (cwd: string, content: string) =>
+		`# .cursorrules\n\nThe following is provided by a root-level .cursorrules file where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
+
+	cursorRulesLocalDirectoryInstructions: (cwd: string, content: string) =>
+		`# .cursor/rules\n\nThe following is provided by a root-level .cursor/rules directory where the user has specified instructions for this working directory (${cwd.toPosix()})\n\n${content}`,
 }
 
 // to avoid circular dependency

src/core/prompts/system.ts

@@ -573,6 +573,7 @@ CAPABILITIES
 		: ""
 }
 - 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.
+- You can use LaTeX syntax in your responses to render mathematical expressions
 
 ====
 
@@ -635,6 +636,9 @@ export function addUserInstructions(
 	settingsCustomInstructions?: string,
 	globalClineRulesFileInstructions?: string,
 	localClineRulesFileInstructions?: string,
+	localCursorRulesFileInstructions?: string,
+	localCursorRulesDirInstructions?: string,
+	localWindsurfRulesFileInstructions?: string,
 	clineIgnoreInstructions?: string,
 	preferredLanguageInstructions?: string,
 ) {
@@ -651,6 +655,15 @@ export function addUserInstructions(
 	if (localClineRulesFileInstructions) {
 		customInstructions += localClineRulesFileInstructions + "\n\n"
 	}
+	if (localCursorRulesFileInstructions) {
+		customInstructions += localCursorRulesFileInstructions + "\n\n"
+	}
+	if (localCursorRulesDirInstructions) {
+		customInstructions += localCursorRulesDirInstructions + "\n\n"
+	}
+	if (localWindsurfRulesFileInstructions) {
+		customInstructions += localWindsurfRulesFileInstructions + "\n\n"
+	}
 	if (clineIgnoreInstructions) {
 		customInstructions += clineIgnoreInstructions
 	}

src/core/storage/disk.ts

@@ -6,7 +6,7 @@ import { fileExistsAtPath } from "@utils/fs"
 import { ClineMessage } from "@shared/ExtensionMessage"
 import { TaskMetadata } from "@core/context/context-tracking/ContextTrackerTypes"
 import os from "os"
-import { execa } from "execa"
+import { execa } from "@packages/execa"
 
 export const GlobalFileNames = {
 	apiConversationHistory: "api_conversation_history.json",
@@ -15,6 +15,9 @@ export const GlobalFileNames = {
 	openRouterModels: "openrouter_models.json",
 	mcpSettings: "cline_mcp_settings.json",
 	clineRules: ".clinerules",
+	cursorRulesDir: ".cursor/rules",
+	cursorRulesFile: ".cursorrules",
+	windsurfRules: ".windsurfrules",
 	taskMetadata: "task_metadata.json",
 }
 

src/core/storage/state-keys.ts

@@ -29,6 +29,8 @@ export type GlobalStateKey =
 	| "awsBedrockEndpoint"
 	| "awsProfile"
 	| "awsUseProfile"
+	| "awsBedrockCustomSelected"
+	| "awsBedrockCustomModelBaseId"
 	| "vertexProjectId"
 	| "vertexRegion"
 	| "lastShownAnnouncementId"
@@ -60,6 +62,8 @@ export type GlobalStateKey =
 	| "previousModeThinkingBudgetTokens"
 	| "previousModeReasoningEffort"
 	| "previousModeVsCodeLmModelSelector"
+	| "previousModeAwsBedrockCustomSelected"
+	| "previousModeAwsBedrockCustomModelBaseId"
 	| "previousModeModelInfo"
 	| "liteLlmBaseUrl"
 	| "liteLlmModelId"

src/core/storage/state.ts

@@ -3,7 +3,7 @@ import { DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
 import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
 import { GlobalStateKey, SecretKey } from "./state-keys"
-import { ApiConfiguration, ApiProvider, ModelInfo } from "@shared/api"
+import { ApiConfiguration, ApiProvider, BedrockModelId, ModelInfo } from "@shared/api"
 import { HistoryItem } from "@shared/HistoryItem"
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
 import { BrowserSettings } from "@shared/BrowserSettings"
@@ -67,6 +67,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		awsBedrockEndpoint,
 		awsProfile,
 		awsUseProfile,
+		awsBedrockCustomSelected,
+		awsBedrockCustomModelBaseId,
 		vertexProjectId,
 		vertexRegion,
 		openAiBaseUrl,
@@ -113,6 +115,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeVsCodeLmModelSelector,
 		previousModeThinkingBudgetTokens,
 		previousModeReasoningEffort,
+		previousModeAwsBedrockCustomSelected,
+		previousModeAwsBedrockCustomModelBaseId,
 		qwenApiLine,
 		liteLlmApiKey,
 		telemetrySetting,
@@ -142,6 +146,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getGlobalState(context, "awsBedrockEndpoint") as Promise<string | undefined>,
 		getGlobalState(context, "awsProfile") as Promise<string | undefined>,
 		getGlobalState(context, "awsUseProfile") as Promise<boolean | undefined>,
+		getGlobalState(context, "awsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "awsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
 		getGlobalState(context, "vertexProjectId") as Promise<string | undefined>,
 		getGlobalState(context, "vertexRegion") as Promise<string | undefined>,
 		getGlobalState(context, "openAiBaseUrl") as Promise<string | undefined>,
@@ -188,6 +194,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getGlobalState(context, "previousModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
 		getGlobalState(context, "previousModeThinkingBudgetTokens") as Promise<number | undefined>,
 		getGlobalState(context, "previousModeReasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
 		getGlobalState(context, "qwenApiLine") as Promise<string | undefined>,
 		getSecret(context, "liteLlmApiKey") as Promise<string | undefined>,
 		getGlobalState(context, "telemetrySetting") as Promise<TelemetrySetting | undefined>,
@@ -258,6 +266,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			awsBedrockEndpoint,
 			awsProfile,
 			awsUseProfile,
+			awsBedrockCustomSelected,
+			awsBedrockCustomModelBaseId,
 			vertexProjectId,
 			vertexRegion,
 			openAiBaseUrl,
@@ -318,6 +328,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeVsCodeLmModelSelector,
 		previousModeThinkingBudgetTokens,
 		previousModeReasoningEffort,
+		previousModeAwsBedrockCustomSelected,
+		previousModeAwsBedrockCustomModelBaseId,
 		mcpMarketplaceEnabled,
 		telemetrySetting: telemetrySetting || "unset",
 		planActSeparateModelsSetting,
@@ -340,6 +352,8 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		awsBedrockEndpoint,
 		awsProfile,
 		awsUseProfile,
+		awsBedrockCustomSelected,
+		awsBedrockCustomModelBaseId,
 		vertexProjectId,
 		vertexRegion,
 		openAiBaseUrl,
@@ -397,6 +411,8 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 	await updateGlobalState(context, "awsBedrockEndpoint", awsBedrockEndpoint)
 	await updateGlobalState(context, "awsProfile", awsProfile)
 	await updateGlobalState(context, "awsUseProfile", awsUseProfile)
+	await updateGlobalState(context, "awsBedrockCustomSelected", awsBedrockCustomSelected)
+	await updateGlobalState(context, "awsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
 	await updateGlobalState(context, "vertexProjectId", vertexProjectId)
 	await updateGlobalState(context, "vertexRegion", vertexRegion)
 	await updateGlobalState(context, "openAiBaseUrl", openAiBaseUrl)

src/core/task/index.ts

@@ -88,6 +88,11 @@ import {
 	refreshClineRulesToggles,
 	ensureLocalClinerulesDirExists,
 } from "@core/context/instructions/user-instructions/cline-rules"
+import {
+	refreshExternalRulesToggles,
+	getLocalWindsurfRules,
+	getLocalCursorRules,
+} from "@core/context/instructions/user-instructions/external-rules"
 import { getGlobalState } from "@core/storage/state"
 import { parseSlashCommands } from "@core/slash-commands"
 import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
@@ -929,6 +934,7 @@ export class Task {
 		let responseImages: string[] | undefined
 		if (response === "messageResponse") {
 			await this.say("user_feedback", text, images)
+			await this.saveCheckpoint()
 			responseText = text
 			responseImages = images
 		}
@@ -1263,7 +1269,7 @@ export class Task {
 				didContinue = true
 				process.continue()
 			} catch {
-				// ask promise was ignored
+				Logger.error("Error while asking for command output")
 			} finally {
 				chunkEnroute = false
 				// If more output accumulated while chunkEnroute, flush again
@@ -1277,11 +1283,11 @@ export class Task {
 			if (chunkTimer) {
 				clearTimeout(chunkTimer)
 			}
-			chunkTimer = setTimeout(() => flushBuffer(), CHUNK_DEBOUNCE_MS)
+			chunkTimer = setTimeout(async () => await flushBuffer(), CHUNK_DEBOUNCE_MS)
 		}
 
 		let result = ""
-		process.on("line", (line) => {
+		process.on("line", async (line) => {
 			result += line + "\n"
 
 			if (!didContinue) {
@@ -1289,7 +1295,7 @@ export class Task {
 				outputBufferSize += Buffer.byteLength(line, "utf8")
 				// Flush if buffer is large enough
 				if (outputBuffer.length >= CHUNK_LINE_COUNT || outputBufferSize >= CHUNK_BYTE_SIZE) {
-					flushBuffer()
+					await flushBuffer()
 				} else {
 					scheduleFlush()
 				}
@@ -1328,6 +1334,7 @@ export class Task {
 
 		if (userFeedback) {
 			await this.say("user_feedback", userFeedback.text, userFeedback.images)
+			await this.saveCheckpoint()
 			return [
 				true,
 				formatResponse.toolResult(
@@ -1444,11 +1451,17 @@ export class Task {
 				: ""
 
 		const { globalToggles, localToggles } = await refreshClineRulesToggles(this.getContext(), cwd)
+		const { windsurfLocalToggles, cursorLocalToggles } = await refreshExternalRulesToggles(this.getContext(), cwd)
 
 		const globalClineRulesFilePath = await ensureRulesDirectoryExists()
 		const globalClineRulesFileInstructions = await getGlobalClineRules(globalClineRulesFilePath, globalToggles)
 
 		const localClineRulesFileInstructions = await getLocalClineRules(cwd, localToggles)
+		const [localCursorRulesFileInstructions, localCursorRulesDirInstructions] = await getLocalCursorRules(
+			cwd,
+			cursorLocalToggles,
+		)
+		const localWindsurfRulesFileInstructions = await getLocalWindsurfRules(cwd, windsurfLocalToggles)
 
 		const clineIgnoreContent = this.clineIgnoreController.clineIgnoreContent
 		let clineIgnoreInstructions: string | undefined
@@ -1460,17 +1473,24 @@ export class Task {
 			settingsCustomInstructions ||
 			globalClineRulesFileInstructions ||
 			localClineRulesFileInstructions ||
+			localCursorRulesFileInstructions ||
+			localCursorRulesDirInstructions ||
+			localWindsurfRulesFileInstructions ||
 			clineIgnoreInstructions ||
 			preferredLanguageInstructions
 		) {
 			// altering the system prompt mid-task will break the prompt cache, but in the grand scheme this will not change often so it's better to not pollute user messages with it the way we have to with <potentially relevant details>
-			systemPrompt += addUserInstructions(
+			const userInstructions = addUserInstructions(
 				settingsCustomInstructions,
 				globalClineRulesFileInstructions,
 				localClineRulesFileInstructions,
+				localCursorRulesFileInstructions,
+				localCursorRulesDirInstructions,
+				localWindsurfRulesFileInstructions,
 				clineIgnoreInstructions,
 				preferredLanguageInstructions,
 			)
+			systemPrompt += userInstructions
 		}
 		const contextManagementMetadata = await this.contextManager.getNewContextMessagesAndMetadata(
 			this.apiConversationHistory,
@@ -1765,6 +1785,7 @@ export class Task {
 						if (text || images?.length) {
 							pushAdditionalToolFeedback(text, images)
 							await this.say("user_feedback", text, images)
+							await this.saveCheckpoint()
 						}
 						this.didRejectTool = true // Prevent further tool uses in this message
 						return false
@@ -1773,6 +1794,7 @@ export class Task {
 						if (text || images?.length) {
 							pushAdditionalToolFeedback(text, images)
 							await this.say("user_feedback", text, images)
+							await this.saveCheckpoint()
 						}
 						return true
 					}
@@ -1847,7 +1869,7 @@ export class Task {
 						if (!accessAllowed) {
 							await this.say("clineignore_error", relPath)
 							pushToolResult(formatResponse.toolError(formatResponse.clineIgnoreError(relPath)))
-
+							await this.saveCheckpoint()
 							break
 						}
 
@@ -1903,6 +1925,7 @@ export class Task {
 									)
 									await this.diffViewProvider.revertChanges()
 									await this.diffViewProvider.reset()
+									await this.saveCheckpoint()
 									break
 								}
 							} else if (content) {
@@ -1960,28 +1983,28 @@ export class Task {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError(block.name, "path"))
 									await this.diffViewProvider.reset()
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (block.name === "replace_in_file" && !diff) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("replace_in_file", "diff"))
 									await this.diffViewProvider.reset()
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (block.name === "write_to_file" && !content) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("write_to_file", "content"))
 									await this.diffViewProvider.reset()
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (block.name === "new_rule" && !content) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("new_rule", "content"))
 									await this.diffViewProvider.reset()
-
+									await this.saveCheckpoint()
 									break
 								}
 
@@ -2040,6 +2063,7 @@ export class Task {
 										if (text || images?.length) {
 											pushAdditionalToolFeedback(text, images)
 											await this.say("user_feedback", text, images)
+											await this.saveCheckpoint()
 										}
 										this.didRejectTool = true
 										didApprove = false
@@ -2049,12 +2073,14 @@ export class Task {
 										if (text || images?.length) {
 											pushAdditionalToolFeedback(text, images)
 											await this.say("user_feedback", text, images)
+											await this.saveCheckpoint()
 										}
 										telemetryService.captureToolUsage(this.taskId, block.name, false, true)
 									}
 
 									if (!didApprove) {
 										await this.diffViewProvider.revertChanges()
+										await this.saveCheckpoint()
 										break
 									}
 								}
@@ -2115,7 +2141,7 @@ export class Task {
 							await handleError("writing file", error)
 							await this.diffViewProvider.revertChanges()
 							await this.diffViewProvider.reset()
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2144,7 +2170,7 @@ export class Task {
 								if (!relPath) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("read_file", "path"))
-
+									await this.saveCheckpoint()
 									break
 								}
 
@@ -2152,7 +2178,7 @@ export class Task {
 								if (!accessAllowed) {
 									await this.say("clineignore_error", relPath)
 									pushToolResult(formatResponse.toolError(formatResponse.clineIgnoreError(relPath)))
-
+									await this.saveCheckpoint()
 									break
 								}
 
@@ -2175,6 +2201,7 @@ export class Task {
 									this.removeLastPartialMessageIfExistsWithType("say", "tool")
 									const didApprove = await askApproval("tool", completeMessage)
 									if (!didApprove) {
+										await this.saveCheckpoint()
 										telemetryService.captureToolUsage(this.taskId, block.name, false, false)
 										break
 									}
@@ -2187,12 +2214,12 @@ export class Task {
 								await this.fileContextTracker.trackFileContext(relPath, "read_tool")
 
 								pushToolResult(content)
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("reading file", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2223,7 +2250,7 @@ export class Task {
 								if (!relDirPath) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("list_files", "path"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -2256,17 +2283,18 @@ export class Task {
 									const didApprove = await askApproval("tool", completeMessage)
 									if (!didApprove) {
 										telemetryService.captureToolUsage(this.taskId, block.name, false, false)
+										await this.saveCheckpoint()
 										break
 									}
 									telemetryService.captureToolUsage(this.taskId, block.name, false, true)
 								}
 								pushToolResult(result)
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("listing files", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2295,7 +2323,7 @@ export class Task {
 								if (!relDirPath) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("list_code_definition_names", "path"))
-
+									await this.saveCheckpoint()
 									break
 								}
 
@@ -2325,17 +2353,18 @@ export class Task {
 									const didApprove = await askApproval("tool", completeMessage)
 									if (!didApprove) {
 										telemetryService.captureToolUsage(this.taskId, block.name, false, false)
+										await this.saveCheckpoint()
 										break
 									}
 									telemetryService.captureToolUsage(this.taskId, block.name, false, true)
 								}
 								pushToolResult(result)
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("parsing source code definitions", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2368,13 +2397,13 @@ export class Task {
 								if (!relDirPath) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("search_files", "path"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (!regex) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("search_files", "regex"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -2406,17 +2435,18 @@ export class Task {
 									const didApprove = await askApproval("tool", completeMessage)
 									if (!didApprove) {
 										telemetryService.captureToolUsage(this.taskId, block.name, false, false)
+										await this.saveCheckpoint()
 										break
 									}
 									telemetryService.captureToolUsage(this.taskId, block.name, false, true)
 								}
 								pushToolResult(results)
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("searching files", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2432,6 +2462,7 @@ export class Task {
 								this.consecutiveMistakeCount++
 								pushToolResult(await this.sayAndCreateMissingParamError("browser_action", "action"))
 								await this.browserSession.closeBrowser()
+								await this.saveCheckpoint()
 							}
 							break
 						}
@@ -2475,7 +2506,7 @@ export class Task {
 										this.consecutiveMistakeCount++
 										pushToolResult(await this.sayAndCreateMissingParamError("browser_action", "url"))
 										await this.browserSession.closeBrowser()
-
+										await this.saveCheckpoint()
 										break
 									}
 									this.consecutiveMistakeCount = 0
@@ -2491,6 +2522,7 @@ export class Task {
 										this.removeLastPartialMessageIfExistsWithType("say", "browser_action_launch")
 										const didApprove = await askApproval("browser_action_launch", url)
 										if (!didApprove) {
+											await this.saveCheckpoint()
 											break
 										}
 									}
@@ -2516,7 +2548,7 @@ export class Task {
 												await this.sayAndCreateMissingParamError("browser_action", "coordinate"),
 											)
 											await this.browserSession.closeBrowser()
-
+											await this.saveCheckpoint()
 											break // can't be within an inner switch
 										}
 									}
@@ -2525,7 +2557,7 @@ export class Task {
 											this.consecutiveMistakeCount++
 											pushToolResult(await this.sayAndCreateMissingParamError("browser_action", "text"))
 											await this.browserSession.closeBrowser()
-
+											await this.saveCheckpoint()
 											break
 										}
 									}
@@ -2574,7 +2606,7 @@ export class Task {
 												browserActionResult.screenshot ? [browserActionResult.screenshot] : [],
 											),
 										)
-
+										await this.saveCheckpoint()
 										break
 									case "close":
 										pushToolResult(
@@ -2582,7 +2614,7 @@ export class Task {
 												`The browser has been closed. You may now proceed to using other tools.`,
 											),
 										)
-
+										await this.saveCheckpoint()
 										break
 								}
 
@@ -2591,7 +2623,7 @@ export class Task {
 						} catch (error) {
 							await this.browserSession.closeBrowser() // if any error occurs, the browser session is terminated
 							await handleError("executing browser action", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2619,7 +2651,7 @@ export class Task {
 								if (!command) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("execute_command", "command"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (!requiresApprovalRaw) {
@@ -2627,7 +2659,7 @@ export class Task {
 									pushToolResult(
 										await this.sayAndCreateMissingParamError("execute_command", "requires_approval"),
 									)
-
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -2643,7 +2675,7 @@ export class Task {
 									pushToolResult(
 										formatResponse.toolError(formatResponse.clineIgnoreError(ignoredFileAttemptedToAccess)),
 									)
-
+									await this.saveCheckpoint()
 									break
 								}
 
@@ -2675,6 +2707,7 @@ export class Task {
 											`${this.shouldAutoApproveTool(block.name) && requiresApprovalPerLLM ? COMMAND_REQ_APP_STRING : ""}`, // ugly hack until we refactor combineCommandSequences
 									)
 									if (!didApprove) {
+										await this.saveCheckpoint()
 										break
 									}
 								}
@@ -2710,7 +2743,7 @@ export class Task {
 							}
 						} catch (error) {
 							await handleError("executing command", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2740,13 +2773,13 @@ export class Task {
 								if (!server_name) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("use_mcp_tool", "server_name"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (!tool_name) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("use_mcp_tool", "tool_name"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								// arguments are optional, but if they are provided they must be valid JSON
@@ -2770,7 +2803,7 @@ export class Task {
 												formatResponse.invalidMcpToolArgumentError(server_name, tool_name),
 											),
 										)
-
+										await this.saveCheckpoint()
 										break
 									}
 								}
@@ -2797,6 +2830,7 @@ export class Task {
 									this.removeLastPartialMessageIfExistsWithType("say", "use_mcp_server")
 									const didApprove = await askApproval("use_mcp_server", completeMessage)
 									if (!didApprove) {
+										await this.saveCheckpoint()
 										break
 									}
 								}
@@ -2848,7 +2882,7 @@ export class Task {
 							}
 						} catch (error) {
 							await handleError("executing MCP tool", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2876,13 +2910,13 @@ export class Task {
 								if (!server_name) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("access_mcp_resource", "server_name"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								if (!uri) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("access_mcp_resource", "uri"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -2903,6 +2937,7 @@ export class Task {
 									this.removeLastPartialMessageIfExistsWithType("say", "use_mcp_server")
 									const didApprove = await askApproval("use_mcp_server", completeMessage)
 									if (!didApprove) {
+										await this.saveCheckpoint()
 										break
 									}
 								}
@@ -2922,12 +2957,12 @@ export class Task {
 										.join("\n\n") || "(Empty response)"
 								await this.say("mcp_server_response", resourceResultPretty)
 								pushToolResult(formatResponse.toolResult(resourceResultPretty))
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("accessing MCP resource", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -2946,7 +2981,7 @@ export class Task {
 								if (!question) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("ask_followup_question", "question"))
-
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -2983,12 +3018,12 @@ export class Task {
 								}
 
 								pushToolResult(formatResponse.toolResult(`<answer>\n${text}\n</answer>`, images))
-
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("asking question", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -3002,6 +3037,7 @@ export class Task {
 								if (!context) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("new_task", "context"))
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -3030,10 +3066,12 @@ export class Task {
 										formatResponse.toolResult(`The user has created a new task with the provided context.`),
 									)
 								}
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("creating new task", error)
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -3047,6 +3085,7 @@ export class Task {
 								if (!context) {
 									this.consecutiveMistakeCount++
 									pushToolResult(await this.sayAndCreateMissingParamError("condense", "context"))
+									await this.saveCheckpoint()
 									break
 								}
 								this.consecutiveMistakeCount = 0
@@ -3089,10 +3128,12 @@ export class Task {
 										await ensureTaskDirectoryExists(this.getContext(), this.taskId),
 									)
 								}
+								await this.saveCheckpoint()
 								break
 							}
 						} catch (error) {
 							await handleError("condensing context window", error)
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -3153,6 +3194,7 @@ export class Task {
 									if (text || images?.length) {
 										telemetryService.captureOptionsIgnored(this.taskId, options.length, "plan")
 										await this.say("user_feedback", text ?? "", images)
+										await this.saveCheckpoint()
 									}
 								}
 
@@ -3299,12 +3341,14 @@ export class Task {
 									// complete command message
 									const didApprove = await askApproval("command", command)
 									if (!didApprove) {
+										await this.saveCheckpoint()
 										break
 									}
 									const [userRejected, execCommandResult] = await this.executeCommandTool(command!)
 									if (userRejected) {
 										this.didRejectTool = true
 										pushToolResult(execCommandResult)
+										await this.saveCheckpoint()
 										break
 									}
 									// user didn't reject, but the command may have output
@@ -3323,6 +3367,7 @@ export class Task {
 									break
 								}
 								await this.say("user_feedback", text ?? "", images)
+								await this.saveCheckpoint()
 
 								const toolResults: (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[] = []
 								if (commandResult) {
@@ -3351,7 +3396,7 @@ export class Task {
 							}
 						} catch (error) {
 							await handleError("attempting completion", error)
-
+							await this.saveCheckpoint()
 							break
 						}
 					}
@@ -3453,9 +3498,6 @@ export class Task {
 
 		// Save checkpoint if this is the first API request
 		const isFirstRequest = this.clineMessages.filter((m) => m.say === "api_req_started").length === 0
-		if (isFirstRequest) {
-			await this.say("checkpoint_created") // no hash since we need to wait for CheckpointTracker to be initialized
-		}
 
 		// getting verbose details is an expensive operation, it uses globby to top-down build file structure of project which for large projects can take a few seconds
 		// for the best UX we show a placeholder api_req_started message with a loading spinner as this happens
@@ -3466,6 +3508,10 @@ export class Task {
 			}),
 		)
 
+		if (isFirstRequest) {
+			await this.say("checkpoint_created") // no hash since we need to wait for CheckpointTracker to be initialized
+		}
+
 		// use this opportunity to initialize the checkpoint tracker (can be expensive to initialize in the constructor)
 		// FIXME: right now we're letting users init checkpoints for old tasks, but this could be a problem if opening a task in the wrong workspace
 		// isNewTask &&

src/core/webview/index.ts

@@ -181,6 +181,14 @@ export class WebviewProvider implements vscode.WebviewViewProvider {
 			"codicon.css",
 		])
 
+		const katexCssUri = getUri(webview, this.context.extensionUri, [
+			"webview-ui",
+			"node_modules",
+			"katex",
+			"dist",
+			"katex.min.css",
+		])
+
 		// const scriptUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, "assets", "main.js"))
 
 		// const styleResetUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, "assets", "reset.css"))
@@ -204,24 +212,25 @@ export class WebviewProvider implements vscode.WebviewViewProvider {
 
 		// Tip: Install the es6-string-html VS Code extension to enable code highlighting below
 		return /*html*/ `
-        <!DOCTYPE html>
-        <html lang="en">
-          <head>
-            <meta charset="utf-8">
-            <meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
-            <meta name="theme-color" content="#000000">
-            <link rel="stylesheet" type="text/css" href="${stylesUri}">
-            <link href="${codiconsUri}" rel="stylesheet" />
-						<meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src https://*.posthog.com https://*.firebaseauth.com https://*.firebaseio.com https://*.googleapis.com https://*.firebase.com; font-src ${webview.cspSource}; style-src ${webview.cspSource} 'unsafe-inline'; img-src ${webview.cspSource} https: data:; script-src 'nonce-${nonce}' 'unsafe-eval';">
-            <title>Cline</title>
-          </head>
-          <body>
-            <noscript>You need to enable JavaScript to run this app.</noscript>
-            <div id="root"></div>
-            <script type="module" nonce="${nonce}" src="${scriptUri}"></script>
-          </body>
-        </html>
-      `
+			<!DOCTYPE html>
+			<html lang="en">
+				<head>
+				<meta charset="utf-8">
+				<meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no">
+				<meta name="theme-color" content="#000000">
+				<link rel="stylesheet" type="text/css" href="${stylesUri}">
+				<link href="${codiconsUri}" rel="stylesheet" />
+				<link href="${katexCssUri}" rel="stylesheet" />
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src https://*.posthog.com https://*.firebaseauth.com https://*.firebaseio.com https://*.googleapis.com https://*.firebase.com; font-src ${webview.cspSource} data:; style-src ${webview.cspSource} 'unsafe-inline'; img-src ${webview.cspSource} https: data:; script-src 'nonce-${nonce}' 'unsafe-eval';">
+				<title>Cline</title>
+			</head>
+			<body>
+				<noscript>You need to enable JavaScript to run this app.</noscript>
+				<div id="root"></div>
+				<script type="module" nonce="${nonce}" src="${scriptUri}"></script>
+			</body>
+		</html>
+		`
 	}
 
 	/**
@@ -256,6 +265,15 @@ export class WebviewProvider implements vscode.WebviewViewProvider {
 			"codicon.css",
 		])
 
+		// Get KaTeX resources
+		const katexCssUri = getUri(webview, this.context.extensionUri, [
+			"webview-ui",
+			"node_modules",
+			"katex",
+			"dist",
+			"katex.min.css",
+		])
+
 		const scriptEntrypoint = "src/main.tsx"
 		const scriptUri = `http://${localServerUrl}/${scriptEntrypoint}`
 
@@ -271,7 +289,7 @@ export class WebviewProvider implements vscode.WebviewViewProvider {
 
 		const csp = [
 			"default-src 'none'",
-			`font-src ${webview.cspSource}`,
+			`font-src ${webview.cspSource} data:`,
 			`style-src ${webview.cspSource} 'unsafe-inline' https://* http://${localServerUrl} http://0.0.0.0:${localPort}`,
 			`img-src ${webview.cspSource} https: data:`,
 			`script-src 'unsafe-eval' https://* http://${localServerUrl} http://0.0.0.0:${localPort} 'nonce-${nonce}'`,
@@ -287,6 +305,7 @@ export class WebviewProvider implements vscode.WebviewViewProvider {
 					<meta http-equiv="Content-Security-Policy" content="${csp.join("; ")}">
 					<link rel="stylesheet" type="text/css" href="${stylesUri}">
 					<link href="${codiconsUri}" rel="stylesheet" />
+					<link href="${katexCssUri}" rel="stylesheet" />
 					<title>Cline</title>
 				</head>
 				<body>

src/integrations/misc/link-preview.ts

@@ -87,7 +87,7 @@ export async function fetchOpenGraphData(url: string): Promise<OpenGraphData> {
  * @param url The URL to check
  * @returns Promise resolving to boolean indicating if the URL is an image
  */
-export async function isImageUrl(url: string): Promise<boolean> {
+export async function detectImageUrl(url: string): Promise<boolean> {
 	try {
 		const response = await axios.head(url, {
 			headers: {

src/integrations/notifications/index.ts

@@ -74,7 +74,7 @@ export async function showSystemNotification(options: NotificationOptions): Prom
 		const escapedOptions = {
 			...options,
 			title: title.replace(/"/g, '\\"'),
-			message: message.replace(/"/g, '\\"'),
+			message: message.replace(/\\/g, "\\\\").replace(/"/g, '\\"'),
 			subtitle: options.subtitle?.replace(/"/g, '\\"') || "",
 		}
 

src/packages/execa.ts

@@ -0,0 +1 @@
+export { execa } from "execa"

src/services/telemetry/TelemetryService.ts

@@ -4,6 +4,7 @@ import { version as extensionVersion } from "../../../package.json"
 
 import type { TaskFeedbackType } from "@shared/WebviewMessage"
 import type { BrowserSettings } from "@shared/BrowserSettings"
+import { posthogConfig } from "@/shared/services/config/posthog-config"
 
 /**
  * PostHogClient handles telemetry event tracking for the Cline extension
@@ -93,8 +94,8 @@ class PostHogClient {
 	 * Initializes PostHog client with configuration
 	 */
 	private constructor() {
-		this.client = new PostHog("phc_qfOAGxZw2TL5O8p9KYd9ak3bPBFzfjC8fy5L6jNWY7K", {
-			host: "https://us.i.posthog.com",
+		this.client = new PostHog(posthogConfig.apiKey, {
+			host: posthogConfig.host,
 			enableExceptionAutocapture: false,
 		})
 	}

src/shared/ExtensionMessage.ts

@@ -35,7 +35,6 @@ export interface ExtensionMessage {
 		| "mcpDownloadDetails"
 		| "commitSearchResults"
 		| "openGraphData"
-		| "isImageUrlResult"
 		| "didUpdateSettings"
 		| "userCreditsBalance"
 		| "userCreditsUsage"
@@ -143,6 +142,8 @@ export interface ExtensionState {
 	vscMachineId: string
 	globalClineRulesToggles: ClineRulesToggles
 	localClineRulesToggles: ClineRulesToggles
+	localCursorRulesToggles: ClineRulesToggles
+	localWindsurfRulesToggles: ClineRulesToggles
 }
 
 export interface ClineMessage {

src/shared/WebviewMessage.ts

@@ -18,13 +18,12 @@ export interface WebviewMessage {
 		| "selectImages"
 		| "exportCurrentTask"
 		| "showTaskWithId"
-		| "deleteTaskWithId"
+		| "deleteTasksWithIds"
 		| "exportTaskWithId"
 		| "resetState"
 		| "requestOllamaModels"
 		| "requestLmStudioModels"
 		| "openInBrowser"
-		| "createRuleFile"
 		| "openMention"
 		| "showChatView"
 		| "refreshOpenRouterModels"
@@ -54,7 +53,6 @@ export interface WebviewMessage {
 		| "telemetrySetting"
 		| "openSettings"
 		| "fetchOpenGraphData"
-		| "checkIsImageUrl"
 		| "invoke"
 		| "updateSettings"
 		| "clearAllTaskHistory"
@@ -69,6 +67,8 @@ export interface WebviewMessage {
 		| "toggleFavoriteModel"
 		| "grpc_request"
 		| "toggleClineRule"
+		| "toggleCursorRule"
+		| "toggleWindsurfRule"
 		| "deleteClineRule"
 		| "copyToClipboard"
 		| "updateTerminalConnectionTimeout"

src/shared/api.ts

@@ -47,6 +47,8 @@ export interface ApiHandlerOptions {
 	awsUseProfile?: boolean
 	awsProfile?: string
 	awsBedrockEndpoint?: string
+	awsBedrockCustomSelected?: boolean
+	awsBedrockCustomModelBaseId?: BedrockModelId
 	vertexProjectId?: string
 	vertexRegion?: string
 	openAiBaseUrl?: string
@@ -101,9 +103,7 @@ export interface ModelInfo {
 	supportsImages?: boolean
 	supportsPromptCache: boolean // this value is hardcoded for now
 	inputPrice?: number // Keep for non-tiered input models
-	inputPriceTiers?: PriceTier[] // Add for tiered input pricing
 	outputPrice?: number // Keep for non-tiered output models
-	outputPriceTiers?: PriceTier[] // Add for tiered output pricing
 	thinkingConfig?: {
 		maxBudget?: number // Max allowed thinking budget tokens
 		outputPrice?: number // Output price per million tokens when budget > 0
@@ -112,6 +112,13 @@ export interface ModelInfo {
 	cacheWritesPrice?: number
 	cacheReadsPrice?: number
 	description?: string
+	tiers?: {
+		contextWindow: number
+		inputPrice?: number
+		outputPrice?: number
+		cacheWritesPrice?: number
+		cacheReadsPrice?: number
+	}[]
 }
 
 export interface OpenAiCompatibleModelInfo extends ModelInfo {
@@ -183,6 +190,15 @@ export const anthropicModels = {
 export type BedrockModelId = keyof typeof bedrockModels
 export const bedrockDefaultModelId: BedrockModelId = "anthropic.claude-3-7-sonnet-20250219-v1:0"
 export const bedrockModels = {
+	"amazon.nova-premier-v1:0": {
+		maxTokens: 10_000,
+		contextWindow: 1_000_000,
+		supportsImages: true,
+
+		supportsPromptCache: false,
+		inputPrice: 2.5,
+		outputPrice: 12.5,
+	},
 	"amazon.nova-pro-v1:0": {
 		maxTokens: 5000,
 		contextWindow: 300_000,
@@ -310,10 +326,15 @@ export const vertexModels = {
 		maxTokens: 8192,
 		contextWindow: 200_000,
 		supportsImages: true,
-
 		supportsPromptCache: true,
 		inputPrice: 3.0,
 		outputPrice: 15.0,
+		cacheWritesPrice: 3.75,
+		cacheReadsPrice: 0.3,
+		thinkingConfig: {
+			maxBudget: 64000,
+			outputPrice: 15.0,
+		},
 	},
 	"claude-3-5-sonnet-v2@20241022": {
 		maxTokens: 8192,
@@ -367,12 +388,22 @@ export const vertexModels = {
 		cacheReadsPrice: 0.03,
 	},
 	"gemini-2.0-flash-001": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 0.15,
+		outputPrice: 0.6,
+		cacheWritesPrice: 1.0,
+		cacheReadsPrice: 0.025,
+	},
+	"gemini-2.0-flash-lite-001": {
 		maxTokens: 8192,
 		contextWindow: 1_048_576,
 		supportsImages: true,
 		supportsPromptCache: false,
-		inputPrice: 0.1,
-		outputPrice: 0.4,
+		inputPrice: 0.075,
+		outputPrice: 0.3,
 	},
 	"gemini-2.0-flash-thinking-exp-1219": {
 		maxTokens: 8192,
@@ -402,16 +433,20 @@ export const vertexModels = {
 		maxTokens: 65536,
 		contextWindow: 1_048_576,
 		supportsImages: true,
-		supportsPromptCache: false,
-		// inputPrice: 1.25, // Removed
-		// outputPrice: 10, // Removed
-		inputPriceTiers: [
-			{ tokenLimit: 200000, price: 1.25 }, // Input price for <= 200k input tokens
-			{ tokenLimit: Infinity, price: 2.5 }, // Input price for > 200k input tokens
-		],
-		outputPriceTiers: [
-			{ tokenLimit: 200000, price: 10.0 }, // Output price for <= 200k input tokens
-			{ tokenLimit: Infinity, price: 15.0 }, // Output price for > 200k input tokens
+		supportsPromptCache: true,
+		inputPrice: 2.5,
+		outputPrice: 15,
+		tiers: [
+			{
+				contextWindow: 200000,
+				inputPrice: 1.25,
+				outputPrice: 10,
+			},
+			{
+				contextWindow: Infinity,
+				inputPrice: 2.5,
+				outputPrice: 15,
+			},
 		],
 	},
 	"gemini-2.5-flash-preview-04-17": {
@@ -446,9 +481,25 @@ export const vertexModels = {
 		maxTokens: 8192,
 		contextWindow: 1_048_576,
 		supportsImages: true,
-		supportsPromptCache: false,
-		inputPrice: 0,
-		outputPrice: 0,
+		supportsPromptCache: true,
+		inputPrice: 0.15,
+		outputPrice: 0.6,
+		cacheWritesPrice: 1.0,
+		cacheReadsPrice: 0.0375,
+		tiers: [
+			{
+				contextWindow: 128000,
+				inputPrice: 0.075,
+				outputPrice: 0.3,
+				cacheReadsPrice: 0.01875,
+			},
+			{
+				contextWindow: Infinity,
+				inputPrice: 0.15,
+				outputPrice: 0.6,
+				cacheReadsPrice: 0.0375,
+			},
+		],
 	},
 	"gemini-1.5-flash-exp-0827": {
 		maxTokens: 8192,
@@ -471,8 +522,8 @@ export const vertexModels = {
 		contextWindow: 2_097_152,
 		supportsImages: true,
 		supportsPromptCache: false,
-		inputPrice: 0,
-		outputPrice: 0,
+		inputPrice: 1.25,
+		outputPrice: 5,
 	},
 	"gemini-1.5-pro-exp-0827": {
 		maxTokens: 8192,
@@ -512,14 +563,24 @@ export const geminiModels = {
 		maxTokens: 65536,
 		contextWindow: 1_048_576,
 		supportsImages: true,
-		supportsPromptCache: false,
-		inputPriceTiers: [
-			{ tokenLimit: 200000, price: 1.25 }, // Input price for <= 200k input tokens
-			{ tokenLimit: Infinity, price: 2.5 }, // Input price for > 200k input tokens
-		],
-		outputPriceTiers: [
-			{ tokenLimit: 200000, price: 10.0 }, // Output price for <= 200k input tokens
-			{ tokenLimit: Infinity, price: 15.0 }, // Output price for > 200k input tokens
+		supportsPromptCache: true,
+		inputPrice: 2.5, // Default price (highest tier)
+		outputPrice: 15, // Default price (highest tier)
+		cacheReadsPrice: 0.625,
+		cacheWritesPrice: 4.5,
+		tiers: [
+			{
+				contextWindow: 200000,
+				inputPrice: 1.25,
+				outputPrice: 10,
+				cacheReadsPrice: 0.31,
+			},
+			{
+				contextWindow: Infinity,
+				inputPrice: 2.5,
+				outputPrice: 15,
+				cacheReadsPrice: 0.625,
+			},
 		],
 	},
 	"gemini-2.5-flash-preview-04-17": {
@@ -538,9 +599,11 @@ export const geminiModels = {
 		maxTokens: 8192,
 		contextWindow: 1_048_576,
 		supportsImages: true,
-		supportsPromptCache: false,
-		inputPrice: 0,
-		outputPrice: 0,
+		supportsPromptCache: true,
+		inputPrice: 0.1,
+		outputPrice: 0.4,
+		cacheReadsPrice: 0.025,
+		cacheWritesPrice: 1.0,
 	},
 	"gemini-2.0-flash-lite-preview-02-05": {
 		maxTokens: 8192,
@@ -586,9 +649,25 @@ export const geminiModels = {
 		maxTokens: 8192,
 		contextWindow: 1_048_576,
 		supportsImages: true,
-		supportsPromptCache: false,
-		inputPrice: 0,
-		outputPrice: 0,
+		supportsPromptCache: true,
+		inputPrice: 0.15, // Default price (highest tier)
+		outputPrice: 0.6, // Default price (highest tier)
+		cacheReadsPrice: 0.0375,
+		cacheWritesPrice: 1.0,
+		tiers: [
+			{
+				contextWindow: 128000,
+				inputPrice: 0.075,
+				outputPrice: 0.3,
+				cacheReadsPrice: 0.01875,
+			},
+			{
+				contextWindow: Infinity,
+				inputPrice: 0.15,
+				outputPrice: 0.6,
+				cacheReadsPrice: 0.0375,
+			},
+		],
 	},
 	"gemini-1.5-flash-exp-0827": {
 		maxTokens: 8192,

src/shared/proto-conversions/file.ts

@@ -0,0 +1,27 @@
+import { RuleFileRequest } from "../proto/file"
+
+/**
+ * Simplified clean interface for RuleFile requests
+ */
+
+// Helper for creating delete requests
+export const DeleteRuleFileRequest = {
+	create: (params: { rulePath: string; isGlobal: boolean; metadata?: any }): RuleFileRequest => {
+		return RuleFileRequest.create({
+			rulePath: params.rulePath,
+			isGlobal: params.isGlobal,
+			metadata: params.metadata,
+		})
+	},
+}
+
+// Helper for creating create requests
+export const CreateRuleFileRequest = {
+	create: (params: { filename: string; isGlobal: boolean; metadata?: any }): RuleFileRequest => {
+		return RuleFileRequest.create({
+			filename: params.filename,
+			isGlobal: params.isGlobal,
+			metadata: params.metadata,
+		})
+	},
+}

src/shared/proto-conversions/file/git-commit-conversion.ts

@@ -0,0 +1,28 @@
+import { GitCommit as ProtoGitCommit } from "@shared/proto/file"
+import { GitCommit } from "@utils/git"
+
+/**
+ * Converts domain GitCommit objects to proto GitCommit objects
+ */
+export function convertGitCommitsToProtoGitCommits(commits: GitCommit[]): ProtoGitCommit[] {
+	return commits.map((commit) => ({
+		hash: commit.hash,
+		shortHash: commit.shortHash,
+		subject: commit.subject,
+		author: commit.author,
+		date: commit.date,
+	}))
+}
+
+/**
+ * Converts proto GitCommit objects to domain GitCommit objects
+ */
+export function convertProtoGitCommitsToGitCommits(protoCommits: ProtoGitCommit[]): GitCommit[] {
+	return protoCommits.map((protoCommit) => ({
+		hash: protoCommit.hash,
+		shortHash: protoCommit.shortHash,
+		subject: protoCommit.subject,
+		author: protoCommit.author,
+		date: protoCommit.date,
+	}))
+}

src/shared/proto-conversions/index.ts

@@ -0,0 +1 @@
+export * from "./file"

src/shared/proto/file.ts

@@ -5,10 +5,431 @@
 // source: file.proto
 
 /* eslint-disable */
-import { Empty, StringRequest } from "./common"
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"
+import { Empty, Metadata, StringRequest } from "./common"
 
 export const protobufPackage = "cline"
 
+/** Response for searchCommits */
+export interface GitCommits {
+	commits: GitCommit[]
+}
+
+/** Represents a Git commit */
+export interface GitCommit {
+	hash: string
+	shortHash: string
+	subject: string
+	author: string
+	date: string
+}
+
+/** Unified request for all rule file operations */
+export interface RuleFileRequest {
+	metadata?: Metadata | undefined
+	/** Common field for all operations */
+	isGlobal: boolean
+	/** Path field for deleteRuleFile (optional) */
+	rulePath?: string | undefined
+	/** Filename field for createRuleFile (optional) */
+	filename?: string | undefined
+}
+
+/** Result for rule file operations with meaningful data only */
+export interface RuleFile {
+	/** Path to the rule file */
+	filePath: string
+	/** Filename for display purposes */
+	displayName: string
+	/** For createRuleFile, indicates if file already existed */
+	alreadyExists: boolean
+}
+
+function createBaseGitCommits(): GitCommits {
+	return { commits: [] }
+}
+
+export const GitCommits: MessageFns<GitCommits> = {
+	encode(message: GitCommits, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+		for (const v of message.commits) {
+			GitCommit.encode(v!, writer.uint32(10).fork()).join()
+		}
+		return writer
+	},
+
+	decode(input: BinaryReader | Uint8Array, length?: number): GitCommits {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input)
+		let end = length === undefined ? reader.len : reader.pos + length
+		const message = createBaseGitCommits()
+		while (reader.pos < end) {
+			const tag = reader.uint32()
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) {
+						break
+					}
+
+					message.commits.push(GitCommit.decode(reader, reader.uint32()))
+					continue
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) {
+				break
+			}
+			reader.skip(tag & 7)
+		}
+		return message
+	},
+
+	fromJSON(object: any): GitCommits {
+		return {
+			commits: globalThis.Array.isArray(object?.commits) ? object.commits.map((e: any) => GitCommit.fromJSON(e)) : [],
+		}
+	},
+
+	toJSON(message: GitCommits): unknown {
+		const obj: any = {}
+		if (message.commits?.length) {
+			obj.commits = message.commits.map((e) => GitCommit.toJSON(e))
+		}
+		return obj
+	},
+
+	create<I extends Exact<DeepPartial<GitCommits>, I>>(base?: I): GitCommits {
+		return GitCommits.fromPartial(base ?? ({} as any))
+	},
+	fromPartial<I extends Exact<DeepPartial<GitCommits>, I>>(object: I): GitCommits {
+		const message = createBaseGitCommits()
+		message.commits = object.commits?.map((e) => GitCommit.fromPartial(e)) || []
+		return message
+	},
+}
+
+function createBaseGitCommit(): GitCommit {
+	return { hash: "", shortHash: "", subject: "", author: "", date: "" }
+}
+
+export const GitCommit: MessageFns<GitCommit> = {
+	encode(message: GitCommit, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+		if (message.hash !== "") {
+			writer.uint32(10).string(message.hash)
+		}
+		if (message.shortHash !== "") {
+			writer.uint32(18).string(message.shortHash)
+		}
+		if (message.subject !== "") {
+			writer.uint32(26).string(message.subject)
+		}
+		if (message.author !== "") {
+			writer.uint32(34).string(message.author)
+		}
+		if (message.date !== "") {
+			writer.uint32(42).string(message.date)
+		}
+		return writer
+	},
+
+	decode(input: BinaryReader | Uint8Array, length?: number): GitCommit {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input)
+		let end = length === undefined ? reader.len : reader.pos + length
+		const message = createBaseGitCommit()
+		while (reader.pos < end) {
+			const tag = reader.uint32()
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) {
+						break
+					}
+
+					message.hash = reader.string()
+					continue
+				}
+				case 2: {
+					if (tag !== 18) {
+						break
+					}
+
+					message.shortHash = reader.string()
+					continue
+				}
+				case 3: {
+					if (tag !== 26) {
+						break
+					}
+
+					message.subject = reader.string()
+					continue
+				}
+				case 4: {
+					if (tag !== 34) {
+						break
+					}
+
+					message.author = reader.string()
+					continue
+				}
+				case 5: {
+					if (tag !== 42) {
+						break
+					}
+
+					message.date = reader.string()
+					continue
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) {
+				break
+			}
+			reader.skip(tag & 7)
+		}
+		return message
+	},
+
+	fromJSON(object: any): GitCommit {
+		return {
+			hash: isSet(object.hash) ? globalThis.String(object.hash) : "",
+			shortHash: isSet(object.shortHash) ? globalThis.String(object.shortHash) : "",
+			subject: isSet(object.subject) ? globalThis.String(object.subject) : "",
+			author: isSet(object.author) ? globalThis.String(object.author) : "",
+			date: isSet(object.date) ? globalThis.String(object.date) : "",
+		}
+	},
+
+	toJSON(message: GitCommit): unknown {
+		const obj: any = {}
+		if (message.hash !== "") {
+			obj.hash = message.hash
+		}
+		if (message.shortHash !== "") {
+			obj.shortHash = message.shortHash
+		}
+		if (message.subject !== "") {
+			obj.subject = message.subject
+		}
+		if (message.author !== "") {
+			obj.author = message.author
+		}
+		if (message.date !== "") {
+			obj.date = message.date
+		}
+		return obj
+	},
+
+	create<I extends Exact<DeepPartial<GitCommit>, I>>(base?: I): GitCommit {
+		return GitCommit.fromPartial(base ?? ({} as any))
+	},
+	fromPartial<I extends Exact<DeepPartial<GitCommit>, I>>(object: I): GitCommit {
+		const message = createBaseGitCommit()
+		message.hash = object.hash ?? ""
+		message.shortHash = object.shortHash ?? ""
+		message.subject = object.subject ?? ""
+		message.author = object.author ?? ""
+		message.date = object.date ?? ""
+		return message
+	},
+}
+
+function createBaseRuleFileRequest(): RuleFileRequest {
+	return { metadata: undefined, isGlobal: false, rulePath: undefined, filename: undefined }
+}
+
+export const RuleFileRequest: MessageFns<RuleFileRequest> = {
+	encode(message: RuleFileRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+		if (message.metadata !== undefined) {
+			Metadata.encode(message.metadata, writer.uint32(10).fork()).join()
+		}
+		if (message.isGlobal !== false) {
+			writer.uint32(16).bool(message.isGlobal)
+		}
+		if (message.rulePath !== undefined) {
+			writer.uint32(26).string(message.rulePath)
+		}
+		if (message.filename !== undefined) {
+			writer.uint32(34).string(message.filename)
+		}
+		return writer
+	},
+
+	decode(input: BinaryReader | Uint8Array, length?: number): RuleFileRequest {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input)
+		let end = length === undefined ? reader.len : reader.pos + length
+		const message = createBaseRuleFileRequest()
+		while (reader.pos < end) {
+			const tag = reader.uint32()
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) {
+						break
+					}
+
+					message.metadata = Metadata.decode(reader, reader.uint32())
+					continue
+				}
+				case 2: {
+					if (tag !== 16) {
+						break
+					}
+
+					message.isGlobal = reader.bool()
+					continue
+				}
+				case 3: {
+					if (tag !== 26) {
+						break
+					}
+
+					message.rulePath = reader.string()
+					continue
+				}
+				case 4: {
+					if (tag !== 34) {
+						break
+					}
+
+					message.filename = reader.string()
+					continue
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) {
+				break
+			}
+			reader.skip(tag & 7)
+		}
+		return message
+	},
+
+	fromJSON(object: any): RuleFileRequest {
+		return {
+			metadata: isSet(object.metadata) ? Metadata.fromJSON(object.metadata) : undefined,
+			isGlobal: isSet(object.isGlobal) ? globalThis.Boolean(object.isGlobal) : false,
+			rulePath: isSet(object.rulePath) ? globalThis.String(object.rulePath) : undefined,
+			filename: isSet(object.filename) ? globalThis.String(object.filename) : undefined,
+		}
+	},
+
+	toJSON(message: RuleFileRequest): unknown {
+		const obj: any = {}
+		if (message.metadata !== undefined) {
+			obj.metadata = Metadata.toJSON(message.metadata)
+		}
+		if (message.isGlobal !== false) {
+			obj.isGlobal = message.isGlobal
+		}
+		if (message.rulePath !== undefined) {
+			obj.rulePath = message.rulePath
+		}
+		if (message.filename !== undefined) {
+			obj.filename = message.filename
+		}
+		return obj
+	},
+
+	create<I extends Exact<DeepPartial<RuleFileRequest>, I>>(base?: I): RuleFileRequest {
+		return RuleFileRequest.fromPartial(base ?? ({} as any))
+	},
+	fromPartial<I extends Exact<DeepPartial<RuleFileRequest>, I>>(object: I): RuleFileRequest {
+		const message = createBaseRuleFileRequest()
+		message.metadata =
+			object.metadata !== undefined && object.metadata !== null ? Metadata.fromPartial(object.metadata) : undefined
+		message.isGlobal = object.isGlobal ?? false
+		message.rulePath = object.rulePath ?? undefined
+		message.filename = object.filename ?? undefined
+		return message
+	},
+}
+
+function createBaseRuleFile(): RuleFile {
+	return { filePath: "", displayName: "", alreadyExists: false }
+}
+
+export const RuleFile: MessageFns<RuleFile> = {
+	encode(message: RuleFile, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+		if (message.filePath !== "") {
+			writer.uint32(10).string(message.filePath)
+		}
+		if (message.displayName !== "") {
+			writer.uint32(18).string(message.displayName)
+		}
+		if (message.alreadyExists !== false) {
+			writer.uint32(24).bool(message.alreadyExists)
+		}
+		return writer
+	},
+
+	decode(input: BinaryReader | Uint8Array, length?: number): RuleFile {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input)
+		let end = length === undefined ? reader.len : reader.pos + length
+		const message = createBaseRuleFile()
+		while (reader.pos < end) {
+			const tag = reader.uint32()
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 10) {
+						break
+					}
+
+					message.filePath = reader.string()
+					continue
+				}
+				case 2: {
+					if (tag !== 18) {
+						break
+					}
+
+					message.displayName = reader.string()
+					continue
+				}
+				case 3: {
+					if (tag !== 24) {
+						break
+					}
+
+					message.alreadyExists = reader.bool()
+					continue
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) {
+				break
+			}
+			reader.skip(tag & 7)
+		}
+		return message
+	},
+
+	fromJSON(object: any): RuleFile {
+		return {
+			filePath: isSet(object.filePath) ? globalThis.String(object.filePath) : "",
+			displayName: isSet(object.displayName) ? globalThis.String(object.displayName) : "",
+			alreadyExists: isSet(object.alreadyExists) ? globalThis.Boolean(object.alreadyExists) : false,
+		}
+	},
+
+	toJSON(message: RuleFile): unknown {
+		const obj: any = {}
+		if (message.filePath !== "") {
+			obj.filePath = message.filePath
+		}
+		if (message.displayName !== "") {
+			obj.displayName = message.displayName
+		}
+		if (message.alreadyExists !== false) {
+			obj.alreadyExists = message.alreadyExists
+		}
+		return obj
+	},
+
+	create<I extends Exact<DeepPartial<RuleFile>, I>>(base?: I): RuleFile {
+		return RuleFile.fromPartial(base ?? ({} as any))
+	},
+	fromPartial<I extends Exact<DeepPartial<RuleFile>, I>>(object: I): RuleFile {
+		const message = createBaseRuleFile()
+		message.filePath = object.filePath ?? ""
+		message.displayName = object.displayName ?? ""
+		message.alreadyExists = object.alreadyExists ?? false
+		return message
+	},
+}
+
 /** Service for file-related operations */
 export type FileServiceDefinition = typeof FileServiceDefinition
 export const FileServiceDefinition = {
@@ -33,5 +454,62 @@ export const FileServiceDefinition = {
 			responseStream: false,
 			options: {},
 		},
+		/** Deletes a rule file from either global or workspace rules directory */
+		deleteRuleFile: {
+			name: "deleteRuleFile",
+			requestType: RuleFileRequest,
+			requestStream: false,
+			responseType: RuleFile,
+			responseStream: false,
+			options: {},
+		},
+		/** Creates a rule file from either global or workspace rules directory */
+		createRuleFile: {
+			name: "createRuleFile",
+			requestType: RuleFileRequest,
+			requestStream: false,
+			responseType: RuleFile,
+			responseStream: false,
+			options: {},
+		},
+		/** Search git commits in the workspace */
+		searchCommits: {
+			name: "searchCommits",
+			requestType: StringRequest,
+			requestStream: false,
+			responseType: GitCommits,
+			responseStream: false,
+			options: {},
+		},
 	},
 } as const
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined
+
+export type DeepPartial<T> = T extends Builtin
+	? T
+	: T extends globalThis.Array<infer U>
+		? globalThis.Array<DeepPartial<U>>
+		: T extends ReadonlyArray<infer U>
+			? ReadonlyArray<DeepPartial<U>>
+			: T extends {}
+				? { [K in keyof T]?: DeepPartial<T[K]> }
+				: Partial<T>
+
+type KeysOfUnion<T> = T extends T ? keyof T : never
+export type Exact<P, I extends P> = P extends Builtin
+	? P
+	: P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never }
+
+function isSet(value: any): boolean {
+	return value !== null && value !== undefined
+}
+
+export interface MessageFns<T> {
+	encode(message: T, writer?: BinaryWriter): BinaryWriter
+	decode(input: BinaryReader | Uint8Array, length?: number): T
+	fromJSON(object: any): T
+	toJSON(message: T): unknown
+	create<I extends Exact<DeepPartial<T>, I>>(base?: I): T
+	fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T
+}

src/shared/proto/web_content.ts

@@ -0,0 +1,138 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.7.0
+//   protoc               v3.19.1
+// source: web_content.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"
+import { StringRequest } from "./common"
+
+export const protobufPackage = "cline"
+
+export interface IsImageUrl {
+	isImage: boolean
+	url: string
+}
+
+function createBaseIsImageUrl(): IsImageUrl {
+	return { isImage: false, url: "" }
+}
+
+export const IsImageUrl: MessageFns<IsImageUrl> = {
+	encode(message: IsImageUrl, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+		if (message.isImage !== false) {
+			writer.uint32(8).bool(message.isImage)
+		}
+		if (message.url !== "") {
+			writer.uint32(18).string(message.url)
+		}
+		return writer
+	},
+
+	decode(input: BinaryReader | Uint8Array, length?: number): IsImageUrl {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input)
+		let end = length === undefined ? reader.len : reader.pos + length
+		const message = createBaseIsImageUrl()
+		while (reader.pos < end) {
+			const tag = reader.uint32()
+			switch (tag >>> 3) {
+				case 1: {
+					if (tag !== 8) {
+						break
+					}
+
+					message.isImage = reader.bool()
+					continue
+				}
+				case 2: {
+					if (tag !== 18) {
+						break
+					}
+
+					message.url = reader.string()
+					continue
+				}
+			}
+			if ((tag & 7) === 4 || tag === 0) {
+				break
+			}
+			reader.skip(tag & 7)
+		}
+		return message
+	},
+
+	fromJSON(object: any): IsImageUrl {
+		return {
+			isImage: isSet(object.isImage) ? globalThis.Boolean(object.isImage) : false,
+			url: isSet(object.url) ? globalThis.String(object.url) : "",
+		}
+	},
+
+	toJSON(message: IsImageUrl): unknown {
+		const obj: any = {}
+		if (message.isImage !== false) {
+			obj.isImage = message.isImage
+		}
+		if (message.url !== "") {
+			obj.url = message.url
+		}
+		return obj
+	},
+
+	create<I extends Exact<DeepPartial<IsImageUrl>, I>>(base?: I): IsImageUrl {
+		return IsImageUrl.fromPartial(base ?? ({} as any))
+	},
+	fromPartial<I extends Exact<DeepPartial<IsImageUrl>, I>>(object: I): IsImageUrl {
+		const message = createBaseIsImageUrl()
+		message.isImage = object.isImage ?? false
+		message.url = object.url ?? ""
+		return message
+	},
+}
+
+export type WebContentServiceDefinition = typeof WebContentServiceDefinition
+export const WebContentServiceDefinition = {
+	name: "WebContentService",
+	fullName: "cline.WebContentService",
+	methods: {
+		checkIsImageUrl: {
+			name: "checkIsImageUrl",
+			requestType: StringRequest,
+			requestStream: false,
+			responseType: IsImageUrl,
+			responseStream: false,
+			options: {},
+		},
+	},
+} as const
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined
+
+export type DeepPartial<T> = T extends Builtin
+	? T
+	: T extends globalThis.Array<infer U>
+		? globalThis.Array<DeepPartial<U>>
+		: T extends ReadonlyArray<infer U>
+			? ReadonlyArray<DeepPartial<U>>
+			: T extends {}
+				? { [K in keyof T]?: DeepPartial<T[K]> }
+				: Partial<T>
+
+type KeysOfUnion<T> = T extends T ? keyof T : never
+export type Exact<P, I extends P> = P extends Builtin
+	? P
+	: P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never }
+
+function isSet(value: any): boolean {
+	return value !== null && value !== undefined
+}
+
+export interface MessageFns<T> {
+	encode(message: T, writer?: BinaryWriter): BinaryWriter
+	decode(input: BinaryReader | Uint8Array, length?: number): T
+	fromJSON(object: any): T
+	toJSON(message: T): unknown
+	create<I extends Exact<DeepPartial<T>, I>>(base?: I): T
+	fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T
+}

src/shared/services/config/posthog-config.ts

@@ -0,0 +1,5 @@
+// Public PostHog key (safe for open source)
+export const posthogConfig = {
+	apiKey: "phc_qfOAGxZw2TL5O8p9KYd9ak3bPBFzfjC8fy5L6jNWY7K",
+	host: "https://us.i.posthog.com",
+}

src/shared/services/feature-flags/feature-flags.ts

@@ -0,0 +1,6 @@
+export const FEATURE_FLAGS = {
+	CUSTOM_INSTRUCTIONS: "custom-instructions",
+	// Further flags here
+} as const
+
+export type FeatureFlag = (typeof FEATURE_FLAGS)[keyof typeof FEATURE_FLAGS]

src/utils/cost.ts

@@ -11,51 +11,56 @@ function calculateApiCostInternal(
 ): number {
 	const usedThinkingBudget = thinkingBudgetTokens && thinkingBudgetTokens > 0
 
-	// Determine effective input price
+	// Default prices
 	let effectiveInputPrice = modelInfo.inputPrice || 0
-	if (modelInfo.inputPriceTiers && modelInfo.inputPriceTiers.length > 0 && totalInputTokensForPricing !== undefined) {
-		// Ensure tiers are sorted by tokenLimit ascending before finding
-		const sortedInputTiers = [...modelInfo.inputPriceTiers].sort((a, b) => a.tokenLimit - b.tokenLimit)
+	let effectiveOutputPrice = modelInfo.outputPrice || 0
+	let effectiveCacheReadsPrice = modelInfo.cacheReadsPrice || 0
+	let effectiveCacheWritesPrice = modelInfo.cacheWritesPrice || 0
+
+	// Handle tiered pricing if available
+	if (modelInfo.tiers && modelInfo.tiers.length > 0 && totalInputTokensForPricing !== undefined) {
+		// Ensure tiers are sorted by contextWindow ascending before finding
+		const sortedTiers = [...modelInfo.tiers].sort((a, b) => a.contextWindow - b.contextWindow)
+
 		// Find the first tier where the total input tokens are less than or equal to the limit
-		const tier = sortedInputTiers.find((t) => totalInputTokensForPricing! <= t.tokenLimit)
+		const tier = sortedTiers.find((t) => totalInputTokensForPricing <= t.contextWindow)
+
 		if (tier) {
-			effectiveInputPrice = tier.price
+			// Apply all tiered price values if they exist
+			effectiveInputPrice = tier.inputPrice ?? effectiveInputPrice
+			effectiveOutputPrice = tier.outputPrice ?? effectiveOutputPrice
+			effectiveCacheReadsPrice = tier.cacheReadsPrice ?? effectiveCacheReadsPrice
+			effectiveCacheWritesPrice = tier.cacheWritesPrice ?? effectiveCacheWritesPrice
 		} else {
 			// Should ideally not happen if Infinity is used for the last tier, but fallback just in case
-			effectiveInputPrice = sortedInputTiers[sortedInputTiers.length - 1]?.price || 0
+			const lastTier = sortedTiers[sortedTiers.length - 1]
+			if (lastTier) {
+				effectiveInputPrice = lastTier.inputPrice ?? effectiveInputPrice
+				effectiveOutputPrice = lastTier.outputPrice ?? effectiveOutputPrice
+				effectiveCacheReadsPrice = lastTier.cacheReadsPrice ?? effectiveCacheReadsPrice
+				effectiveCacheWritesPrice = lastTier.cacheWritesPrice ?? effectiveCacheWritesPrice
+			}
 		}
 	}
 
-	// Determine effective output price
-	let effectiveOutputPrice = modelInfo.outputPrice || 0
-	// Check if thinking budget was used and has a specific price
+	// Override output price for thinking mode if applicable
 	if (usedThinkingBudget && modelInfo.thinkingConfig?.outputPrice !== undefined) {
 		effectiveOutputPrice = modelInfo.thinkingConfig.outputPrice
 		// TODO: Add support for tiered thinking budget output pricing if needed in the future
-		// } else if (usedThinkingBudget && modelInfo.thinkingConfig?.outputPriceTiers) { ... }
-	} else if (modelInfo.outputPriceTiers && modelInfo.outputPriceTiers.length > 0 && totalInputTokensForPricing !== undefined) {
-		// Use standard tiered output pricing (based on total *input* tokens for pricing)
-		const sortedOutputTiers = [...modelInfo.outputPriceTiers].sort((a, b) => a.tokenLimit - b.tokenLimit)
-		const tier = sortedOutputTiers.find((t) => totalInputTokensForPricing! <= t.tokenLimit)
-		if (tier) {
-			effectiveOutputPrice = tier.price
-		} else {
-			// Should ideally not happen if Infinity is used for the last tier, but fallback just in case
-			effectiveOutputPrice = sortedOutputTiers[sortedOutputTiers.length - 1]?.price || 0
-		}
 	}
 
-	const cacheWritesCost = ((modelInfo.cacheWritesPrice || 0) / 1_000_000) * cacheCreationInputTokens
-	const cacheReadsCost = ((modelInfo.cacheReadsPrice || 0) / 1_000_000) * cacheReadInputTokens
+	const cacheWritesCost = (effectiveCacheWritesPrice / 1_000_000) * cacheCreationInputTokens
+	const cacheReadsCost = (effectiveCacheReadsPrice / 1_000_000) * cacheReadInputTokens
+
 	// Use effectiveInputPrice for baseInputCost. Note: 'inputTokens' here is the potentially adjusted count (e.g., non-cached for OpenAI)
 	const baseInputCost = (effectiveInputPrice / 1_000_000) * inputTokens
+
 	// Use effectiveOutputPrice for outputCost
 	const outputCost = (effectiveOutputPrice / 1_000_000) * outputTokens
 
 	const totalCost = cacheWritesCost + cacheReadsCost + baseInputCost + outputCost
 	return totalCost
 }
-
 // For Anthropic compliant usage, the input tokens count does NOT include the cached tokens
 export function calculateApiCostAnthropic(
 	modelInfo: ModelInfo,

src/utils/git.ts

@@ -30,6 +30,15 @@ async function checkGitInstalled(): Promise<boolean> {
 	}
 }
 
+async function checkGitRepoHasCommits(cwd: string): Promise<boolean> {
+	try {
+		await execAsync("git rev-parse HEAD", { cwd })
+		return true
+	} catch (error) {
+		return false
+	}
+}
+
 export async function searchCommits(query: string, cwd: string): Promise<GitCommit[]> {
 	try {
 		const isInstalled = await checkGitInstalled()
@@ -44,6 +53,12 @@ export async function searchCommits(query: string, cwd: string): Promise<GitComm
 			return []
 		}
 
+		// Check if repo has any commits
+		if (!(await checkGitRepoHasCommits(cwd))) {
+			// No commits yet in the repository
+			return []
+		}
+
 		// Search commits by hash or message, limiting to 10 results
 		const { stdout } = await execAsync(
 			`git log -n 10 --format="%H%n%h%n%s%n%an%n%ad" --date=short ` + `--grep="${query}" --regexp-ignore-case`,
@@ -100,6 +115,11 @@ export async function getCommitInfo(hash: string, cwd: string): Promise<string>
 			return "Not a git repository"
 		}
 
+		// Check if repo has any commits
+		if (!(await checkGitRepoHasCommits(cwd))) {
+			return "Repository has no commits yet"
+		}
+
 		// Get commit info, stats, and diff separately
 		const { stdout: info } = await execAsync(`git show --format="%H%n%h%n%s%n%an%n%ad%n%b" --no-patch ${hash}`, {
 			cwd,
@@ -147,8 +167,16 @@ export async function getWorkingState(cwd: string): Promise<string> {
 			return "No changes in working directory"
 		}
 
-		// Get all changes (both staged and unstaged) compared to HEAD
-		const { stdout: diff } = await execAsync("git diff HEAD", { cwd })
+		// Check if repo has any commits before trying to diff against HEAD
+		let diff = ""
+		if (await checkGitRepoHasCommits(cwd)) {
+			// Only run git diff if there are commits
+			const { stdout: diffOutput } = await execAsync("git diff HEAD", { cwd })
+			diff = diffOutput
+		} else {
+			// No commits yet, use status output only
+			return `Working directory changes (new repository):\n\n${status}`
+		}
 		const output = `Working directory changes:\n\n${status}\n\n${diff}`.trim()
 		return truncateOutput(output)
 	} catch (error) {

test-setup.js

@@ -0,0 +1,22 @@
+const tsConfigPaths = require("tsconfig-paths")
+const fs = require("fs")
+
+const tsConfig = JSON.parse(fs.readFileSync("./tsconfig.json", "utf-8"))
+
+/**
+ * The aliases point towards the `src` directory.
+ * However, `tsc` doesn't compile paths by itself
+ * (https://www.typescriptlang.org/docs/handbook/modules/reference.html#paths-does-not-affect-emit)
+ * So we need to use tsconfig-paths to resolve the aliases when running tests,
+ * but pointing to `out` instead.
+ */
+const outPaths = {}
+Object.keys(tsConfig.compilerOptions.paths).forEach((key) => {
+	const value = tsConfig.compilerOptions.paths[key]
+	outPaths[key] = value.map((path) => path.replace("src", "out"))
+})
+
+tsConfigPaths.register({
+	baseUrl: ".",
+	paths: outPaths,
+})