fix file that was touched mistakenly

.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/late-mice-double.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+gRPC over vscode message bus to make messaging better

.changeset/loud-spies-deny.md

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

.changeset/nasty-months-wave.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Add command to focus chat input

.changeset/pretty-eels-breathe.md

@@ -2,4 +2,4 @@
 "claude-dev": patch
 ---
 
-Add markdown copy to chat
+fix vertexai token count

.changeset/rare-starfishes-design.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Allow user to send context with an option selection

.changeset/replace-test-libraries.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Replace testing libraries with Vitest. Remove chai, sinon, should, and proxyquire in favor of Vitest's built-in testing utilities. Keep Mocha types for VSCode test runner compatibility. Use `__tests__` folder convention everywhere.

.changeset/serious-baboons-train.md

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

.changeset/six-hairs-rush.md

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

.changeset/ten-bananas-begin.md

@@ -2,4 +2,4 @@
 "claude-dev": patch
 ---
 
-fix cost calculation
+Readme update

.changeset/thirty-feet-rule.md

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

.changeset/twelve-eyes-teach.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Add OpenAI o3 & 4o-mini

.clinerules/cline-overview.md

@@ -8,8 +8,8 @@ Cline is a VSCode extension that provides AI assistance through a combination of
 
 ```mermaid
 graph TB
-    subgraph VSCodeExtensionHost[VSCode Extension Host]
-        subgraph CoreExtension[Core Extension]
+    subgraph VSCode Extension Host
+        subgraph Core Extension
             ExtensionEntry[Extension Entry<br/>src/extension.ts]
             WebviewProvider[WebviewProvider<br/>src/core/webview/index.ts]
             Controller[Controller<br/>src/core/controller/index.ts]
@@ -19,7 +19,7 @@ graph TB
             McpHub[McpHub<br/>src/services/mcp/McpHub.ts]
         end
 
-        subgraph WebviewUI[Webview UI]
+        subgraph Webview UI
             WebviewApp[React App<br/>webview-ui/src/App.tsx]
             ExtStateContext[ExtensionStateContext<br/>webview-ui/src/context/ExtensionStateContext.tsx]
             ReactComponents[React Components]
@@ -30,14 +30,14 @@ graph TB
             CheckpointSystem[Git-based Checkpoints]
         end
 
-        subgraph apiProviders[API Providers]
+        subgraph API Providers
             AnthropicAPI[Anthropic]
             OpenRouterAPI[OpenRouter]
             BedrockAPI[AWS Bedrock]
             OtherAPIs[Other Providers]
         end
 
-        subgraph MCPServers[MCP Servers]
+        subgraph MCP Servers
             ExternalMcpServers[External MCP Servers]
         end
     end
@@ -51,7 +51,7 @@ graph TB
     Task --> SecretsStorage
     Task --> TaskStorage
     Task --> CheckpointSystem
-    Task --> |API Requests| apiProviders
+    Task --> |API Requests| API Providers
     McpHub --> |Connects to| ExternalMcpServers
     Task --> |Uses| McpHub
 
@@ -67,7 +67,7 @@ graph TB
     style ExtStateContext fill:#bbf,stroke:#333,stroke-width:2px
     style WebviewProvider fill:#bfb,stroke:#333,stroke-width:2px
     style McpHub fill:#bfb,stroke:#333,stroke-width:2px
-    style apiProviders fill:#fdb,stroke:#333,stroke-width:2px
+    style API Providers fill:#fdb,stroke:#333,stroke-width:2px
 ```
 
 ## Definitions 

.codespellrc

@@ -1,6 +0,0 @@
-[codespell]
-# Ref: https://github.com/codespell-project/codespell#using-a-config-file
-skip = .git*,*.svg,package-lock.json,*.css,.codespellrc,locales
-check-hidden = true
-ignore-regex = (\b(optIn|isTaller)\b|https://\S+)
-# ignore-words-list =

.github/CODEOWNERS

@@ -1 +1 @@
-*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv @Garoth
+*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv

.github/workflows/codespell.yml

@@ -1,25 +0,0 @@
-# Codespell configuration is within .codespellrc
----
-name: Codespell
-
-on:
-    push:
-        branches: [main]
-    pull_request:
-        branches: [main]
-
-permissions:
-    contents: read
-
-jobs:
-    codespell:
-        name: Check for spelling errors
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-            - name: Annotate locations with typos
-              uses: codespell-project/codespell-problem-matcher@v1
-            - name: Codespell
-              uses: codespell-project/actions-codespell@v2

.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
-                        });
-                      }

.gitignore

@@ -17,5 +17,3 @@ pnpm-lock.yaml
 coverage
 # But don't ignore the coverage scripts in .github/scripts/
 !.github/scripts/coverage/
-
-*evals.env

.vscode/launch.json

@@ -12,11 +12,23 @@
 			"args": ["--extensionDevelopmentPath=${workspaceFolder}"],
 			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
 			"preLaunchTask": "${defaultBuildTask}",
-			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
 			}
+		},
+		{
+			"name": "Run Extension (Test Mode)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "${defaultBuildTask}",
+			"env": {
+				"IS_DEV": "true",
+				"IS_TEST": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+			}
 		}
 	]
 }

.vscode/tasks.json

@@ -3,26 +3,11 @@
 {
 	"version": "2.0.0",
 	"tasks": [
-		{
-			"label": "npm: protos",
-			"type": "npm",
-			"script": "protos",
-			"problemMatcher": [],
-			"isBackground": false,
-			"presentation": {
-				"reveal": "always"
-			},
-			"options": {
-				"env": {
-					"IS_DEV": "true"
-				}
-			}
-		},
 		{
 			"label": "watch",
-			"dependsOn": ["npm: protos", "npm: build:webview", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild"],
+			"dependsOn": ["npm: build:webview", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild"],
 			"presentation": {
-				"reveal": "always"
+				"reveal": "never"
 			},
 			"group": {
 				"kind": "build",
@@ -31,15 +16,9 @@
 		},
 		{
 			"label": "watch:test",
-			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview:test",
-				"npm: dev:webview",
-				"npm: watch:tsc",
-				"npm: watch:esbuild:test"
-			],
+			"dependsOn": ["npm: build:webview:test", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild:test"],
 			"presentation": {
-				"reveal": "always"
+				"reveal": "never"
 			},
 			"group": "build"
 		},
@@ -50,10 +29,10 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			},
 			"options": {
 				"env": {
@@ -68,10 +47,10 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview:test",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			},
 			"options": {
 				"env": {
@@ -103,10 +82,10 @@
 			],
 			"isBackground": true,
 			"label": "npm: dev:webview",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			},
 			"options": {
 				"env": {
@@ -121,10 +100,10 @@
 			"problemMatcher": "$esbuild-watch",
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			},
 			"options": {
 				"env": {
@@ -139,10 +118,10 @@
 			"problemMatcher": "$esbuild-watch",
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			},
 			"options": {
 				"env": {
@@ -158,10 +137,10 @@
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"label": "npm: watch:tsc",
-			"dependsOn": ["npm: protos"],
 			"presentation": {
 				"group": "watch",
-				"reveal": "always"
+				"reveal": "never",
+				"close": true
 			}
 		},
 		{
@@ -169,16 +148,15 @@
 			"script": "watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
-			"dependsOn": ["npm: protos"],
 			"presentation": {
-				"reveal": "always",
+				"reveal": "never",
 				"group": "watchers"
 			},
 			"group": "build"
 		},
 		{
 			"label": "tasks: watch-tests",
-			"dependsOn": ["npm: protos", "npm: watch", "npm: watch-tests"],
+			"dependsOn": ["npm: watch", "npm: watch-tests"],
 			"problemMatcher": []
 		},
 		{

CHANGELOG.md

@@ -1,52 +1,5 @@
 # Changelog
 
-## [3.13.3]
-
--   Add download counts to MCP marketplace items
--   Add `/compact` command
--   Add prompt caching to gemini models in cline / openrouter providers
--   Add tooltips to bottom row menu
-
-## [3.13.2]
-
--   Add Gemini 2.5 Flash model to Vertex and Gemini Providers (Thanks monotykamary!)
--   Add Caching to gemini provider (Thanks arafatkatze!)
--   Add thinking budget support to Gemini Models (Thanks monotykamary!)
--   Add !include .file directive support for .clineignore (Thanks watany-dev!)
--   Improve slash command functionality
--   Improve prompting for new task tool
--   Fix o1 temperature being passed to the azure api (Thanks treeleaves30760!)
--   Fix to make "add new rule file" button functional
--   Fix Ollama provider timeout, allowing for a larger loading time (Thanks suvarchal!)
--   Fix Non-UTF-8 File Handling: Improve Encoding Detection to Prevent Garbled Text and Binary Misclassification (Thanks yt3trees!)
--   Fix settings to not reset by changing providers
--   Fix terminal outputs missing commas
--   Fix terminal errors caused by starting non-alphanumeric outputs
--   Fix auto approve settings becoming unset
--   Fix Mermaid syntax error in documentation (Thanks tuki0918!)
--   Remove supportsComputerUse restriction and support browser use through any model that supports images (Thanks arafatkatze!)
-
-## [3.13.1]
-
--   Fix bug where task cancellation during thinking stream would result in error state
-
-## [3.13.0]
-
--   Add Cline rules popover under the chat field, allowing you to easily add, enable & disable workspace level or global rule files
--   Add new slash command menu letting you type “/“ to do quick actions like creating new tasks
--   Add ability to edit past messages, with options to restore your workspace back to that point
--   Allow sending a message when selecting an option provided by the question or plan tool
--   Add command to jump to Cline's chat input
--   Add support for OpenAI o3 & 4o-mini (Thanks @PeterDaveHello and @arafatkatze!)
--   Add baseURL option for Google Gemini provider (Thanks @owengo and @olivierhub!)
--   Add support for Azure's DeepSeek model. (Thanks @yt3trees!)
--   Add ability for models that support it to receive image responses from MCP servers (Thanks @rikaaa0928!)
--   Improve search and replace diff editing by making it more flexible with models that fail to follow structured output instructions. (Thanks @chi-cat!)
--   Add detection of Ctrl+C termination in terminal, improving output reading issues
--   Fix issue where some commands with large output would cause UI to freeze
--   Fix token usage tracking issues with vertex provider (Thanks @mzsima!)
--   Fix issue with xAI reasoning content not being parsed (Thanks @mrubens!)
-
 ## [3.12.3]
 
 -   Add copy button to MermaidBlock component (Thanks @cacosub7!)
@@ -105,7 +58,7 @@
 -   Add recommended models for Cline provider
 -   Add ability to detect when user edits files manually so Cline knows to re-read, leading to reduced diff edit errors
 -   Add improvements to file mention searching for faster searching
--   Add scoring logic to file mentions to sort and exclude results based on relevance
+-   Add scoring logic to file mentions to sort and exlcude results based on relevance
 -   Add Support for Bytedance Doubao (Thanks Tunixer!)
 -   Fix to prevent duplicate BOM (Thanks bamps53!)
 
@@ -583,7 +536,7 @@
 -   Adds "Always allow read-only operations" setting to let Claude read files and view directories without needing approval (off by default)
 -   Implement sliding window context management to keep tasks going past 200k tokens
 -   Adds Google Cloud Vertex AI support and updates Claude 3.5 Sonnet max output to 8192 tokens for all providers.
--   Improves system prompt to guard against lazy edits (less "//rest of code here")
+-   Improves system prompt to gaurd against lazy edits (less "//rest of code here")
 
 ## [1.3.0]
 

README.md

@@ -187,4 +187,4 @@ To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.m
 
 ## License
 
-[Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)
+[Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)

esbuild.js

@@ -4,63 +4,11 @@ const path = require("path")
 
 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")
+const test = process.env.IS_TEST === "true"
 
 /**
  * @type {import('esbuild').Plugin}
  */
-const aliasResolverPlugin = {
-	name: "alias-resolver",
-	setup(build) {
-		const aliases = {
-			"@": path.resolve(__dirname, "src"),
-			"@api": path.resolve(__dirname, "src/api"),
-			"@core": path.resolve(__dirname, "src/core"),
-			"@integrations": path.resolve(__dirname, "src/integrations"),
-			"@services": path.resolve(__dirname, "src/services"),
-			"@shared": path.resolve(__dirname, "src/shared"),
-			"@utils": path.resolve(__dirname, "src/utils"),
-		}
-
-		// For each alias entry, create a resolver
-		Object.entries(aliases).forEach(([alias, aliasPath]) => {
-			const aliasRegex = new RegExp(`^${alias}($|/.*)`)
-			build.onResolve({ filter: aliasRegex }, (args) => {
-				const importPath = args.path.replace(alias, aliasPath)
-
-				// First, check if the path exists as is
-				if (fs.existsSync(importPath)) {
-					const stats = fs.statSync(importPath)
-					if (stats.isDirectory()) {
-						// If it's a directory, try to find index files
-						const extensions = [".ts", ".tsx", ".js", ".jsx"]
-						for (const ext of extensions) {
-							const indexFile = path.join(importPath, `index${ext}`)
-							if (fs.existsSync(indexFile)) {
-								return { path: indexFile }
-							}
-						}
-					} else {
-						// It's a file that exists, so return it
-						return { path: importPath }
-					}
-				}
-
-				// If the path doesn't exist, try appending extensions
-				const extensions = [".ts", ".tsx", ".js", ".jsx"]
-				for (const ext of extensions) {
-					const pathWithExtension = `${importPath}${ext}`
-					if (fs.existsSync(pathWithExtension)) {
-						return { path: pathWithExtension }
-					}
-				}
-
-				// If nothing worked, return the original path and let esbuild handle the error
-				return { path: importPath }
-			})
-		})
-	},
-}
-
 const esbuildProblemMatcherPlugin = {
 	name: "esbuild-problem-matcher",
 
@@ -123,10 +71,10 @@ const extensionConfig = {
 	logLevel: "silent",
 	define: {
 		"process.env.IS_DEV": JSON.stringify(!production),
+		"process.env.IS_TEST": JSON.stringify(test),
 	},
 	plugins: [
 		copyWasmFiles,
-		aliasResolverPlugin,
 		/* add to the end of plugins array */
 		esbuildProblemMatcherPlugin,
 		{

evals/README.md

@@ -60,17 +60,6 @@ cline-repo/
 - VSCode with Cline extension installed
 - Git
 
-### Activation Mechanism
-
-The evaluation system uses an `evals.env` file approach to activate test mode in the Cline extension. When an evaluation is run:
-
-1. The CLI creates an `evals.env` file in the workspace directory
-2. The Cline extension activates due to the `workspaceContains:evals.env` activation event
-3. The extension detects this file and automatically enters test mode
-4. After evaluation completes, the file is automatically removed
-
-This approach eliminates the need for environment variables during the build process and allows for targeted activation only when needed for evaluations. The extension remains dormant during normal use, only activating when an evals.env file is present. For more details, see [Evals Env Activation](./docs/evals-env-activation.md).
-
 ### Installation
 
 1. Build the CLI tool:
@@ -117,19 +106,6 @@ Options:
 - `--format`: Report format (json, markdown) (default: markdown)
 - `--output`: Output path for the report
 
-#### Managing Test Mode Activation
-
-The CLI provides a command to manually manage the evals.env file for test mode activation:
-
-```bash
-node dist/index.js evals-env create  # Create evals.env file in current directory
-node dist/index.js evals-env remove  # Remove evals.env file from current directory
-node dist/index.js evals-env check   # Check if evals.env file exists in current directory
-```
-
-Options:
-- `--directory`: Specify a directory other than the current one
-
 ## Benchmarks
 
 ### Exercism

evals/cli/src/adapters/exercism.ts

@@ -167,12 +167,8 @@ export class ExercismAdapter implements BenchmarkAdapter {
 				output += stdout + "\n"
 			} catch (error: any) {
 				success = false
-				if (error.stdout) {
-					output += error.stdout + "\n"
-				}
-				if (error.stderr) {
-					output += error.stderr + "\n"
-				}
+				if (error.stdout) output += error.stdout + "\n"
+				if (error.stderr) output += error.stderr + "\n"
 			}
 		}
 

evals/cli/src/commands/evals-env.ts

@@ -1,53 +0,0 @@
-import * as path from "path"
-import chalk from "chalk"
-import { createEvalsEnvFile, removeEvalsEnvFile, checkEvalsEnvFile } from "../utils/evals-env"
-
-interface EvalsEnvOptions {
-	action: "create" | "remove" | "check"
-	directory?: string
-}
-
-/**
- * Handler for the evals-env command
- * @param options Command options
- */
-export async function evalsEnvHandler(options: EvalsEnvOptions): Promise<void> {
-	// Determine the directory to use - default to repository root instead of current directory
-	const currentDir = process.cwd()
-	const repoRoot = path.resolve(currentDir, "..", "..") // Navigate up from evals/cli to root
-	const directory = options.directory || repoRoot
-
-	console.log(chalk.blue(`Working with directory: ${directory}`))
-
-	// Perform the requested action
-	switch (options.action) {
-		case "create":
-			console.log(chalk.blue("Creating evals.env file..."))
-			createEvalsEnvFile(directory)
-			console.log(chalk.green("The Cline extension should now detect this file and enter test mode."))
-			console.log(chalk.yellow("Note: You may need to reload VSCode for the changes to take effect."))
-			break
-
-		case "remove":
-			console.log(chalk.blue("Removing evals.env file..."))
-			removeEvalsEnvFile(directory)
-			console.log(chalk.green("The Cline extension should now exit test mode."))
-			console.log(chalk.yellow("Note: You may need to reload VSCode for the changes to take effect."))
-			break
-
-		case "check":
-			console.log(chalk.blue("Checking for evals.env file..."))
-			const exists = checkEvalsEnvFile(directory)
-			if (exists) {
-				console.log(chalk.green("The Cline extension should be in test mode."))
-			} else {
-				console.log(chalk.yellow("The Cline extension should not be in test mode."))
-			}
-			break
-
-		default:
-			console.error(chalk.red(`Unknown action: ${options.action}`))
-			console.log(chalk.yellow("Valid actions are: create, remove, check"))
-			break
-	}
-}

evals/cli/src/index.ts

@@ -4,7 +4,6 @@ import chalk from "chalk"
 import { setupHandler } from "./commands/setup"
 import { runHandler } from "./commands/run"
 import { reportHandler } from "./commands/report"
-import { evalsEnvHandler } from "./commands/evals-env"
 
 // Create the CLI program
 const program = new Command()
@@ -62,21 +61,6 @@ program
 		}
 	})
 
-// Evals-env command
-program
-	.command("evals-env")
-	.description("Manage evals.env files for test mode activation")
-	.argument("<action>", "Action to perform: create, remove, or check")
-	.option("-d, --directory <directory>", "Directory to create/remove/check evals.env file in (defaults to current directory)")
-	.action(async (action, options) => {
-		try {
-			await evalsEnvHandler({ action, ...options })
-		} catch (error) {
-			console.error(chalk.red(`Error managing evals.env file: ${error instanceof Error ? error.message : String(error)}`))
-			process.exit(1)
-		}
-	})
-
 // Parse command line arguments
 program.parse(process.argv)
 

evals/cli/src/utils/evals-env.ts

@@ -1,79 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import chalk from "chalk"
-
-/**
- * Creates an evals.env file in the specified directory
- * @param directory The directory where the evals.env file should be created
- * @returns True if the file was created, false if it already exists
- */
-export function createEvalsEnvFile(directory: string): boolean {
-	const evalsEnvPath = path.join(directory, "evals.env")
-
-	// Check if the file already exists
-	if (fs.existsSync(evalsEnvPath)) {
-		console.log(chalk.yellow(`evals.env file already exists at ${evalsEnvPath}`))
-		return false
-	}
-
-	// Create the file
-	try {
-		const content = `# This file activates Cline test mode
-# Created at: ${new Date().toISOString()}
-# 
-# This file is automatically detected by the Cline extension
-# and enables test mode for automated evaluations.
-#
-# Delete this file to deactivate test mode.
-`
-		fs.writeFileSync(evalsEnvPath, content)
-		console.log(chalk.green(`Created evals.env file at ${evalsEnvPath}`))
-		return true
-	} catch (error) {
-		console.error(chalk.red(`Error creating evals.env file: ${error}`))
-		return false
-	}
-}
-
-/**
- * Removes an evals.env file from the specified directory
- * @param directory The directory where the evals.env file should be removed
- * @returns True if the file was removed, false if it doesn't exist
- */
-export function removeEvalsEnvFile(directory: string): boolean {
-	const evalsEnvPath = path.join(directory, "evals.env")
-
-	// Check if the file exists
-	if (!fs.existsSync(evalsEnvPath)) {
-		console.log(chalk.yellow(`No evals.env file found at ${evalsEnvPath}`))
-		return false
-	}
-
-	// Remove the file
-	try {
-		fs.unlinkSync(evalsEnvPath)
-		console.log(chalk.green(`Removed evals.env file from ${evalsEnvPath}`))
-		return true
-	} catch (error) {
-		console.error(chalk.red(`Error removing evals.env file: ${error}`))
-		return false
-	}
-}
-
-/**
- * Checks if an evals.env file exists in the specified directory
- * @param directory The directory to check for an evals.env file
- * @returns True if the file exists, false otherwise
- */
-export function checkEvalsEnvFile(directory: string): boolean {
-	const evalsEnvPath = path.join(directory, "evals.env")
-	const exists = fs.existsSync(evalsEnvPath)
-
-	if (exists) {
-		console.log(chalk.green(`evals.env file found at ${evalsEnvPath}`))
-	} else {
-		console.log(chalk.yellow(`No evals.env file found at ${evalsEnvPath}`))
-	}
-
-	return exists
-}

evals/cli/src/utils/vscode.ts

@@ -3,6 +3,7 @@ import * as path from "path"
 import * as fs from "fs"
 import fetch from "node-fetch"
 import * as os from "os"
+import * as child_process from "child_process"
 import { installRequiredExtensions, configureExtensionSettings } from "./extensions"
 
 // Store temporary directories for cleanup
@@ -30,43 +31,23 @@ export async function spawnVSCode(workspacePath: string, vsixPath?: string): Pro
 	// If no VSIX path is provided, build one with IS_TEST=true
 	if (!vsixPath) {
 		try {
-			// Build the VSIX (no longer need to set IS_TEST=true as we'll use evals.env file)
-			console.log("Building VSIX...")
+			// Build the VSIX with IS_TEST=true
+			console.log("Building test VSIX...")
 			const clineRoot = path.resolve(process.cwd(), "..", "..")
 			await execa("npx", ["vsce", "package"], {
 				cwd: clineRoot,
+				env: {
+					IS_TEST: "true",
+				},
 				stdio: "inherit",
 			})
 
-			// Find the generated VSIX file(s)
+			// Find the generated VSIX file
 			const files = fs.readdirSync(clineRoot)
-			const vsixFiles = files.filter((file) => file.endsWith(".vsix"))
-
-			if (vsixFiles.length > 0) {
-				// Get file stats to find the most recent one
-				const vsixFilesWithStats = vsixFiles.map((file) => {
-					const filePath = path.join(clineRoot, file)
-					return {
-						file,
-						path: filePath,
-						mtime: fs.statSync(filePath).mtime,
-					}
-				})
-
-				// Sort by modification time (most recent first)
-				vsixFilesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-
-				// Use the most recent VSIX
-				vsixPath = vsixFilesWithStats[0].path
-				console.log(`Using most recent VSIX: ${vsixPath} (modified ${vsixFilesWithStats[0].mtime.toISOString()})`)
-
-				// Log all found VSIX files for debugging
-				if (vsixFiles.length > 1) {
-					console.log(`Found ${vsixFiles.length} VSIX files:`)
-					vsixFilesWithStats.forEach((f) => {
-						console.log(`  - ${f.file} (modified ${f.mtime.toISOString()})`)
-					})
-				}
+			const vsixFile = files.find((file) => file.endsWith(".vsix"))
+			if (vsixFile) {
+				vsixPath = path.join(clineRoot, vsixFile)
+				console.log(`Using built VSIX: ${vsixPath}`)
 			} else {
 				console.warn("Could not find generated VSIX file")
 			}
@@ -85,21 +66,6 @@ export async function spawnVSCode(workspacePath: string, vsixPath?: string): Pro
 	fs.mkdirSync(tempExtensionsDir, { recursive: true })
 	console.log(`Created temporary extensions directory: ${tempExtensionsDir}`)
 
-	// Create evals.env file in the workspace to trigger test mode
-	console.log(`Creating evals.env file in workspace: ${workspacePath}`)
-	const evalsEnvPath = path.join(workspacePath, "evals.env")
-	fs.writeFileSync(
-		evalsEnvPath,
-		`# This file activates Cline test mode
-# Created at: ${new Date().toISOString()}
-# 
-# This file is automatically detected by the Cline extension
-# and enables test mode for automated evaluations.
-#
-# Delete this file to deactivate test mode.
-`,
-	)
-
 	// Create settings.json in the temporary user data directory to disable workspace trust
 	// and configure Cline to auto-open on startup
 	const settingsDir = path.join(tempUserDataDir, "User")
@@ -582,7 +548,7 @@ export async function cleanupVSCode(workspacePath: string): Promise<void> {
 		console.warn(`Error closing VS Code: ${error}`)
 	}
 
-	// Clean up temporary directories and evals.env file
+	// Clean up temporary directories
 	try {
 		console.log(`Removing temporary user data directory: ${resources.tempUserDataDir}`)
 		fs.rmSync(resources.tempUserDataDir, { recursive: true, force: true })
@@ -597,17 +563,6 @@ export async function cleanupVSCode(workspacePath: string): Promise<void> {
 		console.warn(`Error removing temporary extensions directory: ${error}`)
 	}
 
-	// Remove the evals.env file
-	try {
-		const evalsEnvPath = path.join(workspacePath, "evals.env")
-		if (fs.existsSync(evalsEnvPath)) {
-			console.log(`Removing evals.env file: ${evalsEnvPath}`)
-			fs.unlinkSync(evalsEnvPath)
-		}
-	} catch (error) {
-		console.warn(`Error removing evals.env file: ${error}`)
-	}
-
 	// Remove from the global map
 	workspaceResources.delete(workspacePath)
 

locales/zh-cn/README.md

@@ -26,17 +26,17 @@
 </table>
 </div>
 
-认识 Cline —— 一个可以使用你的 **终端** 和 **编辑器** 的 AI 助手。
+认识 Cline，一个可以使用你的 **CLI** 和 **编辑器** 的 AI 助手。
 
-得益于 [Claude 3.7 Sonnet 的代理式编码能力](https://www.anthropic.com/claude/sonnet)，Cline 能够逐步处理复杂的软件开发任务。借助于一系列工具，他可以创建和编辑文件、浏览大型项目、使用浏览器，并在你授权后执行终端命令，从而在代码补全或技术支持之外提供更深入的帮助。Cline 甚至还能使用 Model Context Protocol（MCP）来创建新工具，并扩展自身的能力。虽然传统的自动化 AI 脚本通常运行在沙盒环境中，但这个扩展提供了一个人类参与审核的图形界面（GUI），用于审批每一次文件变更和终端命令，从而为探索代理式 AI 的潜力提供了一种安全且易于使用的方式。
+感谢 [Claude 3.7 Sonnet 的代理编码能力](https://www.anthropic.com/claude/sonnet)，Cline 可以一步步处理复杂的软件开发任务。通过允许他创建和编辑文件、探索大型项目、使用浏览器和执行终端命令（在你授予权限后），他可以提供超越代码完成或技术支持的帮助。Cline 甚至可以使用 Model Context Protocol (MCP) 创建新工具并扩展自己的能力。虽然自主 AI 脚本传统上在沙盒环境中运行，但此扩展提供了一个人机交互的 GUI 来批准每个文件更改和终端命令，提供了一种安全且可访问的方式来探索代理 AI 的潜力。
 
-1. 输入你的任务，并添加图片，以将界面原型（mockup）转换为功能应用，或通过截图修复 bug。
-2. Cline 会从分析你的文件结构和源代码的抽象语法树（AST）开始，同时执行正则搜索并读取相关文件，以便尽快熟悉项目上下文。通过精细地管理上下文中引入的信息，即使面对大型复杂项目，Cline 也能在不超出上下文窗口限制的前提下提供有效协助。
-3. 一旦获取了所需信息，Cline 能够：
-   - 创建和编辑文件，并在过程中监控 linter 或编译器错误，主动修复诸如缺少导入、语法错误等问题。
-   - 直接在你的终端中执行命令，并在运行过程中监控输出，例如在修改文件后自动响应开发服务器问题。
-   - 针对 Web 开发任务，Cline 可以在无头浏览器中打开网站，进行点击、输入、滚动操作，并采集截图与控制台日志，从而修复运行时错误和界面问题。
-4. 当任务完成后，Cline 会通过类似 `open -a "Google Chrome" index.html` 的终端命令将结果展示给你，你只需点击按钮即可执行。
+1. 输入你的任务并添加图像，将模型转换为功能应用程序或通过截图修复错误。
+2. Cline 首先分析你的文件结构和源代码 AST，运行正则表达式搜索，并阅读相关文件以了解现有项目。通过仔细管理添加到上下文中的信息，Cline 即使在大型复杂项目中也能提供有价值的帮助，而不会使上下文窗口过载。
+3. 一旦 Cline 获得所需信息，他可以：
+   - 创建和编辑文件 + 监控 linter/编译器错误，从而主动修复诸如缺少导入和语法错误等问题。
+   - 直接在你的终端中执行命令并监控其输出，从而在编辑文件后对开发服务器问题做出反应。
+   - 对于 Web 开发任务，Cline 可以在无头浏览器中启动网站，点击、输入、滚动并捕获截图和控制台日志，从而修复运行时错误和视觉错误。
+4. 当任务完成时，Cline 将通过终端命令如 `open -a "Google Chrome" index.html` 向你展示结果，你可以通过点击按钮运行该命令。
 
 > [!TIP]
 > 使用 `CMD/CTRL + Shift + P` 快捷键打开命令面板并输入 "Cline: Open In New Tab" 将扩展作为标签在编辑器中打开。这让你可以与文件资源管理器并排使用 Cline，更清楚地看到他如何改变你的工作空间。
@@ -49,7 +49,7 @@
 
 Cline 支持 OpenRouter、Anthropic、OpenAI、Google Gemini、AWS Bedrock、Azure 和 GCP Vertex 等 API 提供商。你还可以配置任何兼容 OpenAI 的 API，或通过 LM Studio/Ollama 使用本地模型。如果你使用 OpenRouter，扩展会获取他们的最新模型列表，让你在新模型可用时立即使用。
 
-此外，该扩展还会记录整个任务流程中以及每次请求的总 token 数和 API 使用费用，确保你在每一步都能清楚了解花费情况。
+扩展还会跟踪整个任务循环和单个请求的总令牌和 API 使用成本，让你在每一步都了解支出情况。
 
 <!-- 透明像素以在浮动图像后创建换行 -->
 

locales/zh-tw/README.md

@@ -32,7 +32,7 @@
 
 認識 Cline，一個可以使用您的**命令列介面** (CLI) 和**程式編輯器** (Editor) 的 AI 助理。
 
-感謝 [Claude 3.7 Sonnet 的代理式程式設計能力](https://www.anthropic.com/claude/sonnet)，Cline 能夠逐步處理複雜的軟體開發任務。透過能讓他建立和編輯檔案、探索大型專案、使用瀏覽器，以及執行終端機指令（在您授權後）的工具，從而在程式碼補全或技術支援之外提供更深入的協助。Cline 甚至能使用模型上下文協定（Model Context Protocol，MCP）來建立新工具並擴展自己的功能。雖然自主 AI 腳本傳統上會在沙箱環境中執行，但這個擴充套件提供了人機互動的圖形介面，讓您可以核准每個檔案變更和終端機指令，提供一個安全且容易使用的方式來探索代理式 AI 的潛力。
+感謝 [Claude 3.7 Sonnet 的代理式程式設計能力](https://www.anthropic.com/claude/sonnet)，Cline 能夠逐步處理複雜的軟體開發任務。透過能讓他建立和編輯檔案、探索大型專案、使用瀏覽器，以及執行終端機指令（在您授權後）的工具，他能以超越程式碼自動完成或技術支援的方式協助您。Cline 甚至能使用模型上下文協定（Model Context Protocol，MCP）來建立新工具並擴展自己的功能。雖然自主 AI 腳本傳統上會在沙箱環境中執行，但這個擴充套件提供了人機互動的圖形介面，讓您可以核准每個檔案變更和終端機指令，提供一個安全且容易使用的方式來探索代理式 AI 的潛力。
 
 1. 輸入您的任務，並可以加入圖片來將設計稿轉換成功能性應用程式，或使用截圖來修正錯誤。
 2. Cline 會先分析您的檔案結構和程式碼 AST、執行正規表達式搜尋，並讀取相關檔案，以便在現有專案中快速掌握狀況。透過仔細管理加入上下文的資訊，Cline 可以在不超過上下文視窗的情況下，為大型且複雜的專案提供有價值的協助。

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.12.3",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -39,9 +39,7 @@
 		"ai",
 		"llama"
 	],
-	"activationEvents": [
-		"workspaceContains:evals.env"
-	],
+	"activationEvents": [],
 	"main": "./dist/extension.js",
 	"contributes": {
 		"viewsContainers": {
@@ -114,6 +112,11 @@
 				"title": "Add to Cline",
 				"category": "Cline"
 			},
+			{
+				"command": "cline.fixWithCline",
+				"title": "Fix with Cline",
+				"category": "Cline"
+			},
 			{
 				"command": "cline.focusChatInput",
 				"title": "Jump to Chat Input",
@@ -289,9 +292,13 @@
 		"compile": "npm run check-types && npm run lint && node esbuild.js",
 		"watch": "npm-run-all -p watch:*",
 		"watch:esbuild": "node esbuild.js --watch",
+		"watch:esbuild:test": "IS_TEST=true node esbuild.js --watch",
 		"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",
+		"package:test": "IS_TEST=true npm run build:webview:test && npm run check-types && npm run lint && IS_TEST=true node esbuild.js --production",
+		"build:webview:test": "cd webview-ui && IS_TEST=true npm run build",
+		"watch:test": "IS_TEST=true npm-run-all -p watch:tsc watch:esbuild:test",
 		"compile-tests": "tsc -p ./tsconfig.test.json --outDir out",
 		"watch-tests": "tsc -p . -w --outDir out",
 		"pretest": "npm run compile-tests && npm run compile && npm run lint",
@@ -299,10 +306,12 @@
 		"lint": "eslint src --ext ts && eslint webview-ui/src --ext ts",
 		"format": "prettier . --check",
 		"format:fix": "prettier . --write",
-		"test": "npm-run-all test:unit test:integration",
+		"test": "npm-run-all test:unit test:integration test:webview",
 		"test:ci": "node scripts/test-ci.js",
+		"test:unit": "vitest run",
+		"test:unit:watch": "vitest",
+		"test:unit:coverage": "vitest run --coverage",
 		"test:integration": "vscode-test",
-		"test:unit": "TS_NODE_PROJECT='./tsconfig.unit-test.json' mocha",
 		"test:coverage": "vscode-test --coverage",
 		"install:all": "npm install && cd webview-ui && npm install",
 		"dev:webview": "cd webview-ui && npm run dev",
@@ -316,38 +325,36 @@
 	},
 	"devDependencies": {
 		"@changesets/cli": "^2.27.12",
-		"@types/chai": "^5.0.1",
+		"@types/chai": "^5.2.1",
 		"@types/clone-deep": "^4.0.4",
 		"@types/diff": "^5.2.1",
 		"@types/get-folder-size": "^3.0.4",
-		"@types/mocha": "^10.0.7",
+		"@types/mocha": "^10.0.10",
 		"@types/node": "20.x",
 		"@types/pdf-parse": "^1.1.4",
-		"@types/proxyquire": "^1.3.31",
 		"@types/should": "^11.2.0",
 		"@types/sinon": "^17.0.4",
 		"@types/turndown": "^5.0.5",
 		"@types/vscode": "^1.84.0",
 		"@typescript-eslint/eslint-plugin": "^7.14.1",
 		"@typescript-eslint/parser": "^7.11.0",
-		"@vscode/test-cli": "^0.0.9",
+		"@vitest/coverage-v8": "^3.1.1",
+		"@vscode/test-cli": "^0.0.10",
 		"@vscode/test-electron": "^2.4.0",
-		"chai": "^4.3.10",
+		"chai": "^4.5.0",
 		"chalk": "^5.3.0",
 		"esbuild": "^0.25.0",
 		"eslint": "^8.57.0",
-		"grpc-tools": "^1.13.0",
 		"husky": "^9.1.7",
 		"npm-run-all": "^4.1.5",
 		"prettier": "^3.3.3",
 		"protoc-gen-ts": "^0.8.7",
-		"proxyquire": "^2.1.3",
 		"should": "^13.2.3",
-		"sinon": "^19.0.2",
+		"sinon": "^20.0.0",
 		"ts-node": "^10.9.2",
 		"ts-proto": "^2.6.1",
-		"tsconfig-paths": "^4.2.0",
-		"typescript": "^5.4.5"
+		"typescript": "^5.4.5",
+		"vitest": "^3.1.1"
 	},
 	"dependencies": {
 		"@anthropic-ai/bedrock-sdk": "^0.12.4",
@@ -356,7 +363,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3.758.0",
 		"@bufbuild/protobuf": "^2.2.5",
 		"@google-cloud/vertexai": "^1.9.3",
-		"@google/genai": "^0.9.0",
+		"@google/generative-ai": "^0.18.0",
 		"@grpc/grpc-js": "^1.9.15",
 		"@mistralai/mistralai": "^1.5.0",
 		"@modelcontextprotocol/sdk": "^1.7.0",
@@ -381,10 +388,8 @@
 		"fzf": "^0.5.2",
 		"get-folder-size": "^5.0.0",
 		"globby": "^14.0.2",
-		"iconv-lite": "^0.6.3",
 		"ignore": "^7.0.3",
 		"isbinaryfile": "^5.0.2",
-		"jschardet": "^3.1.4",
 		"mammoth": "^1.8.0",
 		"monaco-vscode-textmate-theme-converter": "^0.1.7",
 		"ollama": "^0.5.13",

proto/account.proto

@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// Service for account-related operations
-service AccountService {
-    // Handles the user clicking the login link in the UI.
-    // Generates a secure nonce for state validation, stores it in secrets,
-    // and opens the authentication URL in the external browser.
-    rpc accountLoginClicked(EmptyRequest) returns (String);
-}

proto/browser.proto

@@ -1,50 +1,15 @@
 syntax = "proto3";
 
 package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
 
 import "common.proto";
 
 service BrowserService {
   rpc getBrowserConnectionInfo(EmptyRequest) returns (BrowserConnectionInfo);
-  rpc testBrowserConnection(StringRequest) returns (BrowserConnection);
-  rpc discoverBrowser(EmptyRequest) returns (BrowserConnection);
-  rpc getDetectedChromePath(EmptyRequest) returns (ChromePath);
-  rpc updateBrowserSettings(UpdateBrowserSettingsRequest) returns (Boolean);
 }
 
 message BrowserConnectionInfo {
   bool is_connected = 1;
   bool is_remote = 2;
-  optional string host = 3;
-}
-
-message BrowserConnection {
-  bool success = 1;
-  string message = 2;
-  optional string endpoint = 3;
-}
-
-message ChromePath {
-  string path = 1;
-  bool is_bundled = 2;
-}
-
-message Viewport {
-  int32 width = 1;
-  int32 height = 2;
-}
-
-message BrowserSettings {
-  Viewport viewport = 1;
-  optional string remote_browser_host = 2;
-  optional bool remote_browser_enabled = 3;
-}
-
-message UpdateBrowserSettingsRequest {
-  Metadata metadata = 1;
-  Viewport viewport = 2;
-  optional string remote_browser_host = 3;
-  optional bool remote_browser_enabled = 4;
+  string host = 3; // Optional, may be empty
 }

proto/build-proto.js

@@ -6,11 +6,6 @@ import { execSync } from "child_process"
 import { globby } from "globby"
 import chalk from "chalk"
 
-import { createRequire } from "module"
-const require = createRequire(import.meta.url)
-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 ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
@@ -18,6 +13,26 @@ const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
 async function main() {
 	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))
 
+	// Check if protoc is installed
+	try {
+		const options = { stdio: "ignore" }
+		execSync("protoc --version", options)
+	} catch (error) {
+		console.warn(chalk.yellow("Warning: protoc is not installed. Skipping proto generation."))
+		console.warn(chalk.yellow("To install Protocol Buffers compiler, visit: https://grpc.io/docs/protoc-installation/"))
+		process.exit(0) // Exit with success as requested
+	}
+
+	// Check if ts-proto plugin is available
+	const TS_PROTO_PLUGIN = path.join(ROOT_DIR, "node_modules", ".bin", "protoc-gen-ts_proto")
+	try {
+		await fs.access(TS_PROTO_PLUGIN)
+	} catch (error) {
+		console.error(chalk.red("Error: ts-proto plugin not found at"), TS_PROTO_PLUGIN)
+		console.error(chalk.red('Please run "npm install" to install the required dependencies.'))
+		process.exit(1)
+	}
+
 	// Define output directories
 	const TS_OUT_DIR = path.join(ROOT_DIR, "src", "shared", "proto")
 
@@ -33,15 +48,15 @@ async function main() {
 
 	// Process all proto files
 	console.log(chalk.cyan("Processing proto files from"), SCRIPT_DIR)
-	const protoFiles = await globby("*.proto", { cwd: SCRIPT_DIR })
+	const protoFiles = await globby("**/*.proto", { cwd: SCRIPT_DIR })
 
 	for (const protoFile of protoFiles) {
 		console.log(chalk.cyan(`Generating TypeScript code for ${protoFile}...`))
 
 		// Build the protoc command with proper path handling for cross-platform
 		const protocCommand = [
-			protoc,
-			`--plugin=protoc-gen-ts_proto="${tsProtoPlugin}"`,
+			"protoc",
+			`--plugin=protoc-gen-ts_proto="${TS_PROTO_PLUGIN}"`,
 			`--ts_proto_out="${TS_OUT_DIR}"`,
 			"--ts_proto_opt=outputServices=generic-definitions,env=node,esModuleInterop=true,useDate=false,useOptionals=messages",
 			`--proto_path="${SCRIPT_DIR}"`,
@@ -77,12 +92,7 @@ async function generateMethodRegistrations() {
 	console.log(chalk.cyan("Generating method registration files..."))
 
 	const serviceDirs = [
-		path.join(ROOT_DIR, "src", "core", "controller", "account"),
 		path.join(ROOT_DIR, "src", "core", "controller", "browser"),
-		path.join(ROOT_DIR, "src", "core", "controller", "checkpoints"),
-		path.join(ROOT_DIR, "src", "core", "controller", "file"),
-		path.join(ROOT_DIR, "src", "core", "controller", "mcp"),
-		path.join(ROOT_DIR, "src", "core", "controller", "task"),
 		// Add more service directories here as needed
 	]
 

proto/checkpoints.proto

@@ -1,19 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-service CheckpointsService {
-  rpc checkpointDiff(Int64Request) returns (Empty);
-  rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);
-}
-
-message CheckpointRestoreRequest {
-  Metadata metadata = 1;
-  int64 number = 2;
-  string restore_type = 3;
-  optional int64 offset = 4;
-}

proto/common.proto

@@ -1,8 +1,6 @@
 syntax = "proto3";
 
 package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
 
 message Metadata {
 }
@@ -13,39 +11,3 @@ message EmptyRequest {
 
 message Empty {
 }
-
-message StringRequest {
-  Metadata metadata = 1;
-  string value = 2;
-}
-
-message String {
-  string value = 1;
-}
-
-message Int64Request {
-  Metadata metadata = 1;
-  int64 value = 2;
-}
-
-message Int64 {
-  int64 value = 1;
-}
-
-message BytesRequest {
-  Metadata metadata = 1;
-  bytes value = 2;
-}
-
-message Bytes {
-  bytes value = 1;
-}
-
-message BooleanRequest {
-  Metadata metadata = 1;
-  bool value = 2;
-}
-
-message Boolean {
-  bool value = 1;
-}

proto/file.proto

@@ -1,16 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// Service for file-related operations
-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);
-}

proto/mcp.proto

@@ -1,69 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-service McpService {
-  rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
-  rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
-}
-
-message ToggleMcpServerRequest {
-  Metadata metadata = 1;
-  string server_name = 2;
-  bool disabled = 3;
-}
-
-message UpdateMcpTimeoutRequest {
-  Metadata metadata = 1;
-  string server_name = 2;
-  int32 timeout = 3;
-}
-
-message McpTool {
-  string name = 1;
-  optional string description = 2;
-  optional string input_schema = 3;
-  optional bool auto_approve = 4;
-}
-
-message McpResource {
-  string uri = 1;
-  string name = 2;
-  optional string mime_type = 3;
-  optional string description = 4;
-}
-
-message McpResourceTemplate {
-  string uri_template = 1;
-  string name = 2;
-  optional string mime_type = 3;
-  optional string description = 4;
-}
-
-enum McpServerStatus {
-  // Protobuf enums (in proto3) must have a zero value defined, which serves as the default if the field isn't explicitly set. 
-  // To align with the required nature of the TypeScript type and avoid an unnecessary UNSPECIFIED state, we map one of the existing statuses to this zero value.
-  MCP_SERVER_STATUS_DISCONNECTED = 0; // default
-  MCP_SERVER_STATUS_CONNECTED = 1;
-  MCP_SERVER_STATUS_CONNECTING = 2;
-}
-
-message McpServer {
-  string name = 1;
-  string config = 2;
-  McpServerStatus status = 3;
-  optional string error = 4;
-  repeated McpTool tools = 5;
-  repeated McpResource resources = 6;
-  repeated McpResourceTemplate resource_templates = 7;
-  optional bool disabled = 8;
-  optional int32 timeout = 9;
-}
-
-message McpServers {
-  repeated McpServer mcp_servers = 1;
-}

proto/task.proto

@@ -1,23 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-service TaskService {
-  // Cancels the currently running task
-  rpc cancelTask(EmptyRequest) returns (Empty);
-  // Clears the current task
-  rpc clearTask(EmptyRequest) returns (Empty);
-  // Creates a new task with the given text and optional images
-  rpc newTask(NewTaskRequest) returns (Empty);
-}
-
-// Request message for creating a new task
-message NewTaskRequest {
-  Metadata metadata = 1;
-  string text = 2;
-  repeated string images = 3;
-}

src/api/__tests__/retry.spec.ts

@@ -1,6 +1,5 @@
-import { describe, it } from "mocha"
-import "should"
-import { withRetry } from "./retry"
+import { describe, it, expect, assert } from "vitest"
+import { withRetry } from "../retry"
 
 describe("Retry Decorator", () => {
 	describe("withRetry", () => {
@@ -20,8 +19,8 @@ describe("Retry Decorator", () => {
 				result.push(value)
 			}
 
-			callCount.should.equal(1)
-			result.should.deepEqual(["success"])
+			expect(callCount).toBe(1)
+			expect(result).toEqual(["success"])
 		})
 
 		it("should retry on rate limit (429) error", async () => {
@@ -45,8 +44,8 @@ describe("Retry Decorator", () => {
 				result.push(value)
 			}
 
-			callCount.should.equal(2)
-			result.should.deepEqual(["success after retry"])
+			expect(callCount).toBe(2)
+			expect(result).toEqual(["success after retry"])
 		})
 
 		it("should not retry on non-rate-limit errors", async () => {
@@ -66,8 +65,8 @@ describe("Retry Decorator", () => {
 				}
 				throw new Error("Should have thrown")
 			} catch (error: any) {
-				error.message.should.equal("Regular error")
-				callCount.should.equal(1)
+				expect(error.message).toBe("Regular error")
+				expect(callCount).toBe(1)
 			}
 		})
 
@@ -95,9 +94,9 @@ describe("Retry Decorator", () => {
 			}
 
 			const duration = Date.now() - startTime
-			duration.should.be.approximately(10, 10) // Allow 10ms variance
-			callCount.should.equal(2)
-			result.should.deepEqual(["success after retry"])
+			assert.closeTo(duration, 10, 10, "duration should be 10 ± 10ms")
+			expect(callCount).toBe(2)
+			expect(result).toEqual(["success after retry"])
 		})
 
 		it("should respect retry-after header with Unix timestamp", async () => {
@@ -126,9 +125,9 @@ describe("Retry Decorator", () => {
 			}
 
 			const duration = Date.now() - startTime
-			duration.should.be.approximately(10, 10) // Allow 10ms variance
-			callCount.should.equal(2)
-			result.should.deepEqual(["success after retry"])
+			assert.closeTo(duration, 10, 10, "duration should be 10 ± 10ms")
+			expect(callCount).toBe(2)
+			expect(result).toEqual(["success after retry"])
 		})
 
 		it("should use exponential backoff when no retry-after header", async () => {
@@ -155,9 +154,9 @@ describe("Retry Decorator", () => {
 
 			const duration = Date.now() - startTime
 			// First retry should be after baseDelay (10ms)
-			duration.should.be.approximately(10, 10)
-			callCount.should.equal(2)
-			result.should.deepEqual(["success after retry"])
+			assert.closeTo(duration, 10, 10, "duration should be 10 ± 10ms")
+			expect(callCount).toBe(2)
+			expect(result).toEqual(["success after retry"])
 		})
 
 		it("should respect maxDelay", async () => {
@@ -184,9 +183,9 @@ describe("Retry Decorator", () => {
 
 			const duration = Date.now() - startTime
 			// Both retries should be capped at maxDelay (10ms each)
-			duration.should.be.approximately(20, 20)
-			callCount.should.equal(3)
-			result.should.deepEqual(["success after retries"])
+			assert.closeTo(duration, 20, 10, "duration should be 20 ± 10ms")
+			expect(callCount).toBe(3)
+			expect(result).toEqual(["success after retries"])
 		})
 
 		it("should throw after maxRetries attempts", async () => {
@@ -208,8 +207,8 @@ describe("Retry Decorator", () => {
 				}
 				throw new Error("Should have thrown")
 			} catch (error: any) {
-				error.message.should.equal("Rate limit exceeded")
-				callCount.should.equal(2) // Initial attempt + 1 retry
+				expect(error.message).toBe("Rate limit exceeded")
+				expect(callCount).toBe(2) // Initial attempt + 1 retry
 			}
 		})
 	})

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

@@ -0,0 +1,224 @@
+import { describe, it, beforeEach, afterEach, beforeAll, expect, vi } from "vitest"
+import { Anthropic } from "@anthropic-ai/sdk"
+import { OllamaHandler } from "../ollama"
+import { ApiHandlerOptions } from "../../../shared/api"
+import axios from "axios"
+
+describe("OllamaHandler", () => {
+	let ollamaAvailable = false
+
+	// Check if Ollama is running before running tests
+	beforeAll(async function () {
+		try {
+			await axios.get("http://localhost:11434/api/version", { timeout: 2000 })
+			ollamaAvailable = true
+		} catch (error) {
+			console.log("Ollama server not available, skipping tests")
+			ollamaAvailable = false
+		}
+	}, 5000)
+
+	let handler: OllamaHandler
+	let options: ApiHandlerOptions
+
+	beforeEach(() => {
+		options = {
+			ollamaModelId: "llama2",
+			ollamaBaseUrl: "http://localhost:11434",
+		}
+		handler = new OllamaHandler(options)
+		// Use fake timers for testing timeouts
+		vi.useFakeTimers()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+		vi.restoreAllMocks()
+	})
+
+	describe("createMessage", () => {
+		it("should handle successful responses", async function ({ skip }) {
+			if (!ollamaAvailable) {
+				skip()
+			}
+			// Mock the Ollama client's chat method
+			const chatStub = vi.spyOn(handler["client"], "chat").mockResolvedValue({
+				[Symbol.asyncIterator]: async function* () {
+					yield {
+						message: { content: "Hello, world!" },
+						eval_count: 10,
+						prompt_eval_count: 20,
+					}
+				},
+			} as any)
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+
+			const result = []
+			const usageInfo = []
+
+			// Collect the results
+			for await (const chunk of handler.createMessage(systemPrompt, messages)) {
+				if (chunk.type === "text") {
+					result.push(chunk.text)
+				} else if (chunk.type === "usage") {
+					usageInfo.push({
+						inputTokens: chunk.inputTokens,
+						outputTokens: chunk.outputTokens,
+					})
+				}
+			}
+
+			// Verify the results
+			expect(result).toEqual(["Hello, world!"])
+			expect(usageInfo).toEqual([{ inputTokens: 20, outputTokens: 10 }])
+			expect(chatStub).toHaveBeenCalledTimes(1)
+		})
+
+		it("should handle timeout errors", { timeout: 10000 }, async function ({ skip }) {
+			if (!ollamaAvailable) {
+				skip()
+			}
+
+			// Restore real timers for this test
+			vi.useRealTimers()
+
+			// Create a handler with a very short timeout for testing
+			const testHandler = new OllamaHandler(options)
+
+			// Replace the createMessage method with one that has a shorter timeout
+			testHandler.createMessage = async function* (systemPrompt, messages) {
+				try {
+					// Create a promise that rejects after a short timeout
+					const timeoutPromise = new Promise<never>((_, reject) => {
+						setTimeout(() => reject(new Error("Ollama request timed out after 30 seconds")), 100)
+					})
+
+					// Create a promise that never resolves
+					const neverPromise = new Promise(() => {})
+
+					// Race them
+					await Promise.race([timeoutPromise, neverPromise])
+				} catch (error: any) {
+					// Enhance error reporting
+					console.error(`Ollama API error: ${error.message}`)
+					throw error
+				}
+			}
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+
+			// Start the request and catch the error
+			let errorMessage = ""
+			try {
+				for await (const _ of testHandler.createMessage(systemPrompt, messages)) {
+					// This should not be reached
+				}
+			} catch (error: any) {
+				errorMessage = error.message
+			}
+
+			// Check the result
+			expect(errorMessage).toBe("Ollama request timed out after 30 seconds")
+
+			// Restore the fake timers for other tests
+			vi.useFakeTimers()
+		})
+
+		it("should retry on errors when using the withRetry decorator", { timeout: 10000 }, async function ({ skip }) {
+			if (!ollamaAvailable) {
+				skip()
+			}
+
+			// Restore real timers for this test
+			vi.useRealTimers()
+
+			// Mock the Ollama client's chat method to fail on first call and succeed on second
+			const chatStub = vi.spyOn(handler["client"], "chat")
+
+			// First call throws an error
+			chatStub.mockRejectedValueOnce(new Error("API Error"))
+
+			// Second call succeeds
+			chatStub.mockResolvedValueOnce({
+				[Symbol.asyncIterator]: async function* () {
+					yield {
+						message: { content: "Success after retry" },
+					}
+				},
+			} as any)
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+
+			const result = []
+
+			// Add a small delay to ensure the retry mechanism has time to work
+			await new Promise((resolve) => setTimeout(resolve, 100))
+
+			// Collect the results
+			for await (const chunk of handler.createMessage(systemPrompt, messages)) {
+				if (chunk.type === "text") {
+					result.push(chunk.text)
+				}
+			}
+
+			// Verify the results
+			expect(result).toEqual(["Success after retry"])
+			expect(chatStub).toHaveBeenCalledTimes(2)
+
+			// Restore the fake timers for other tests
+			vi.useFakeTimers()
+		})
+
+		it("should handle stream processing errors", { timeout: 10000 }, async function ({ skip }) {
+			if (!ollamaAvailable) {
+				skip()
+			}
+
+			// Restore real timers for this test
+			vi.useRealTimers()
+
+			// Create a handler with a custom implementation for testing
+			const testHandler = new OllamaHandler(options)
+
+			// Replace the createMessage method with one that simulates a stream error
+			testHandler.createMessage = async function* (systemPrompt, messages) {
+				// First yield a successful chunk
+				yield {
+					type: "text",
+					text: "Partial response",
+				}
+
+				// Then throw an error in the stream
+				throw new Error("Ollama stream processing error: Stream error")
+			}
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+
+			const result = []
+
+			// Collect the results and catch the error
+			let errorMessage = ""
+			try {
+				for await (const chunk of testHandler.createMessage(systemPrompt, messages)) {
+					if (chunk.type === "text") {
+						result.push(chunk.text)
+					}
+				}
+			} catch (error: any) {
+				errorMessage = error.message
+			}
+
+			// Verify the results
+			expect(errorMessage).toBe("Ollama stream processing error: Stream error")
+			expect(result).toEqual(["Partial response"])
+
+			// Restore the fake timers for other tests
+			vi.useFakeTimers()
+		})
+	})
+})

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

@@ -3,7 +3,7 @@ import "should"
 import sinon from "sinon"
 import { Anthropic } from "@anthropic-ai/sdk"
 import { OllamaHandler } from "../ollama"
-import { ApiHandlerOptions } from "@shared/api"
+import { ApiHandlerOptions } from "../../../shared/api"
 import axios from "axios"
 
 describe("OllamaHandler", () => {
@@ -96,7 +96,7 @@ describe("OllamaHandler", () => {
 				try {
 					// Create a promise that rejects after a short timeout
 					const timeoutPromise = new Promise<never>((_, reject) => {
-						setTimeout(() => reject(new Error("Ollama request timed out after 120 seconds")), 100)
+						setTimeout(() => reject(new Error("Ollama request timed out after 30 seconds")), 100)
 					})
 
 					// Create a promise that never resolves
@@ -125,7 +125,7 @@ describe("OllamaHandler", () => {
 			}
 
 			// Check the result
-			errorMessage.should.equal("Ollama request timed out after 120 seconds")
+			errorMessage.should.equal("Ollama request timed out after 30 seconds")
 
 			// Restore the fake timers for other tests
 			clock = sinon.useFakeTimers()

src/api/providers/anthropic.ts

@@ -1,7 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { Stream as AnthropicStream } from "@anthropic-ai/sdk/streaming"
 import { withRetry } from "../retry"
-import { anthropicDefaultModelId, AnthropicModelId, anthropicModels, ApiHandlerOptions, ModelInfo } from "@shared/api"
+import { anthropicDefaultModelId, AnthropicModelId, anthropicModels, ApiHandlerOptions, ModelInfo } from "../../shared/api"
 import { ApiHandler } from "../index"
 import { ApiStream } from "../transform/stream"
 

src/api/providers/asksage.ts

@@ -7,7 +7,7 @@ import {
 	askSageModels,
 	askSageDefaultModelId,
 	askSageDefaultURL,
-} from "@shared/api"
+} from "../../shared/api"
 import { ApiStream } from "../transform/stream"
 
 type AskSageRequest = {

src/api/providers/bedrock.ts

@@ -3,7 +3,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
 import { convertToR1Format } from "../transform/r1-format"
-import { ApiHandlerOptions, bedrockDefaultModelId, BedrockModelId, bedrockModels, ModelInfo } from "@shared/api"
+import { ApiHandlerOptions, bedrockDefaultModelId, BedrockModelId, bedrockModels, ModelInfo } from "../../shared/api"
 import { calculateApiCostOpenAI } from "../../utils/cost"
 import { ApiStream } from "../transform/stream"
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers"

src/api/providers/cline.ts

@@ -1,7 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "../../shared/api"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
 import axios from "axios"

src/api/providers/deepseek.ts

@@ -2,7 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, DeepSeekModelId, ModelInfo, deepSeekDefaultModelId, deepSeekModels } from "@shared/api"
+import { ApiHandlerOptions, DeepSeekModelId, ModelInfo, deepSeekDefaultModelId, deepSeekModels } from "../../shared/api"
 import { calculateApiCostOpenAI } from "../../utils/cost"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"

src/api/providers/doubao.ts

@@ -1,5 +1,5 @@
 import { ApiHandler } from ".."
-import { ApiHandlerOptions, doubaoDefaultModelId, DoubaoModelId, doubaoModels, ModelInfo } from "@shared/api"
+import { ApiHandlerOptions, doubaoDefaultModelId, DoubaoModelId, doubaoModels, ModelInfo } from "../../shared/api"
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { convertToOpenAiMessages } from "../transform/openai-format"

src/api/providers/gemini.ts

@@ -1,154 +1,49 @@
-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 { Anthropic } from "@anthropic-ai/sdk"
+import { GoogleGenerativeAI } from "@google/generative-ai"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "@shared/api"
+import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "../../shared/api"
 import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
 import { ApiStream } from "../transform/stream"
 
-// Define a default TTL for the cache (e.g., 1 hour in seconds)
-const DEFAULT_CACHE_TTL_SECONDS = 3600
-
 export class GeminiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: GoogleGenAI // Updated client type
-
-	// Internal state for caching
-	private cacheName: string | null = null
-	private cacheExpireTime: number | null = null
-	private isFirstApiCall = true
+	private client: GoogleGenerativeAI
 
 	constructor(options: ApiHandlerOptions) {
 		if (!options.geminiApiKey) {
 			throw new Error("API key is required for Google Gemini")
 		}
 		this.options = options
-		// Updated client initialization
-		this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
+		this.client = new GoogleGenerativeAI(options.geminiApiKey)
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const { id: modelId, info: modelInfo } = this.getModel()
-
-		// --- Cache Handling Logic ---
-		const isCacheValid = this.cacheName && this.cacheExpireTime && Date.now() < this.cacheExpireTime
-		let useCache = !this.isFirstApiCall && isCacheValid
-
-		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
-
-			// 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)
-			}
-			// 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
-		const thinkingBudget = this.options.thinkingBudgetTokens ?? 0
-		const maxBudget = modelInfo.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
-		const requestConfig: GenerateContentConfig = {
-			...generationConfig,
-		}
-
-		// Add thinking config if the model supports it
-		if (modelInfo.thinkingConfig?.outputPrice !== undefined && maxBudget > 0) {
-			requestConfig.thinkingConfig = {
-				thinkingBudget: thinkingBudget,
-			}
-		}
-
-		// Generate content using the new SDK structure via client.models
-		const result = await this.client.models.generateContentStream({
-			model: modelId, // Pass model ID directly
-			contents,
-			// Add cachedContent if using the cache
-			config: {
-				...requestConfig,
-				...(useCache ? { cachedContent: this.cacheName! } : {}),
+		const model = this.client.getGenerativeModel({
+			model: this.getModel().id,
+			systemInstruction: systemPrompt,
+		})
+		const result = await model.generateContentStream({
+			contents: messages.map(convertAnthropicMessageToGemini),
+			generationConfig: {
+				// maxOutputTokens: this.getModel().info.maxTokens,
+				temperature: 0,
 			},
 		})
 
-		// Declare variable to hold the last usage metadata found
-		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined
-
-		// Iterate directly over the stream
-		for await (const chunk of result) {
-			if (chunk.text) {
-				yield {
-					type: "text",
-					text: chunk.text,
-				}
-			}
-			if (chunk.usageMetadata) {
-				lastUsageMetadata = chunk.usageMetadata
-			}
-		}
-
-		if (lastUsageMetadata) {
+		for await (const chunk of result.stream) {
 			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
+				type: "text",
+				text: chunk.text(),
 			}
 		}
-	}
 
-	private async createCacheInBackground(modelId: string, systemInstruction: string): Promise<void> {
-		try {
-			const cache = await this.client.caches.create({
-				model: modelId,
-				config: {
-					systemInstruction: systemInstruction,
-					ttl: `${DEFAULT_CACHE_TTL_SECONDS}s`,
-				},
-			})
-
-			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.")
-			}
-		} catch (error) {
-			console.error("Failed to create Gemini cache in background:", error)
-			// Reset state if creation failed definitively
-			this.cacheName = null
-			this.cacheExpireTime = null
+		const response = await result.response
+		yield {
+			type: "usage",
+			inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+			outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
 		}
 	}
 

src/api/providers/litellm.ts

@@ -1,6 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandlerOptions, liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults } from "@shared/api"
+import { ApiHandlerOptions, liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults } from "../../shared/api"
 import { ApiHandler } from ".."
 import { ApiStream } from "../transform/stream"
 import { convertToOpenAiMessages } from "../transform/openai-format"

src/api/providers/lmstudio.ts

@@ -1,7 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 

src/api/providers/mistral.ts

@@ -2,7 +2,16 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { Mistral } from "@mistralai/mistralai"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, mistralDefaultModelId, MistralModelId, mistralModels, ModelInfo } from "@shared/api"
+import {
+	ApiHandlerOptions,
+	mistralDefaultModelId,
+	MistralModelId,
+	mistralModels,
+	ModelInfo,
+	openAiNativeDefaultModelId,
+	OpenAiNativeModelId,
+	openAiNativeModels,
+} from "../../shared/api"
 import { convertToMistralMessages } from "../transform/mistral-format"
 import { ApiStream } from "../transform/stream"
 

src/api/providers/ollama.ts

@@ -21,9 +21,8 @@ export class OllamaHandler implements ApiHandler {
 
 		try {
 			// Create a promise that rejects after timeout
-			const timeoutMs = this.options.requestTimeoutMs || 30000
 			const timeoutPromise = new Promise<never>((_, reject) => {
-				setTimeout(() => reject(new Error(`Ollama request timed out after ${timeoutMs / 1000} seconds`)), timeoutMs)
+				setTimeout(() => reject(new Error("Ollama request timed out after 30 seconds")), 30000)
 			})
 
 			// Create the actual API request promise
@@ -64,8 +63,7 @@ export class OllamaHandler implements ApiHandler {
 		} catch (error: any) {
 			// Check if it's a timeout error
 			if (error.message && error.message.includes("timed out")) {
-				const timeoutMs = this.options.requestTimeoutMs || 30000
-				throw new Error(`Ollama request timed out after ${timeoutMs / 1000} seconds`)
+				throw new Error("Ollama request timed out after 30 seconds")
 			}
 
 			// Enhance error reporting

src/api/providers/openai-native.ts

@@ -2,7 +2,13 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openAiNativeDefaultModelId, OpenAiNativeModelId, openAiNativeModels } from "@shared/api"
+import {
+	ApiHandlerOptions,
+	ModelInfo,
+	openAiNativeDefaultModelId,
+	OpenAiNativeModelId,
+	openAiNativeModels,
+} from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { calculateApiCostOpenAI } from "../../utils/cost"
 import { ApiStream } from "../transform/stream"
@@ -44,7 +50,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 			case "o1":
 			case "o1-preview":
 			case "o1-mini": {
-				// o1 doesn't support streaming, non-1 temp, or system prompt
+				// o1 doesnt support streaming, non-1 temp, or system prompt
 				const response = await this.client.chat.completions.create({
 					model: model.id,
 					messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],

src/api/providers/openai.ts

@@ -1,7 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI, { AzureOpenAI } from "openai"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, azureOpenAiDefaultApiVersion, ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
+import { ApiHandlerOptions, azureOpenAiDefaultApiVersion, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { ApiHandler } from "../index"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
@@ -16,22 +16,16 @@ export class OpenAiHandler implements ApiHandler {
 		this.options = options
 		// Azure API shape slightly differs from the core API shape: https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai
 		// Use azureApiVersion to determine if this is an Azure endpoint, since the URL may not always contain 'azure.com'
-		if (
-			this.options.azureApiVersion ||
-			(this.options.openAiBaseUrl?.toLowerCase().includes("azure.com") &&
-				!this.options.openAiModelId?.toLowerCase().includes("deepseek"))
-		) {
+		if (this.options.azureApiVersion || this.options.openAiBaseUrl?.toLowerCase().includes("azure.com")) {
 			this.client = new AzureOpenAI({
 				baseURL: this.options.openAiBaseUrl,
 				apiKey: this.options.openAiApiKey,
 				apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion,
-				defaultHeaders: this.options.openAiHeaders,
 			})
 		} else {
 			this.client = new OpenAI({
 				baseURL: this.options.openAiBaseUrl,
 				apiKey: this.options.openAiApiKey,
-				defaultHeaders: this.options.openAiHeaders,
 			})
 		}
 	}
@@ -41,7 +35,7 @@ export class OpenAiHandler implements ApiHandler {
 		const modelId = this.options.openAiModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
 		const isR1FormatRequired = this.options.openAiModelInfo?.isR1FormatRequired ?? false
-		const isReasoningModelFamily = modelId.includes("o1") || modelId.includes("o3") || modelId.includes("o4")
+		const isReasoningModelFamily = modelId.includes("o3") || modelId.includes("o4")
 
 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },

src/api/providers/openrouter.ts

@@ -3,7 +3,7 @@ import axios from "axios"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "../../shared/api"
 import { withRetry } from "../retry"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"

src/api/providers/qwen.ts

@@ -10,7 +10,7 @@ import {
 	internationalQwenDefaultModelId,
 	MainlandQwenModelId,
 	InternationalQwenModelId,
-} from "@shared/api"
+} from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { convertToR1Format } from "../transform/r1-format"

src/api/providers/requesty.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandlerOptions, ModelInfo, requestyDefaultModelId, requestyDefaultModelInfo } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, requestyDefaultModelId, requestyDefaultModelInfo } from "../../shared/api"
 import { ApiHandler } from "../index"
 import { withRetry } from "../retry"
-import { convertToOpenAiMessages } from "@api/transform/openai-format"
-import { calculateApiCostOpenAI } from "@utils/cost"
-import { ApiStream } from "@api/transform/stream"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { calculateApiCostOpenAI } from "../../utils/cost"
+import { ApiStream } from "../transform/stream"
 
 export class RequestyHandler implements ApiHandler {
 	private options: ApiHandlerOptions

src/api/providers/sambanova.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, ModelInfo, SambanovaModelId, sambanovaDefaultModelId, sambanovaModels } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, SambanovaModelId, sambanovaDefaultModelId, sambanovaModels } from "../../shared/api"
 import { ApiHandler } from "../index"
-import { convertToOpenAiMessages } from "@/api/transform/openai-format"
-import { ApiStream } from "@api/transform/stream"
-import { convertToR1Format } from "@api/transform/r1-format"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+import { convertToR1Format } from "../transform/r1-format"
 
 export class SambanovaHandler implements ApiHandler {
 	private options: ApiHandlerOptions

src/api/providers/together.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
+import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { ApiHandler } from "../index"
-import { convertToOpenAiMessages } from "@api/transform/openai-format"
-import { ApiStream } from "@api/transform/stream"
-import { convertToR1Format } from "@api/transform/r1-format"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+import { convertToR1Format } from "../transform/r1-format"
 
 export class TogetherHandler implements ApiHandler {
 	private options: ApiHandlerOptions

src/api/providers/vertex.ts

@@ -2,10 +2,10 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, vertexDefaultModelId, VertexModelId, vertexModels } from "@shared/api"
-import { ApiStream } from "@api/transform/stream"
+import { ApiHandlerOptions, ModelInfo, vertexDefaultModelId, VertexModelId, vertexModels } from "../../shared/api"
+import { ApiStream } from "../transform/stream"
 import { VertexAI } from "@google-cloud/vertexai"
-import { calculateApiCostOpenAI } from "@utils/cost"
+import { calculateApiCostOpenAI } from "../../utils/cost"
 
 // https://docs.anthropic.com/en/api/claude-on-vertex-ai
 export class VertexHandler implements ApiHandler {

src/api/providers/vscode-lm.ts

@@ -1,11 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import * as vscode from "vscode"
 import { ApiHandler, SingleCompletionHandler } from "../"
-import { calculateApiCostAnthropic } from "@utils/cost"
-import { ApiStream } from "@api/transform/stream"
-import { convertToVsCodeLmMessages } from "@api/transform/vscode-lm-format"
-import { SELECTOR_SEPARATOR, stringifyVsCodeLmModelSelector } from "@shared/vsCodeSelectorUtils"
-import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
+import { calculateApiCostAnthropic } from "../../utils/cost"
+import { ApiStream } from "../transform/stream"
+import { convertToVsCodeLmMessages } from "../transform/vscode-lm-format"
+import { SELECTOR_SEPARATOR, stringifyVsCodeLmModelSelector } from "../../shared/vsCodeSelectorUtils"
+import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import type { LanguageModelChatSelector as LanguageModelChatSelectorFromTypes } from "./types"
 
 // Cline does not update VSCode type definitions or engine requirements to maintain compatibility.

src/api/providers/xai.ts

@@ -1,9 +1,9 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, XAIModelId, ModelInfo, xaiDefaultModelId, xaiModels } from "@shared/api"
-import { convertToOpenAiMessages } from "@api/transform/openai-format"
-import { ApiStream } from "@api/transform/stream"
+import { ApiHandlerOptions, XAIModelId, ModelInfo, xaiDefaultModelId, xaiModels } from "../../shared/api"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
 import { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
 
 export class XAIHandler implements ApiHandler {
@@ -47,7 +47,7 @@ export class XAIHandler implements ApiHandler {
 				}
 			}
 
-			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
+			if ("reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
 					// @ts-ignore-next-line

src/api/transform/__tests__/vscode-lm-format.test.ts

@@ -0,0 +1,211 @@
+// This file contains `declare module "vscode"` so we must import it.
+import "../../providers/vscode-lm"
+import { describe, it } from "mocha"
+import "should"
+import * as vscode from "vscode"
+import { Anthropic } from "@anthropic-ai/sdk"
+import { asObjectSafe, convertToAnthropicRole, convertToVsCodeLmMessages, convertToAnthropicMessage } from "../vscode-lm-format"
+
+describe("asObjectSafe", () => {
+	it("should handle falsy values", () => {
+		asObjectSafe(0).should.deepEqual({})
+		asObjectSafe("").should.deepEqual({})
+		asObjectSafe(null).should.deepEqual({})
+		asObjectSafe(undefined).should.deepEqual({})
+	})
+
+	it("should parse valid JSON strings", () => {
+		asObjectSafe('{"key": "value"}').should.deepEqual({ key: "value" })
+	})
+
+	it("should return an empty object for invalid JSON strings", () => {
+		asObjectSafe("invalid json").should.deepEqual({})
+	})
+
+	it("should convert objects to plain objects", () => {
+		const input = { prop: "value" }
+		asObjectSafe(input).should.deepEqual(input)
+		asObjectSafe(input).should.not.equal(input) // Should be a new object
+	})
+
+	it("should convert arrays to plain objects", () => {
+		const input = ["hello world"]
+		asObjectSafe(input).should.deepEqual({ 0: "hello world" })
+	})
+})
+
+describe("convertToAnthropicRole", () => {
+	it("should convert VSCode roles to Anthropic roles", () => {
+		// @ts-expect-error（Testing with an invalid role）
+		const unknownRole = "unknown" as vscode.LanguageModelChatMessageRole
+		;(convertToAnthropicRole(vscode.LanguageModelChatMessageRole.Assistant) === "assistant").should.be.true()
+		;(convertToAnthropicRole(vscode.LanguageModelChatMessageRole.User) === "user").should.be.true()
+		;(convertToAnthropicRole(unknownRole) === null).should.be.true()
+	})
+})
+
+describe("convertToVsCodeLmMessages", () => {
+	it("should convert simple string messages", () => {
+		const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+			{ role: "user", content: "Hello" },
+			{ role: "assistant", content: "Hi there" },
+		]
+
+		const result = convertToVsCodeLmMessages(anthropicMessages)
+
+		result.should.have.length(2)
+		result[0].role.should.equal(vscode.LanguageModelChatMessageRole.User)
+		result[0].content[0].should.be.instanceof(vscode.LanguageModelTextPart)
+		const textPart0 = result[0].content[0] as vscode.LanguageModelTextPart
+		textPart0.should.have.property("value", "Hello")
+
+		result[1].role.should.equal(vscode.LanguageModelChatMessageRole.Assistant)
+		result[1].content[0].should.be.instanceof(vscode.LanguageModelTextPart)
+		const textPart1 = result[1].content[0] as vscode.LanguageModelTextPart
+		textPart1.should.have.property("value", "Hi there")
+	})
+
+	it("should convert complex user messages with tool results", () => {
+		const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "User text" },
+					{
+						type: "tool_result",
+						tool_use_id: "tool-123",
+						content: [{ type: "text", text: "Tool result" }],
+					},
+				],
+			},
+		]
+
+		const result = convertToVsCodeLmMessages(anthropicMessages)
+
+		result.should.have.length(1)
+		result[0].role.should.equal(vscode.LanguageModelChatMessageRole.User)
+		result[0].content.should.have.length(2)
+
+		// Check that the first content part is a ToolResultPart
+		result[0].content[0].should.be.instanceof(vscode.LanguageModelToolResultPart)
+		const toolResultPart = result[0].content[0] as vscode.LanguageModelToolResultPart
+		toolResultPart.should.have.property("callId", "tool-123")
+
+		// Skip detailed testing of internal structure as it may vary
+		// Just verify it's the right type with the right ID
+
+		// Check the second content part is a TextPart
+		result[0].content[1].should.be.instanceof(vscode.LanguageModelTextPart)
+		const textPart = result[0].content[1] as vscode.LanguageModelTextPart
+		textPart.should.have.property("value", "User text")
+	})
+
+	it("should convert complex assistant messages with tool calls", () => {
+		const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+			{
+				role: "assistant",
+				content: [
+					{ type: "text", text: "Assistant text" },
+					{
+						type: "tool_use",
+						id: "tool-123",
+						name: "testTool",
+						input: { param: "value" },
+					},
+				],
+			},
+		]
+
+		const result = convertToVsCodeLmMessages(anthropicMessages)
+
+		result.should.have.length(1)
+		result[0].role.should.equal(vscode.LanguageModelChatMessageRole.Assistant)
+		result[0].content.should.have.length(2)
+
+		result[0].content[0].should.be.instanceof(vscode.LanguageModelToolCallPart)
+		const toolCallPart = result[0].content[0] as vscode.LanguageModelToolCallPart
+		toolCallPart.should.have.property("callId", "tool-123")
+		toolCallPart.should.have.property("name", "testTool")
+		toolCallPart.should.have.property("input")
+		toolCallPart.input.should.deepEqual({ param: "value" })
+
+		result[0].content[1].should.be.instanceof(vscode.LanguageModelTextPart)
+		const textPart = result[0].content[1] as vscode.LanguageModelTextPart
+		textPart.should.have.property("value", "Assistant text")
+	})
+
+	it("should handle image blocks with appropriate placeholders", () => {
+		const anthropicMessages: Anthropic.Messages.MessageParam[] = [
+			{
+				role: "user",
+				content: [
+					{
+						type: "image",
+						source: {
+							type: "base64",
+							media_type: "image/jpeg",
+							data: "base64data",
+						},
+					},
+				],
+			},
+		]
+
+		const result = convertToVsCodeLmMessages(anthropicMessages)
+
+		result.should.have.length(1)
+		result[0].content[0].should.be.instanceof(vscode.LanguageModelTextPart)
+		const textPart = result[0].content[0] as vscode.LanguageModelTextPart
+		textPart.should.have.property("value")
+		textPart.value.should.match(/Image \(base64\): image\/jpeg not supported by VSCode LM API/)
+	})
+})
+
+describe("convertToAnthropicMessage", () => {
+	it("should convert VSCode assistant messages to Anthropic format", () => {
+		const vsCodeMsg = vscode.LanguageModelChatMessage.Assistant([
+			new vscode.LanguageModelTextPart("Test message"),
+			new vscode.LanguageModelToolCallPart("tool-id", "testTool", { param: "value" }),
+		])
+
+		const result = convertToAnthropicMessage(vsCodeMsg)
+
+		result.should.have.property("role", "assistant")
+		result.should.have.property("content").which.is.an.Array()
+		result.content.should.have.length(2)
+
+		// Check properties carefully to avoid null reference errors
+		if (result.content && result.content.length >= 1) {
+			const textContent = result.content[0]
+			if (textContent) {
+				textContent.should.have.property("type", "text")
+				if (textContent.type === "text") {
+					textContent.should.have.property("text", "Test message")
+				}
+			}
+		}
+
+		if (result.content && result.content.length >= 2) {
+			const toolContent = result.content[1]
+			if (toolContent) {
+				toolContent.should.have.property("type", "tool_use")
+				if (toolContent.type === "tool_use") {
+					toolContent.should.have.property("id", "tool-id")
+					toolContent.should.have.property("name", "testTool")
+					toolContent.should.have.property("input").which.deepEqual({ param: "value" })
+				}
+			}
+		}
+	})
+
+	it("should throw an error for non-assistant messages", () => {
+		const vsCodeMsg = vscode.LanguageModelChatMessage.User("User message")
+
+		try {
+			convertToAnthropicMessage(vsCodeMsg)
+			throw new Error("Should have thrown an error")
+		} catch (error: any) {
+			error.message.should.match(/Only assistant messages are supported/)
+		}
+	})
+})

src/api/transform/gemini-format.ts

@@ -1,14 +1,14 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import { Content, GenerateContentResponse, Part } from "@google/genai"
+import { Content, EnhancedGenerateContentResponse, InlineDataPart, Part, TextPart } from "@google/generative-ai"
 
 export function convertAnthropicContentToGemini(content: string | Anthropic.ContentBlockParam[]): Part[] {
 	if (typeof content === "string") {
-		return [{ text: content }]
+		return [{ text: content } as TextPart]
 	}
-	return content.flatMap((block): Part => {
+	return content.flatMap((block) => {
 		switch (block.type) {
 			case "text":
-				return { text: block.text }
+				return { text: block.text } as TextPart
 			case "image":
 				if (block.source.type !== "base64") {
 					throw new Error("Unsupported image source type")
@@ -18,7 +18,7 @@ export function convertAnthropicContentToGemini(content: string | Anthropic.Cont
 						data: block.source.data,
 						mimeType: block.source.media_type,
 					},
-				}
+				} as InlineDataPart
 			default:
 				throw new Error(`Unsupported content block type: ${block.type}`)
 		}
@@ -39,14 +39,16 @@ export function unescapeGeminiContent(content: string) {
 	return content.replace(/\\n/g, "\n").replace(/\\'/g, "'").replace(/\\"/g, '"').replace(/\\r/g, "\r").replace(/\\t/g, "\t")
 }
 
-export function convertGeminiResponseToAnthropic(response: GenerateContentResponse): Anthropic.Messages.Message {
+export function convertGeminiResponseToAnthropic(response: EnhancedGenerateContentResponse): Anthropic.Messages.Message {
 	const content: Anthropic.Messages.ContentBlock[] = []
 
-	const text = response.text
+	// Add the main text response
+	const text = response.text()
 	if (text) {
 		content.push({ type: "text", text, citations: null })
 	}
 
+	// Determine stop reason
 	let stop_reason: Anthropic.Messages.Message["stop_reason"] = null
 	const finishReason = response.candidates?.[0]?.finishReason
 	if (finishReason) {
@@ -62,11 +64,12 @@ export function convertGeminiResponseToAnthropic(response: GenerateContentRespon
 			case "OTHER":
 				stop_reason = "stop_sequence"
 				break
+			// Add more cases if needed
 		}
 	}
 
 	return {
-		id: `msg_${Date.now()}`,
+		id: `msg_${Date.now()}`, // Generate a unique ID
 		type: "message",
 		role: "assistant",
 		content,

src/api/transform/openrouter-stream.ts

@@ -1,8 +1,10 @@
-import { ModelInfo } from "@shared/api"
-import { convertToOpenAiMessages } from "@api/transform/openai-format"
-import { convertToR1Format } from "@api/transform/r1-format"
+import { ModelInfo } from "../../shared/api"
+import { convertToOpenAiMessages } from "./openai-format"
+import { convertToR1Format } from "./r1-format"
+import { ApiStream, ApiStreamChunk } from "./stream"
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
+import { OpenRouterErrorResponse } from "../providers/types"
 
 export async function createOpenRouterStream(
 	client: OpenAI,
@@ -20,8 +22,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
+	// this is specifically for claude models (some models may 'support prompt caching' automatically without this)
 	switch (model.id) {
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":
@@ -40,10 +41,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: [

src/core/assistant-message/diff.test.ts

@@ -1,178 +0,0 @@
-import { constructNewFileContent as cnfc2 } from "./diff"
-import { describe, it } from "mocha"
-import { expect } from "chai"
-
-async function cnfc(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
-	return cnfc2(diffContent, originalContent, isFinal, "v1")
-}
-
-describe("constructNewFileContent", () => {
-	const testCases = [
-		{
-			name: "empty file",
-			original: "",
-			diff: `<<<<<<< SEARCH
-=======
-new content
->>>>>>> REPLACE`,
-			expected: "new content\n",
-			isFinal: true,
-		},
-		{
-			name: "full file replacement",
-			original: "old content",
-			diff: `<<<<<<< SEARCH
-=======
-new content
->>>>>>> REPLACE`,
-			expected: "new content\n",
-			isFinal: true,
-		},
-		{
-			name: "exact match replacement",
-			original: "line1\nline2\nline3",
-			diff: `<<<<<<< SEARCH
-line2
-=======
-replaced
->>>>>>> REPLACE`,
-			expected: "line1\nreplaced\nline3",
-			isFinal: true,
-		},
-		{
-			name: "line-trimmed match replacement",
-			original: "line1\n line2 \nline3",
-			diff: `<<<<<<< SEARCH
-line2
-=======
-replaced
->>>>>>> REPLACE`,
-			expected: "line1\nreplaced\nline3",
-			isFinal: true,
-		},
-		{
-			name: "block anchor match replacement",
-			original: "line1\nstart\nmiddle\nend\nline5",
-			diff: `<<<<<<< SEARCH
-start
-middle
-end
-=======
-replaced
->>>>>>> REPLACE`,
-			expected: "line1\nreplaced\nline5",
-			isFinal: true,
-		},
-		{
-			name: "incremental processing",
-			original: "line1\nline2\nline3",
-			diff: [
-				`<<<<<<< SEARCH
-line2
-=======`,
-				"replaced\n",
-				">>>>>>> REPLACE",
-			].join("\n"),
-			expected: "line1\nreplaced\n\nline3",
-			isFinal: true,
-		},
-		{
-			name: "final chunk with remaining content",
-			original: "line1\nline2\nline3",
-			diff: `<<<<<<< SEARCH
-line2
-=======
-replaced
->>>>>>> REPLACE`,
-			expected: "line1\nreplaced\nline3",
-			isFinal: true,
-		},
-		{
-			name: "multiple ordered replacements",
-			original: "First\nSecond\nThird\nFourth",
-			diff: `<<<<<<< SEARCH
-First
-=======
-1st
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-Third
-=======
-3rd
->>>>>>> REPLACE`,
-			expected: "1st\nSecond\n3rd\nFourth",
-			isFinal: true,
-		},
-		{
-			name: "replace then delete",
-			original: "line1\nline2\nline3\nline4",
-			diff: `<<<<<<< SEARCH
-line2
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-line4
-=======
->>>>>>> REPLACE`,
-			expected: "line1\nreplaced\nline3\n",
-			isFinal: true,
-		},
-		{
-			name: "delete then replace",
-			original: "line1\nline2\nline3\nline4",
-			diff: `<<<<<<< SEARCH
-line1
-=======
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-line3
-=======
-replaced
->>>>>>> REPLACE`,
-			expected: "line2\nreplaced\nline4",
-			isFinal: true,
-		},
-	]
-	//.filter(({name}) => name === "multiple ordered replacements")
-	//.filter(({name}) => name === "delete then replace")
-	testCases.forEach(({ name, original, diff, expected, isFinal }) => {
-		it(`should handle ${name} case correctly`, async () => {
-			const result1 = await cnfc(diff, original, isFinal)
-			const result2 = await cnfc2(diff, original, isFinal)
-			const equal = result1 === result2
-			const equal2 = result1 === expected
-			// Verify both implementations produce same result
-			expect(result1).to.equal(result2)
-
-			// Verify result matches expected
-			expect(result1).to.equal(expected)
-		})
-	})
-
-	it("should throw error when no match found", async () => {
-		const original = "line1\nline2\nline3"
-		const diff = `<<<<<<< SEARCH
-non-existent
-=======
-replaced
->>>>>>> REPLACE`
-
-		try {
-			await cnfc(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-})

src/core/assistant-message/diff.ts

@@ -200,31 +200,7 @@ function blockAnchorFallbackMatch(originalContent: string, searchContent: string
  * - If the search block cannot be matched using any of the available matching strategies,
  *   an error is thrown.
  */
-export async function constructNewFileContent(
-	diffContent: string,
-	originalContent: string,
-	isFinal: boolean,
-	version: "v1" | "v2" = "v2",
-): Promise<string> {
-	const constructor = constructNewFileContentVersionMapping[version]
-	if (!constructor) {
-		throw new Error(`Invalid version '${version}' for file content constructor`)
-	}
-	return constructor(diffContent, originalContent, isFinal)
-}
-
-const constructNewFileContentVersionMapping: Record<
-	string,
-	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
-> = {
-	v1: constructNewFileContentV1,
-	v2: constructNewFileContentV2,
-} as const
-
-/**
- * @deprecated
- */
-async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+export async function constructNewFileContent(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
 	let result = ""
 	let lastProcessedIndex = 0
 
@@ -365,359 +341,3 @@ async function constructNewFileContentV1(diffContent: string, originalContent: s
 
 	return result
 }
-
-enum ProcessingState {
-	Idle = 0,
-	StateSearch = 1 << 0,
-	StateReplace = 1 << 1,
-}
-
-class NewFileContentConstructor {
-	private originalContent: string
-	private isFinal: boolean
-	private state: number
-	private pendingNonStandardLines: string[]
-	private result: string
-	private lastProcessedIndex: number
-	private currentSearchContent: string
-	private currentReplaceContent: string
-	private searchMatchIndex: number
-	private searchEndIndex: number
-
-	constructor(originalContent: string, isFinal: boolean) {
-		this.originalContent = originalContent
-		this.isFinal = isFinal
-		this.pendingNonStandardLines = []
-		this.result = ""
-		this.lastProcessedIndex = 0
-		this.state = ProcessingState.Idle
-		this.currentSearchContent = ""
-		this.currentReplaceContent = ""
-		this.searchMatchIndex = -1
-		this.searchEndIndex = -1
-	}
-
-	private resetForNextBlock() {
-		// Reset for next block
-		this.state = ProcessingState.Idle
-		this.currentSearchContent = ""
-		this.currentReplaceContent = ""
-		this.searchMatchIndex = -1
-		this.searchEndIndex = -1
-	}
-
-	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
-		for (let i = lineLimit; i > 0; ) {
-			i--
-			if (this.pendingNonStandardLines[i].match(regx)) {
-				return i
-			}
-		}
-		return -1
-	}
-
-	private updateProcessingState(newState: ProcessingState) {
-		const isValidTransition =
-			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
-			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
-
-		if (!isValidTransition) {
-			throw new Error(
-				`Invalid state transition.\n` +
-					"Valid transitions are:\n" +
-					"- Idle → StateSearch\n" +
-					"- StateSearch → StateReplace",
-			)
-		}
-
-		this.state |= newState
-	}
-
-	private isStateActive(state: ProcessingState): boolean {
-		return (this.state & state) === state
-	}
-
-	private activateReplaceState() {
-		this.updateProcessingState(ProcessingState.StateReplace)
-	}
-
-	private activateSearchState() {
-		this.updateProcessingState(ProcessingState.StateSearch)
-		this.currentSearchContent = ""
-		this.currentReplaceContent = ""
-	}
-
-	private isSearchingActive(): boolean {
-		return this.isStateActive(ProcessingState.StateSearch)
-	}
-
-	private isReplacingActive(): boolean {
-		return this.isStateActive(ProcessingState.StateReplace)
-	}
-
-	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
-		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
-	}
-
-	public processLine(line: string) {
-		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
-	}
-
-	public getResult() {
-		// If this is the final chunk, append any remaining original content
-		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
-			this.result += this.originalContent.slice(this.lastProcessedIndex)
-		}
-		if (this.isFinal && this.state !== ProcessingState.Idle) {
-			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
-		}
-		return this.result
-	}
-
-	private internalProcessLine(
-		line: string,
-		canWritependingNonStandardLines: boolean,
-		pendingNonStandardLineLimit: number,
-	): number {
-		let removeLineCount = 0
-		if (line === "<<<<<<< SEARCH") {
-			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
-			if (removeLineCount > 0) {
-				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
-			}
-			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
-				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
-				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
-			}
-			this.activateSearchState()
-		} else if (line === "=======") {
-			// 校验非标内容
-			if (!this.isSearchingActive()) {
-				this.tryFixSearchBlock(pendingNonStandardLineLimit)
-				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
-			}
-			this.activateReplaceState()
-			this.beforeReplace()
-		} else if (line === ">>>>>>> REPLACE") {
-			if (!this.isReplacingActive()) {
-				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
-				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
-			}
-			this.lastProcessedIndex = this.searchEndIndex
-			this.resetForNextBlock()
-		} else {
-			// Accumulate content for search or replace
-			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
-			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
-			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
-			if (this.isReplacingActive()) {
-				this.currentReplaceContent += line + "\n"
-				// Output replacement lines immediately if we know the insertion point
-				if (this.searchMatchIndex !== -1) {
-					this.result += line + "\n"
-				}
-			} else if (this.isSearchingActive()) {
-				this.currentSearchContent += line + "\n"
-			} else {
-				let appendToPendingNonStandardLines = canWritependingNonStandardLines
-				if (appendToPendingNonStandardLines) {
-					console.log("unstandard line:" + line)
-					// 处理非标内容
-					this.pendingNonStandardLines.push(line)
-				}
-			}
-		}
-		return removeLineCount
-	}
-
-	private beforeReplace() {
-		// Remove trailing linebreak for adding the === marker
-		// if (currentSearchContent.endsWith("\r\n")) {
-		// 	currentSearchContent = currentSearchContent.slice(0, -2)
-		// } else if (currentSearchContent.endsWith("\n")) {
-		// 	currentSearchContent = currentSearchContent.slice(0, -1)
-		// }
-
-		if (!this.currentSearchContent) {
-			// Empty search block
-			if (this.originalContent.length === 0) {
-				// New file scenario: nothing to match, just start inserting
-				this.searchMatchIndex = 0
-				this.searchEndIndex = 0
-			} else {
-				// Complete file replacement scenario: treat the entire file as matched
-				this.searchMatchIndex = 0
-				this.searchEndIndex = this.originalContent.length
-			}
-		} else {
-			// Add check for inefficient full-file search
-			// if (currentSearchContent.trim() === originalContent.trim()) {
-			// 	throw new Error(
-			// 		"The SEARCH block contains the entire file content. Please either:\n" +
-			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
-			// 			"2. Make focused changes to specific parts of the file that need modification.",
-			// 	)
-			// }
-			// Exact search match scenario
-			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
-			if (exactIndex !== -1) {
-				this.searchMatchIndex = exactIndex
-				this.searchEndIndex = exactIndex + this.currentSearchContent.length
-			} else {
-				// Attempt fallback line-trimmed matching
-				const lineMatch = lineTrimmedFallbackMatch(
-					this.originalContent,
-					this.currentSearchContent,
-					this.lastProcessedIndex,
-				)
-				if (lineMatch) {
-					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
-				} else {
-					// Try block anchor fallback for larger blocks
-					const blockMatch = blockAnchorFallbackMatch(
-						this.originalContent,
-						this.currentSearchContent,
-						this.lastProcessedIndex,
-					)
-					if (blockMatch) {
-						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
-					} else {
-						throw new Error(
-							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
-						)
-					}
-				}
-			}
-		}
-		if (this.searchMatchIndex < this.lastProcessedIndex) {
-			throw new Error(
-				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
-			)
-		}
-		// Output everything up to the match location
-		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
-	}
-
-	private tryFixSearchBlock(lineLimit: number): number {
-		let removeLineCount = 0
-		if (lineLimit < 0) {
-			lineLimit = this.pendingNonStandardLines.length
-		}
-		if (!lineLimit) {
-			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
-		}
-		let searchTagRegexp = /^[<]{3,} SEARCH$/
-		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
-		if (searchTagIndex !== -1) {
-			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
-			fixLines[0] = "<<<<<<< SEARCH"
-			for (const line of fixLines) {
-				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
-			}
-		} else {
-			throw new Error(
-				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
-			)
-		}
-		return removeLineCount
-	}
-
-	private tryFixReplaceBlock(lineLimit: number): number {
-		let removeLineCount = 0
-		if (lineLimit < 0) {
-			lineLimit = this.pendingNonStandardLines.length
-		}
-		if (!lineLimit) {
-			throw new Error()
-		}
-		let replaceBeginTagRegexp = /^[=]{3,}$/
-		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
-		if (replaceBeginTagIndex !== -1) {
-			// // 校验非标内容
-			// if (!this.isSearchingActive()) {
-			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
-			// }
-			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
-			fixLines[0] = "======="
-			for (const line of fixLines) {
-				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
-			}
-		} else {
-			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
-		}
-		return removeLineCount
-	}
-
-	private tryFixSearchReplaceBlock(lineLimit: number): number {
-		let removeLineCount = 0
-		if (lineLimit < 0) {
-			lineLimit = this.pendingNonStandardLines.length
-		}
-		if (!lineLimit) {
-			throw new Error()
-		}
-
-		let replaceEndTagRegexp = /^[>]{3,} REPLACE$/
-		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
-		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
-		if (likeReplaceEndTag) {
-			// // 校验非标内容
-			// if (!this.isReplacingActive()) {
-			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
-			// }
-			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
-			fixLines[fixLines.length - 1] = ">>>>>>> REPLACE"
-			for (const line of fixLines) {
-				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
-			}
-		} else {
-			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
-		}
-		return removeLineCount
-	}
-
-	/**
-	 * Removes trailing empty lines from the pendingNonStandardLines array
-	 * @param lineLimit - The index to start checking from (exclusive).
-	 *                    Removes empty lines from lineLimit-1 backwards.
-	 * @returns The number of empty lines removed
-	 */
-	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
-		let removedCount = 0
-		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
-
-		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
-			this.pendingNonStandardLines.pop()
-			removedCount++
-			i--
-		}
-
-		return removedCount
-	}
-}
-
-export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
-	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
-
-	let lines = diffContent.split("\n")
-
-	// If the last line looks like a partial marker but isn't recognized,
-	// remove it because it might be incomplete.
-	const lastLine = lines[lines.length - 1]
-	if (
-		lines.length > 0 &&
-		(lastLine.startsWith("<") || lastLine.startsWith("=") || lastLine.startsWith(">")) &&
-		lastLine !== "<<<<<<< SEARCH" &&
-		lastLine !== "=======" &&
-		lastLine !== ">>>>>>> REPLACE"
-	) {
-		lines.pop()
-	}
-
-	for (const line of lines) {
-		newFileContentConstructor.processLine(line)
-	}
-
-	let result = newFileContentConstructor.getResult()
-	return result
-}

src/core/assistant-message/diff_edge_cases.test.ts

@@ -1,131 +0,0 @@
-import { constructNewFileContent as cnfc2 } from "./diff"
-import { describe, it } from "mocha"
-import { expect } from "chai"
-
-async function cnfc(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
-	return cnfc2(diffContent, originalContent, isFinal, "v1")
-}
-
-describe("Diff Format Edge Cases", () => {
-	it("should handle SEARCH prefix symbols < less than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<< SEARCH
-content
-=======
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("new content\n")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle SEARCH prefix symbols < more than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<<<<<<<< SEARCH
-content
-=======
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("new content\n")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle SEARCH < less than 7 and REPLACE = less than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<< SEARCH
-content
-=====
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("r")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle SEARCH < less than 7 and REPLACE = more than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<< SEARCH
-content
-========
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("r")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle SEARCH < more than 7 and REPLACE = more than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<<<<<<<< SEARCH
-content
-==========
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("r")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle SEARCH < more than 7 and REPLACE = less than 7", async () => {
-		const isFinal = true
-		const original = "before\ncontent\nafter"
-		const diff = `<<<<<<<<<<< SEARCH
-content
-=====
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("r")
-		expect(result2).to.equal("before\nnew content\nafter")
-	})
-
-	it("should handle consecutive SEARCH-REPLACE with second block SEARCH < less than 7", async () => {
-		const isFinal = true
-		const original = "before\nfirst content\nafter\nsecond content\nend"
-		const diff = `<<<<<<< SEARCH
-first content
-=======
-first new content
->>>>>>> REPLACE
-<<<<< SEARCH
-second content
-=======
-second new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("before\nfirst new content\nsecond new content\n")
-		expect(result2).to.equal("before\nfirst new content\nafter\nsecond new content\nend")
-	})
-
-	it("should handle consecutive SEARCH-REPLACE with second block SEARCH < less than 7 and REPLACE = less than 7", async () => {
-		const isFinal = true
-		const original = "before\nfirst content\nafter\nsecond content\nend"
-		const diff = `<<<<<<< SEARCH
-first content
-=======
-first new content
->>>>>>> REPLACE
-<<<<< SEARCH
-second content
-=====
-second new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, isFinal)
-		const result2 = await cnfc2(diff, original, isFinal)
-		expect(result1).to.equal("before\nfirst new content\nd")
-		expect(result2).to.equal("before\nfirst new content\nafter\nsecond new content\nend")
-	})
-})

src/core/assistant-message/diff_edge_cases2.test.ts

@@ -1,361 +0,0 @@
-import { constructNewFileContent as cnfc2 } from "./diff"
-import { describe, it } from "mocha"
-import { expect } from "chai"
-
-async function cnfc(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
-	return cnfc2(diffContent, originalContent, isFinal, "v1")
-}
-
-describe("Diff Format Edge Cases", () => {
-	it("should handle missing search block", async () => {
-		const original = "line1\nline2"
-		const diff = `=======
-new content
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("new content\n")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("should handle consecutive search blocks", async () => {
-		const original = "text"
-		const diff = `<<<<<<< SEARCH
-=======
-replaced
->>>>>>> REPLACE
-<<<<<<< SEARCH
-=======
-another
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("replaced\nanother\n")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("should handle reverse markers order", async () => {
-		const original = "content"
-		const diff = `>>>>>>> SEARCH
-=======
-invalid
-<<<<<<< REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("invalid\ncontent")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("should handle incomplete block structure", async () => {
-		const original = "valid text"
-		const diff = `<<<<<<< SEARCH
-text
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("t")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("should handle empty search block", async () => {
-		const original = "any content"
-		const diff = `<<<<<<< SEARCH
-=======
-inserted
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("inserted\n")
-		expect(result1).to.equal(result2)
-	})
-
-	it("should handle mixed line endings", async () => {
-		const original = "line1\r\nline2"
-		const diff = `<<<<<<< SEARCH
-line1\r
-=======
-line1
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("line1\nline2")
-		expect(result1).to.equal(result2)
-	})
-
-	it("should handle special characters in search", async () => {
-		const original = "text with $^.*\nend"
-		const diff = `<<<<<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("text with replaced\nend")
-		expect(result1).to.equal(result2)
-	})
-
-	it("should handle special regex chars and nested search markers", async () => {
-		const original = `text with $^.*\n<<< SEARCH\nend`
-		const diff = `<<<<<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-<<< SEARCH
-=======
-before
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("text with replaced\nbefore\nend")
-		expect(result1).to.equal(result2)
-	})
-
-	it("cnfc2 should handle invalid search marker format", async () => {
-		const original = `text with $^.*\n<<< SEARCH\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-<<< SEARCH
-=======
-before
->>>>>>> REPLACE`
-		try {
-			await cnfc(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-		const result2 = await cnfc2(diff, original, true)
-		expect(result2).to.equal("text with replaced\nbefore\nend")
-	})
-
-	it("cnfc2 should throw error for incomplete search marker", async () => {
-		const original = `text with $^.*\n<<< SEARCH\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-<<< SEARCH
-=======
-before
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("replaced\nbefore\n")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("cnfc2 should handle custom nested search markers", async () => {
-		const original = `text with $^.*\n<<< SEARCH2\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-<<< SEARCH2
-=======
-before
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("replaced\nbefore\n")
-		expect(result2).to.equal("text with replaced\nbefore\nend")
-	})
-
-	it("cnfc2 should handle text containing nested search markers", async () => {
-		const original = `text with $^.*\ntext with <<< SEARCH2\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-text with <<< SEARCH2
-=======
-before
->>>>>>> REPLACE`
-		const result1 = await cnfc(diff, original, true)
-		const result2 = await cnfc2(diff, original, true)
-		expect(result1).to.equal("replaced\nbefore\n")
-		expect(result2).to.equal("text with replaced\nbefore\nend")
-	})
-
-	it("cnfc2 should handle missing replacement marker in lenient mode", async () => {
-		const original = `text with $^.*\ntext with <<< SEARCH2\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-text with <<< SEARCH2
-=======
-before`
-		const result1 = await cnfc(diff, original, false)
-		const result2 = await cnfc2(diff, original, false)
-		expect(result1).to.equal("replaced\nbefore\n")
-		expect(result2).to.equal("text with replaced\nbefore\n")
-	})
-
-	it("cnfc2 should throw error for missing replacement marker in strict mode", async () => {
-		const original = `text with $^.*\ntext with <<< SEARCH2\nend`
-		const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-text with <<< SEARCH2
-=======
-before`
-		const result1 = await cnfc(diff, original, true)
-		expect(result1).to.equal("replaced\nbefore\n")
-		try {
-			await cnfc2(diff, original, true)
-			expect.fail("Expected an error to be thrown")
-		} catch (err) {
-			expect(err).to.be.an("error")
-		}
-	})
-
-	it("cnfc2 should handle long text with multiple search-replace blocks", async () => {
-		const original = `This is a long text with multiple sections.
-Section 1: Lorem ipsum dolor sit amet
-Section 2: consectetur adipiscing elit
-Section 3: sed do eiusmod tempor
-Section 4: incididunt ut labore
-Section 5: et dolore magna aliqua`
-
-		const diff = `<<< SEARCH
-Section 1: Lorem ipsum dolor sit amet
-=======
-Section 1: Replaced text
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-Section 3: sed do eiusmod tempor
-=======
-Section 3: Modified content
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-Section 5: et dolore magna aliqua
-=======
-Section 5: Final replacement
->>>>>>> REPLACE`
-
-		const expected = `This is a long text with multiple sections.
-Section 1: Replaced text
-Section 2: consectetur adipiscing elit
-Section 3: Modified content
-Section 4: incididunt ut labore
-Section 5: Final replacement
-`
-
-		const result = await cnfc2(diff, original, true)
-		expect(result).to.equal(expected)
-	})
-
-	// Test diff containing special regex characters and nested search markers
-	const diff = `<<< SEARCH
-$^.*
-=======
-replaced
->>>>>>> REPLACE
-
-<<<<<< SEARCH
-<<< SEARCH
-=======
-before
->>>>>>> REPLACE`
-	// expected1 shows the incremental results when processing the diff line by line
-	// Each element represents the result after processing that line number
-	const expected1 = [
-		"",
-		"",
-		"",
-		"replaced\n",
-		"replaced\n",
-		"replaced\n",
-		"replaced\n",
-		"replaced\n",
-		"replaced\n",
-		"replaced\nbefore\n",
-	]
-	// expected2 shows the results when processing with original content
-	// Each element represents the result after processing that line number
-	const expected2 = [
-		"",
-		"",
-		"text with ",
-		"text with replaced\n",
-		"text with replaced\n",
-		"text with replaced\n",
-		"text with replaced\n",
-		"text with replaced\n",
-		new Error(),
-		new Error(),
-	]
-	const diffLines = diff.split("\n")
-	for (let i = 1; i < diffLines.length; i++) {
-		it(`cnfc2 should handle partial diff configuration (line ${i})`, async () => {
-			const original = `text with $^.*\n<<< SEARCH\nend`
-			const result1 = await cnfc(diffLines.slice(0, i).join("\n"), original, i === diffLines.length - 1)
-			expect(result1).to.equal(expected1[i - 1])
-		})
-	}
-
-	for (let i = 1; i < diffLines.length; i++) {
-		it(`cnfc2 should handle partial diff configuration (line ${i})`, async () => {
-			const original = `text with $^.*\n<<< SEARCH\nend`
-			let expected = expected2[i - 1]
-			if (expected instanceof Error) {
-				try {
-					await cnfc2(diffLines.slice(0, i).join("\n"), original, true)
-					expect.fail("Expected an error to be thrown")
-				} catch (err) {
-					expect(err).to.be.an("error")
-				}
-			} else {
-				const result2 = await cnfc2(diffLines.slice(0, i).join("\n"), original, i === diffLines.length - 1)
-				expect(result2).to.equal(expected)
-			}
-		})
-	}
-})

src/core/assistant-message/index.ts

@@ -24,7 +24,6 @@ export const toolUseNames = [
 	"load_mcp_documentation",
 	"attempt_completion",
 	"new_task",
-	"condense",
 ] as const
 
 // Converts array of tool call names into a union type ("execute_command" | "read_file" | ...)

src/core/assistant-message/parse-assistant-message.ts

@@ -123,7 +123,7 @@ export function parseAssistantMessage(assistantMessage: string) {
 		contentBlocks.push(currentToolUse)
 	}
 
-	// Note: it doesn't matter if check for currentToolUse or currentTextContent, only one of them will be defined since only one can be partial at a time
+	// Note: it doesnt matter if check for currentToolUse or currentTextContent, only one of them will be defined since only one can be partial at a time
 	if (currentTextContent) {
 		// stream did not complete text content, add it as partial
 		contentBlocks.push(currentTextContent)

src/core/context/context-management/ContextManager-legacy.ts

@@ -1,6 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import { ClineApiReqInfo, ClineMessage } from "@shared/ExtensionMessage"
-import { ApiHandler } from "@api/index"
+import { ClineApiReqInfo, ClineMessage } from "../../../shared/ExtensionMessage"
+import { ApiHandler } from "../../../api"
 import { getContextWindowInfo } from "./context-window-utils"
 
 class ContextManager {

src/core/context/context-management/ContextManager.ts

@@ -1,12 +1,12 @@
 import { getContextWindowInfo } from "./context-window-utils"
-import { formatResponse } from "@core/prompts/responses"
-import { GlobalFileNames } from "@core/storage/disk"
-import { fileExistsAtPath } from "@utils/fs"
+import { formatResponse } from "../../prompts/responses"
+import { GlobalFileNames } from "../../storage/disk"
+import { fileExistsAtPath } from "../../../utils/fs"
 import * as path from "path"
 import fs from "fs/promises"
 import cloneDeep from "clone-deep"
-import { ClineApiReqInfo, ClineMessage } from "@shared/ExtensionMessage"
-import { ApiHandler } from "@api/index"
+import { ClineApiReqInfo, ClineMessage } from "../../../shared/ExtensionMessage"
+import { ApiHandler } from "../../../api"
 import { Anthropic } from "@anthropic-ai/sdk"
 
 enum EditType {
@@ -193,20 +193,14 @@ export class ContextManager {
 	public getNextTruncationRange(
 		apiMessages: Anthropic.Messages.MessageParam[],
 		currentDeletedRange: [number, number] | undefined,
-		keep: "none" | "lastTwo" | "half" | "quarter",
+		keep: "half" | "quarter",
 	): [number, number] {
 		// We always keep the first user-assistant pairing, and truncate an even number of messages from there
 		const rangeStartIndex = 2 // index 0 and 1 are kept
 		const startOfRest = currentDeletedRange ? currentDeletedRange[1] + 1 : 2 // inclusive starting index
 
 		let messagesToRemove: number
-		if (keep === "none") {
-			// Removes all messages beyond the first core user/assistant message pair
-			messagesToRemove = Math.max(apiMessages.length - startOfRest, 0)
-		} else if (keep === "lastTwo") {
-			// Keep the last user-assistant pair in addition to the first core user/assistant message pair
-			messagesToRemove = Math.max(apiMessages.length - startOfRest - 2, 0)
-		} else if (keep === "half") {
+		if (keep === "half") {
 			// Remove half of remaining user-assistant pairs
 			// We first calculate half of the messages then divide by 2 to get the number of pairs.
 			// After flooring, we multiply by 2 to get the number of messages.
@@ -388,17 +382,6 @@ export class ContextManager {
 		return [contextHistoryUpdated, uniqueFileReadIndices]
 	}
 
-	/**
-	 * Public function for triggering potentially setting the truncation message
-	 * If the truncation message already exists, does nothing, otherwise adds the message
-	 */
-	async triggerApplyStandardContextTruncationNoticeChange(timestamp: number, taskDirectory: string) {
-		const updated = this.applyStandardContextTruncationNoticeChange(timestamp)
-		if (updated) {
-			await this.saveContextHistory(taskDirectory)
-		}
-	}
-
 	/**
 	 * if there is any truncation and there is no other alteration already set, alter the assistant message to indicate this occurred
 	 */
@@ -554,7 +537,7 @@ export class ContextManager {
 
 			// we can assume that thisExistingFileReads does not have many entries
 			if (!thisExistingFileReads.includes(filePath)) {
-				// meaning we haven't already replaced this file read
+				// meaning we havent already replaced this file read
 
 				const entireMatch = match[0] // The entire matched string
 
@@ -607,7 +590,7 @@ export class ContextManager {
 	) {
 		const pattern = new RegExp(`(<final_file_content path="[^"]*">)[\\s\\S]*?(</final_file_content>)`)
 
-		// check if this exists in the text, it won't exist if the user rejects the file change for example
+		// check if this exists in the text, it wont exist if the user rejects the file change for example
 		if (pattern.test(secondBlockText)) {
 			const replacementText = secondBlockText.replace(pattern, `$1 ${formatResponse.duplicateFileReadNotice()} $2`)
 			const indices = fileReadIndices.get(filePath) || []
@@ -758,7 +741,7 @@ export class ContextManager {
 		let totalCharactersSaved = 0
 
 		for (let i = startIndex; i < endIndex; i++) {
-			// looping over the outer indices of messages
+			// looping over the outer indicies of messages
 			const message = apiMessages[i]
 
 			if (!message.content) {
@@ -799,7 +782,7 @@ export class ContextManager {
 
 									totalCharCount += originalTextLength
 								} else {
-									// meaning there was an update to this text previously, but we didn't just alter it
+									// meaning there was an update to this text previously, but we didnt just alter it
 									totalCharCount += latestUpdate[2][0].length
 								}
 							} else {
@@ -807,7 +790,7 @@ export class ContextManager {
 								totalCharCount += block.text.length
 							}
 						} else {
-							// reach here if there's no alterations for this outer index, meaning each inner index won't have any changes either
+							// reach here if there's no alterations for this outer index, meaning each inner index wont have any changes either
 							totalCharCount += block.text.length
 						}
 					} else if (block.type === "image" && block.source) {

src/core/context/context-management/context-window-utils.ts

@@ -1,5 +1,5 @@
-import { ApiHandler } from "@api/index"
-import { OpenAiHandler } from "@api/providers/openai"
+import { ApiHandler } from "../../../api"
+import { OpenAiHandler } from "../../../api/providers/openai"
 
 /**
  * Gets context window information for the given API handler

src/core/context/context-tracking/ContextTrackerTypes.ts

@@ -1,3 +1,5 @@
+import * as vscode from "vscode"
+
 // Type definitions for FileContextTracker
 export interface FileMetadataEntry {
 	path: string

src/core/context/context-tracking/FileContextTracker.ts

@@ -1,6 +1,6 @@
 import * as path from "path"
 import * as vscode from "vscode"
-import { getTaskMetadata, saveTaskMetadata } from "@core/storage/disk"
+import { getTaskMetadata, saveTaskMetadata } from "../../storage/disk"
 import type { FileMetadataEntry } from "./ContextTrackerTypes"
 
 // This class is responsible for tracking file operations that may result in stale context.

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

@@ -3,7 +3,7 @@ import { expect } from "chai"
 import * as sinon from "sinon"
 import * as vscode from "vscode"
 import { ModelContextTracker } from "./ModelContextTracker"
-import * as diskModule from "@core/storage/disk"
+import * as diskModule from "../../storage/disk"
 import type { TaskMetadata } from "./ContextTrackerTypes"
 
 describe("ModelContextTracker", () => {

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

@@ -1,5 +1,5 @@
 import * as vscode from "vscode"
-import { getTaskMetadata, saveTaskMetadata } from "@core/storage/disk"
+import { getTaskMetadata, saveTaskMetadata } from "../../storage/disk"
 
 export class ModelContextTracker {
 	readonly taskId: string

src/core/context/context-tracking/__tests__/FileContextTracker.test.ts

@@ -3,9 +3,9 @@ import { expect } from "chai"
 import * as sinon from "sinon"
 import * as vscode from "vscode"
 import * as path from "path"
-import { FileContextTracker } from "./FileContextTracker"
-import * as diskModule from "@core/storage/disk"
-import type { TaskMetadata, FileMetadataEntry } from "./ContextTrackerTypes"
+import { FileContextTracker } from "../FileContextTracker"
+import * as diskModule from "../../../storage/disk"
+import type { TaskMetadata, FileMetadataEntry } from "../ContextTrackerTypes"
 
 describe("FileContextTracker", () => {
 	let sandbox: sinon.SinonSandbox

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

@@ -0,0 +1,205 @@
+import { describe, it, beforeEach, afterEach } from "mocha"
+import { expect } from "chai"
+import * as sinon from "sinon"
+import * as vscode from "vscode"
+import { ModelContextTracker } from "../ModelContextTracker"
+import * as diskModule from "../../../storage/disk"
+import type { TaskMetadata } from "../ContextTrackerTypes"
+
+describe("ModelContextTracker", () => {
+	let sandbox: sinon.SinonSandbox
+	let mockContext: vscode.ExtensionContext
+	let tracker: ModelContextTracker
+	let taskId: string
+	let mockTaskMetadata: TaskMetadata
+	let getTaskMetadataStub: sinon.SinonStub
+	let saveTaskMetadataStub: sinon.SinonStub
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+
+		// Mock controller and context
+		mockContext = {
+			globalStorageUri: { fsPath: "/mock/storage" },
+		} as unknown as vscode.ExtensionContext
+
+		// Mock disk module functions
+		mockTaskMetadata = { files_in_context: [], model_usage: [] }
+		getTaskMetadataStub = sandbox.stub(diskModule, "getTaskMetadata").resolves(mockTaskMetadata)
+		saveTaskMetadataStub = sandbox.stub(diskModule, "saveTaskMetadata").resolves()
+
+		// Create tracker instance
+		taskId = "test-task-id"
+		tracker = new ModelContextTracker(mockContext, taskId)
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it("should record model usage with correct data", async () => {
+		// Test data
+		const apiProviderId = "anthropic"
+		const modelId = "claude-3-opus"
+		const mode = "act"
+
+		// Use a fake timer to have a predictable timestamp
+		const fakeNow = 1617293940000 // Some fixed timestamp
+		const clock = sandbox.useFakeTimers(fakeNow)
+
+		try {
+			// Call the method being tested
+			await tracker.recordModelUsage(apiProviderId, modelId, mode)
+
+			// Verify getTaskMetadata was called with correct parameters
+			expect(getTaskMetadataStub.calledOnce).to.be.true
+			expect(getTaskMetadataStub.firstCall.args[1]).to.equal(taskId)
+
+			// Verify saveTaskMetadata was called with the correct data
+			expect(saveTaskMetadataStub.calledOnce).to.be.true
+
+			// Extract the saved metadata from the call arguments
+			const savedMetadata = saveTaskMetadataStub.firstCall.args[2]
+
+			// Verify model_usage array has one entry
+			expect(savedMetadata.model_usage.length).to.equal(1)
+
+			// Verify the entry has the correct properties
+			const modelUsageEntry = savedMetadata.model_usage[0]
+			expect(modelUsageEntry.ts).to.equal(fakeNow)
+			expect(modelUsageEntry.model_id).to.equal(modelId)
+			expect(modelUsageEntry.model_provider_id).to.equal(apiProviderId)
+			expect(modelUsageEntry.mode).to.equal(mode)
+		} finally {
+			// Restore the clock
+			clock.restore()
+		}
+	})
+
+	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
+		mockTaskMetadata.model_usage = [
+			{
+				ts: existingTimestamp,
+				model_id: "existing-model",
+				model_provider_id: "existing-provider",
+				mode: "plan",
+			},
+		]
+
+		// Test data for new entry
+		const apiProviderId = "anthropic"
+		const modelId = "claude-3-sonnet"
+		const mode = "act"
+
+		// Use a fake timer
+		const newTimestamp = 1617300000000
+		const clock = sandbox.useFakeTimers(newTimestamp)
+
+		try {
+			// Call the method being tested
+			await tracker.recordModelUsage(apiProviderId, modelId, mode)
+
+			// Verify saveTaskMetadata was called
+			expect(saveTaskMetadataStub.calledOnce).to.be.true
+
+			// Extract the saved metadata
+			const savedMetadata = saveTaskMetadataStub.firstCall.args[2]
+
+			// Verify model_usage array now has two entries
+			expect(savedMetadata.model_usage.length).to.equal(2)
+
+			// Verify the existing entry is preserved
+			expect(savedMetadata.model_usage[0]).to.deep.equal({
+				ts: existingTimestamp,
+				model_id: "existing-model",
+				model_provider_id: "existing-provider",
+				mode: "plan",
+			})
+
+			// Verify the new entry has correct data
+			expect(savedMetadata.model_usage[1]).to.deep.equal({
+				ts: newTimestamp,
+				model_id: modelId,
+				model_provider_id: apiProviderId,
+				mode: mode,
+			})
+		} finally {
+			clock.restore()
+		}
+	})
+
+	it("should handle multiple model usages in sequence", async () => {
+		// Test data for sequential calls
+		const usages = [
+			{ provider: "anthropic", model: "claude-3-opus", mode: "plan" },
+			{ provider: "openai", model: "gpt-4", mode: "act" },
+			{ provider: "anthropic", model: "claude-3-haiku", mode: "plan" },
+		]
+
+		// Use a fake timer that advances with each call
+		const startTime = 1617300000000
+		const clock = sandbox.useFakeTimers(startTime)
+
+		try {
+			// Record multiple model usages
+			for (let i = 0; i < usages.length; i++) {
+				const { provider, model, mode } = usages[i]
+
+				// Advance time by 1 second for each call
+				clock.tick(1000)
+				const expectedTime = startTime + (i + 1) * 1000
+
+				// Reset history between calls to check individual call behavior
+				getTaskMetadataStub.resetHistory()
+				saveTaskMetadataStub.resetHistory()
+
+				// Reset mock metadata for each iteration to avoid accumulation
+				mockTaskMetadata.model_usage = []
+
+				// Call the method
+				await tracker.recordModelUsage(provider, model, mode)
+
+				// Verify interaction with disk module
+				expect(getTaskMetadataStub.calledOnce).to.be.true
+				expect(saveTaskMetadataStub.calledOnce).to.be.true
+
+				// Get the saved metadata
+				const savedMetadata = saveTaskMetadataStub.firstCall.args[2]
+
+				// Since we reset the array for each call, we should always have 1 entry
+				expect(savedMetadata.model_usage.length).to.equal(1)
+
+				// Check the entry
+				const entry = savedMetadata.model_usage[0]
+				expect(entry.ts).to.equal(expectedTime)
+				expect(entry.model_id).to.equal(model)
+				expect(entry.model_provider_id).to.equal(provider)
+				expect(entry.mode).to.equal(mode)
+			}
+		} finally {
+			clock.restore()
+		}
+	})
+})

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

@@ -1,11 +1,10 @@
 import path from "path"
-import { ensureRulesDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { fileExistsAtPath, isDirectory, readDirectory } from "@utils/fs"
-import { formatResponse } from "@core/prompts/responses"
+import { GlobalFileNames } from "../../../storage/disk"
+import { fileExistsAtPath, isDirectory, readDirectory } from "../../../../utils/fs"
+import { formatResponse } from "../../../prompts/responses"
 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"
+
+export type ClineRulesToggles = Record<string, boolean> // filepath -> enabled/disabled
 
 export const getGlobalClineRules = async (globalClineRulesFilePath: string, toggles: ClineRulesToggles) => {
 	if (await fileExistsAtPath(globalClineRulesFilePath)) {
@@ -148,100 +147,3 @@ export async function synchronizeRuleToggles(
 
 	return updatedToggles
 }
-
-export async function refreshClineRulesToggles(
-	context: vscode.ExtensionContext,
-	workingDirectory: string,
-): Promise<{
-	globalToggles: ClineRulesToggles
-	localToggles: ClineRulesToggles
-}> {
-	// Global toggles
-	const globalClineRulesToggles = ((await getGlobalState(context, "globalClineRulesToggles")) as ClineRulesToggles) || {}
-	const globalClineRulesFilePath = await ensureRulesDirectoryExists()
-	const updatedGlobalToggles = await synchronizeRuleToggles(globalClineRulesFilePath, globalClineRulesToggles)
-	await updateGlobalState(context, "globalClineRulesToggles", updatedGlobalToggles)
-
-	// Local toggles
-	const localClineRulesToggles = ((await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles) || {}
-	const localClineRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.clineRules)
-	const updatedLocalToggles = await synchronizeRuleToggles(localClineRulesFilePath, localClineRulesToggles)
-	await updateWorkspaceState(context, "localClineRulesToggles", updatedLocalToggles)
-
-	return {
-		globalToggles: updatedGlobalToggles,
-		localToggles: updatedLocalToggles,
-	}
-}
-
-export const createRuleFile = async (isGlobal: boolean, filename: string, cwd: string) => {
-	try {
-		let filePath: string
-		if (isGlobal) {
-			const globalClineRulesFilePath = await ensureRulesDirectoryExists()
-			filePath = path.join(globalClineRulesFilePath, filename)
-		} else {
-			const localClineRulesFilePath = path.resolve(cwd, GlobalFileNames.clineRules)
-			await fs.mkdir(localClineRulesFilePath, { recursive: true })
-			filePath = path.join(localClineRulesFilePath, filename)
-		}
-
-		const fileExists = await fileExistsAtPath(filePath)
-
-		if (fileExists) {
-			return { filePath, fileExists }
-		}
-
-		await fs.writeFile(filePath, "", "utf8")
-
-		return { filePath, fileExists: false }
-	} catch (error) {
-		return { filePath: null, fileExists: false }
-	}
-}
-
-export async function deleteRuleFile(
-	context: vscode.ExtensionContext,
-	rulePath: string,
-	isGlobal: boolean,
-): Promise<{ success: boolean; message: string }> {
-	try {
-		// Check if file exists
-		const fileExists = await fileExistsAtPath(rulePath)
-		if (!fileExists) {
-			return {
-				success: false,
-				message: `Rule file does not exist: ${rulePath}`,
-			}
-		}
-
-		// Delete the file from disk
-		await fs.unlink(rulePath)
-
-		// Get the filename for messages
-		const fileName = path.basename(rulePath)
-
-		// Update the appropriate toggles
-		if (isGlobal) {
-			const toggles = ((await getGlobalState(context, "globalClineRulesToggles")) as ClineRulesToggles) || {}
-			delete toggles[rulePath]
-			await updateGlobalState(context, "globalClineRulesToggles", toggles)
-		} else {
-			const toggles = ((await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles) || {}
-			delete toggles[rulePath]
-			await updateWorkspaceState(context, "localClineRulesToggles", toggles)
-		}
-
-		return {
-			success: true,
-			message: `Rule file "${fileName}" deleted successfully`,
-		}
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error)
-		console.error(`Error deleting rule file: ${errorMessage}`, error)
-		return {
-			success: false,
-			message: `Failed to delete rule file.`,
-		}
-	}
-}

src/core/controller/account/accountLoginClicked.ts

@@ -1,30 +0,0 @@
-import * as vscode from "vscode"
-import crypto from "crypto"
-import { Controller } from "../index"
-import { storeSecret } from "../../storage/state"
-
-/**
- * Handles the user clicking the login link in the UI.
- * Generates a secure nonce for state validation, stores it in secrets,
- * and opens the authentication URL in the external browser.
- *
- * @param controller The controller instance.
- * @returns The login URL as a string.
- */
-export async function accountLoginClicked(controller: Controller): Promise<String> {
-	// Generate nonce for state validation
-	const nonce = crypto.randomBytes(32).toString("hex")
-	await storeSecret(controller.context, "authNonce", nonce)
-
-	// Open browser for authentication with state param
-	console.log("Login button clicked in account page")
-	console.log("Opening auth page with state param")
-
-	const uriScheme = vscode.env.uriScheme
-
-	const authUrl = vscode.Uri.parse(
-		`https://app.cline.bot/auth?state=${encodeURIComponent(nonce)}&callback_url=${encodeURIComponent(`${uriScheme || "vscode"}://saoudrizwan.claude-dev/auth`)}`,
-	)
-	vscode.env.openExternal(authUrl)
-	return authUrl.toString()
-}

src/core/controller/account/index.ts

@@ -1,14 +0,0 @@
-import { createServiceRegistry, ServiceMethodHandler } from "../grpc-service"
-import { registerAllMethods } from "./methods"
-
-const accountService = createServiceRegistry("account")
-
-// Export the method handler type and registration function
-export type AccountMethodHandler = ServiceMethodHandler
-export const registerMethod = accountService.registerMethod
-
-// Export the request handler
-export const handleAccountServiceRequest = accountService.handleRequest
-
-// Register all account methods
-registerAllMethods()

src/core/controller/account/methods.ts

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

src/core/controller/browser/discoverBrowser.ts

@@ -1,47 +0,0 @@
-import { BrowserConnection } from "@shared/proto/browser"
-import { EmptyRequest } from "@shared/proto/common"
-import { Controller } from "../index"
-import { getAllExtensionState } from "@core/storage/state"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
-
-/**
- * Discover Chrome instances
- * @param controller The controller instance
- * @param request The request message
- * @returns The browser connection result
- */
-export async function discoverBrowser(controller: Controller, request: EmptyRequest): Promise<BrowserConnection> {
-	try {
-		const discoveredHost = await discoverChromeInstances()
-
-		if (discoveredHost) {
-			// Don't update the remoteBrowserHost state when auto-discovering
-			// This way we don't override the user's preference
-
-			// Test the connection to get the endpoint
-			const { browserSettings } = await getAllExtensionState(controller.context)
-			const browserSession = new BrowserSession(controller.context, browserSettings)
-			const result = await browserSession.testConnection(discoveredHost)
-
-			return {
-				success: true,
-				message: `Successfully discovered and connected to Chrome at ${discoveredHost}`,
-				endpoint: result.endpoint || "",
-			}
-		} else {
-			return {
-				success: false,
-				message:
-					"No Chrome instances found. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
-				endpoint: "",
-			}
-		}
-	} catch (error) {
-		return {
-			success: false,
-			message: `Error discovering browser: ${error instanceof Error ? error.message : String(error)}`,
-			endpoint: "",
-		}
-	}
-}

src/core/controller/browser/getBrowserConnectionInfo.ts

@@ -1,7 +1,7 @@
-import { BrowserConnectionInfo } from "@shared/proto/browser"
-import { EmptyRequest } from "@shared/proto/common"
+import { BrowserConnectionInfo } from "../../../shared/proto/browser"
+import { EmptyRequest } from "../../../shared/proto/common"
 import { Controller } from "../index"
-import { getAllExtensionState } from "@core/storage/state"
+import { getAllExtensionState } from "../../storage/state"
 
 /**
  * Get information about the current browser connection

src/core/controller/browser/getDetectedChromePath.ts

@@ -1,30 +0,0 @@
-import { ChromePath } from "../../../shared/proto/browser"
-import { EmptyRequest } from "../../../shared/proto/common"
-import { Controller } from "../index"
-import { getAllExtensionState } from "../../storage/state"
-import { BrowserSession } from "../../../services/browser/BrowserSession"
-
-/**
- * Get the detected Chrome executable path
- * @param controller The controller instance
- * @param request The empty request message
- * @returns The detected Chrome path and whether it's bundled
- */
-export async function getDetectedChromePath(controller: Controller, request: EmptyRequest): Promise<ChromePath> {
-	try {
-		const { browserSettings } = await getAllExtensionState(controller.context)
-		const browserSession = new BrowserSession(controller.context, browserSettings)
-		const result = await browserSession.getDetectedChromePath()
-
-		return {
-			path: result.path,
-			isBundled: result.isBundled,
-		}
-	} catch (error) {
-		console.error("Error getting detected Chrome path:", error)
-		return {
-			path: "",
-			isBundled: false,
-		}
-	}
-}

src/core/controller/browser/methods.ts

@@ -3,18 +3,10 @@
 
 // Import all method implementations
 import { registerMethod } from "./index"
-import { discoverBrowser } from "./discoverBrowser"
 import { getBrowserConnectionInfo } from "./getBrowserConnectionInfo"
-import { getDetectedChromePath } from "./getDetectedChromePath"
-import { testBrowserConnection } from "./testBrowserConnection"
-import { updateBrowserSettings } from "./updateBrowserSettings"
 
 // Register all browser service methods
 export function registerAllMethods(): void {
 	// Register each method with the registry
-	registerMethod("discoverBrowser", discoverBrowser)
 	registerMethod("getBrowserConnectionInfo", getBrowserConnectionInfo)
-	registerMethod("getDetectedChromePath", getDetectedChromePath)
-	registerMethod("testBrowserConnection", testBrowserConnection)
-	registerMethod("updateBrowserSettings", updateBrowserSettings)
 }

src/core/controller/browser/testBrowserConnection.ts

@@ -1,63 +0,0 @@
-import { BrowserConnection } from "@shared/proto/browser"
-import { StringRequest } from "@shared/proto/common"
-import { Controller } from "../index"
-import { getAllExtensionState } from "@core/storage/state"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
-
-/**
- * Test connection to a browser instance
- * @param controller The controller instance
- * @param request The request message
- * @returns The browser connection result
- */
-export async function testBrowserConnection(controller: Controller, request: StringRequest): Promise<BrowserConnection> {
-	try {
-		const { browserSettings } = await getAllExtensionState(controller.context)
-		const browserSession = new BrowserSession(controller.context, browserSettings)
-		const text = request.value || ""
-
-		// If no text is provided, try auto-discovery
-		if (!text) {
-			try {
-				const discoveredHost = await discoverChromeInstances()
-				if (discoveredHost) {
-					// Test the connection to the discovered host
-					const result = await browserSession.testConnection(discoveredHost)
-					return {
-						success: result.success,
-						message: `Auto-discovered and tested connection to Chrome at ${discoveredHost}: ${result.message}`,
-						endpoint: result.endpoint || "",
-					}
-				} else {
-					return {
-						success: false,
-						message:
-							"No Chrome instances found on the network. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
-						endpoint: "",
-					}
-				}
-			} catch (error) {
-				return {
-					success: false,
-					message: `Error during auto-discovery: ${error instanceof Error ? error.message : String(error)}`,
-					endpoint: "",
-				}
-			}
-		} else {
-			// Test the provided URL
-			const result = await browserSession.testConnection(text)
-			return {
-				success: result.success,
-				message: result.message,
-				endpoint: result.endpoint || "",
-			}
-		}
-	} catch (error) {
-		return {
-			success: false,
-			message: `Error testing connection: ${error instanceof Error ? error.message : String(error)}`,
-			endpoint: "",
-		}
-	}
-}

src/core/controller/browser/updateBrowserSettings.ts

@@ -1,46 +0,0 @@
-import { UpdateBrowserSettingsRequest } from "../../../shared/proto/browser"
-import { Boolean } from "../../../shared/proto/common"
-import { Controller } from "../index"
-import { updateGlobalState } from "../../storage/state"
-import { BrowserSettings as SharedBrowserSettings } from "../../../shared/BrowserSettings"
-
-/**
- * Update browser settings
- * @param controller The controller instance
- * @param request The browser settings request message
- * @returns Success response
- */
-export async function updateBrowserSettings(controller: Controller, request: UpdateBrowserSettingsRequest): Promise<Boolean> {
-	try {
-		// Convert from protobuf format to shared format
-		const browserSettings: SharedBrowserSettings = {
-			viewport: {
-				width: request.viewport?.width || 900,
-				height: request.viewport?.height || 600,
-			},
-			remoteBrowserEnabled: request.remoteBrowserEnabled || false,
-			remoteBrowserHost: request.remoteBrowserHost || undefined,
-		}
-
-		// Update global state with new settings
-		await updateGlobalState(controller.context, "browserSettings", browserSettings)
-
-		// Update task browser settings if task exists
-		if (controller.task) {
-			controller.task.browserSettings = browserSettings
-			controller.task.browserSession.browserSettings = browserSettings
-		}
-
-		// Post updated state to webview
-		await controller.postStateToWebview()
-
-		return {
-			value: true,
-		}
-	} catch (error) {
-		console.error("Error updating browser settings:", error)
-		return {
-			value: false,
-		}
-	}
-}

src/core/controller/checkpoints/checkpointDiff.ts

@@ -1,9 +0,0 @@
-import { Controller } from ".."
-import { Empty, Int64Request } from "@shared/proto/common"
-
-export async function checkpointDiff(controller: Controller, request: Int64Request): Promise<Empty> {
-	if (request.value) {
-		await controller.task?.presentMultifileDiff(request.value, false)
-	}
-	return Empty
-}

src/core/controller/checkpoints/checkpointRestore.ts

@@ -1,22 +0,0 @@
-import { Controller } from ".."
-import { ClineCheckpointRestore } from "../../../shared/WebviewMessage"
-import { CheckpointRestoreRequest } from "../../../shared/proto/checkpoints"
-import { Empty } from "../../../shared/proto/common"
-import pWaitFor from "p-wait-for"
-
-export async function checkpointRestore(controller: Controller, request: CheckpointRestoreRequest): Promise<Empty> {
-	await controller.cancelTask() // we cannot alter message history say if the task is active, as it could be in the middle of editing a file or running a command, which expect the ask to be responded to rather than being superseded by a new message eg add deleted_api_reqs
-
-	if (request.number) {
-		// wait for messages to be loaded
-		await pWaitFor(() => controller.task?.isInitialized === true, {
-			timeout: 3_000,
-		}).catch(() => {
-			console.error("Failed to init new cline instance")
-		})
-
-		// NOTE: cancelTask awaits abortTask, which awaits diffViewProvider.revertChanges, which reverts any edited files, allowing us to reset to a checkpoint rather than running into a state where the revertChanges function is called alongside or after the checkpoint reset
-		await controller.task?.restoreCheckpoint(request.number, request.restoreType as ClineCheckpointRestore, request.offset)
-	}
-	return {}
-}

src/core/controller/checkpoints/index.ts

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

src/core/controller/checkpoints/methods.ts

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

src/core/controller/file/index.ts

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

src/core/controller/file/methods.ts

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