revert refactor

- Add explicit TypeScript types for OpenRouter interfaces
- Reorganize imports with proper type annotations
- Remove unused counter property and improve method naming
- Improve error handling and code readability

.changeset/chilly-sheep-rhyme.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Improve cerebras Qwen model performance by removing thinking tokens from the model input

.changeset/kind-boxes-remember.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Change available Cerebras models - limit to Qwen and llama 3.3 70b

.changeset/many-ligers-beam.md

@@ -1,8 +0,0 @@
----
-"claude-dev": patch
----
-
-Added checkpointTrackerErrorMessage to HistoryItem - restored with task, prevents re-initialization if timed out before
-Never re-init checkpoint tracker if it timed out before
-Warning at 7s that it's taking awhile, timeout and give up at 15s
-Fixed click to open settings - now opens to correct tab

.changeset/moody-crabs-relate.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix: mcp servers are not started when disabled

.changeset/nasty-vans-mate.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Refactor Git commit message generation to support output streaming.

.changeset/popular-flies-explode.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Introduce Claude Code support on Windows and fix E2BIG issues

.changeset/strange-zebras-tan.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Adding safety guard for workspace root

.changeset/wet-spiders-watch.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Change Cerebras Qwen 3 32b context window from 16k to 64k

.changeset/yellow-meals-smash.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+calibrate input token counts when using anthropic models of sap ai core provider

.clinerules/cline-overview.md

@@ -716,7 +716,7 @@ The Controller class manages MCP servers through the McpHub service:
 class Controller {
   mcpHub?: McpHub
 
-  constructor(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, webviewProvider: WebviewProvider) {
+  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
     this.mcpHub = new McpHub(this)
   }
 

.clinerules/workflows/pr-review.md

@@ -219,6 +219,9 @@ EOF
 
 ## Basic PR Commands
 ```bash
+# Get current PR number
+gh pr view --json number -q .number
+
 # List open PRs
 gh pr list
 

.eslintrc.json

@@ -20,7 +20,6 @@
 		"no-throw-literal": "warn",
 		"semi": "off",
 		"react-hooks/exhaustive-deps": "off",
-		"eslint-rules/no-protobuf-object-literals": "error",
 		"eslint-rules/no-direct-vscode-api": "warn",
 		"no-restricted-syntax": [
 			"error",

.github/CODEOWNERS

@@ -1 +1,3 @@
-*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv @Garoth
+/docs/
+/.github/   @saoudrizwan @dcbartlett
+/README.md  @saoudrizwan @nickbaumann98

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -5,7 +5,7 @@ body:
     - type: markdown
       attributes:
           value: |
-              **Important:** All bug reports must be reproducible using Claude 3.5 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
+              **Important:** All bug reports must be reproducible using Claude 4 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
     - type: textarea
       id: what-happened
       attributes:
@@ -24,7 +24,7 @@ body:
               2.
               3.
       validations:
-          required: true
+          required: false
     - type: textarea
       id: logs
       attributes:
@@ -39,20 +39,19 @@ body:
           placeholder: "e.g., cline:anthropic/claude-3.7-sonnet, gemini:gemini-2.5-pro-exp-03-25"
       validations:
           required: true
-    - type: input
-      id: operating-system
-      attributes:
-          label: Operating System
-          description: What operating system are you using?
-          placeholder: "e.g., Windows 11, macOS Sonoma, Ubuntu 22.04"
-      validations:
-          required: true
     - type: textarea
       id: system-info
       attributes:
-          label: System Info
-          description: What system information is relevant to the issue?
-          placeholder: "e.g., CPU: Intel Core i7-11700K, GPU: NVIDIA GeForce RTX 3070, RAM: 32GB DDR4"
+          label: System Information
+          description: What operating system and hardware are you using?
+          placeholder: |
+              Operating System: Windows 11, macOS Sonoma, Ubuntu 22.04, etc.
+              Hardware: CPU, GPU, RAM specifications if relevant
+              e.g.,
+              OS: Windows 11
+              CPU: Intel Core i7-11700K
+              GPU: NVIDIA GeForce RTX 3070
+              RAM: 32GB DDR4
       validations:
           required: true
     - type: input
@@ -63,8 +62,3 @@ body:
           placeholder: "e.g., 1.2.3"
       validations:
           required: true
-    - type: textarea
-      id: additional-context
-      attributes:
-          label: Additional context
-          description: Add any other context about the problem here, such as screenshots or related issues.

.github/ISSUE_TEMPLATE/feature_contribution.yml

@@ -1,116 +0,0 @@
-name: 💡 Feature Proposal & Contribution
-description: Propose a new feature or improvement, and optionally offer to implement feature as a contributor
-labels: ["proposal"]
-body:
-    - type: markdown
-      attributes:
-          value: |
-              **Feature Proposal & Contribution for Cline**
-
-              Thank you for proposing a feature or improvement for Cline! This template helps us understand the problem, evaluate the solution, and coordinate implementation.
-
-              **For detailed proposals:** Please provide comprehensive information to enable fast prioritization and discussion.
-              **For contribution offers:** You can indicate your willingness to implement the feature yourself.
-
-              Before submitting:
-              - Search existing [Issues](https://github.com/cline/cline/issues) and [Discussions](https://github.com/cline/cline/discussions) to avoid duplicates
-              - Read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md) if you plan to contribute
-              - Don't start implementation until the proposal is reviewed and approved
-
-    - type: textarea
-      id: problem-description
-      attributes:
-          label: What problem does this solve?
-          description: |
-              Describe the problem clearly from a user's point of view. Focus on why this matters, who it affects, and when it occurs.
-
-              ✅ Good examples:
-              - "LLM provider returns 400 error when nearing the context window instead of truncating"
-              - "Submit button is invisible in dark mode"
-              - "Users can't easily share their Cline configurations with team members"
-
-              ❌ Avoid vague descriptions:
-              - "Performance is bad"
-              - "UI needs work"
-
-              Your description should include:
-              - Who is affected?
-              - When does it happen?
-              - What's the current vs expected behavior?
-              - What is the impact?
-          placeholder: Be specific about the problem, who it affects, and the impact.
-      validations:
-          required: true
-
-    - type: textarea
-      id: proposed-solution
-      attributes:
-          label: What's the proposed solution?
-          description: |
-              Describe how the problem should be solved. Be specific about UX, system behavior, and any flows that would change.
-
-              ✅ Good examples:
-              - "Add error handling immediately after attempting to create the llm stream and retry after manually truncating"
-              - "Update button styling to ensure contrast in all themes"
-              - "Add export/import functionality in settings with JSON format"
-
-              ❌ Avoid vague solutions:
-              - "Improve performance"
-              - "Fix the bug"
-
-              Your solution should include:
-              - What exactly will change?
-              - How will users interact with it?
-              - What's the expected outcome?
-          placeholder: Describe the proposed changes and how they solve the problem.
-      validations:
-          required: false
-
-    - type: dropdown
-      id: contribution-intent
-      attributes:
-          label: Are you interested in implementing this?
-          description: Let us know if you'd like to contribute to this feature
-          options:
-              - "No, just proposing the idea"
-              - "Yes, I'd like to implement this myself"
-              - "Yes, I'd like to collaborate with others"
-              - "Maybe, depending on complexity and guidance"
-      validations:
-          required: false
-
-    - type: textarea
-      id: implementation-approach
-      attributes:
-          label: Implementation approach (if contributing)
-          description: |
-              **Only fill this out if you selected "Yes" above.**
-
-              How do you plan to implement this? Include:
-              - High-level technical approach
-              - Files/components that would be affected
-              - Any new dependencies required
-              - Potential challenges or considerations you've identified
-
-              This helps us provide better guidance and ensures alignment before you start coding.
-          placeholder: "My implementation approach would be..."
-
-    - type: checkboxes
-      id: checklist
-      attributes:
-          label: Proposal checklist
-          options:
-              - label: I've checked for existing issues or related proposals
-                required: true
-              - label: I understand this needs review before implementation can start
-                required: true
-
-    - type: checkboxes
-      id: contribution-checklist
-      attributes:
-          label: Contribution checklist (if contributing)
-          description: Only check these if you plan to contribute
-          options:
-              - label: I've read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
-              - label: I'm willing to make changes based on feedback
-              - label: I understand the code review process and requirements

.github/pull_request_template.md

@@ -2,15 +2,14 @@
 Thank you for contributing to Cline!
 
 ⚠️ Important: Before submitting this PR, please ensure you have:
-- Opened an issue and discussed your proposed changes with the community / contributors
-- Received approval from a core Cline contributor prior to proceeding with the implementation
-- Link the associated issue in the "Related Issue" section
+- For feature requests: Created a discussion in our Feature Requests discussions board https://github.com/cline/cline/discussions/categories/feature-requests and received approval from core maintainers before implementation
+- For all changes: Link the associated issue/discussion in the "Related Issue" section below
 
 Limited exceptions:
-Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly.
+Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly without prior discussion.
 
 Why this requirement?
-We deeply appreciate all community contributions - they are the core reason we're able to operate successfully and keep innovating! We welcome community input and want to make it as easy as possible for people to submit quality work. This process helps our core maintainers review new ideas faster and saves contributor time by ensuring you have the go-ahead before spending time on implementation.
+We deeply appreciate all community contributions - they are essential to Cline's success! To ensure the best use of everyone's time and maintain project direction, we use our Feature Requests discussions board to gauge community interest and validate feature ideas before implementation begins. This helps us focus development efforts on features that will benefit the most users.
 -->
 
 ### Related Issue

.github/workflows/test.yml

@@ -96,16 +96,15 @@ jobs:
             - name: Build Tests and Extension
               run: npm run pretest
 
-            # Unit Tests disabled due to module system conflicts between backend and webview-ui
-            # - name: Unit Tests
-            #   run: npm run test:unit
+            - name: Unit Tests
+              run: npm run test:unit
 
             # Run extension tests with coverage
-            - name: Extension Tests with Coverage
+            - name: Extension Integration Tests with Coverage
               id: extension_coverage
               continue-on-error: true
               run: |
-                  node ./scripts/test-ci.js > extension_coverage.txt 2>&1
+                  node ./scripts/test-ci.js 2>&1 | tee extension_coverage.txt
                   # Default the encoding to UTF-8 - It's not the default on Windows
                   PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage extension_coverage.txt --type=extension --github-output --verbose
 
@@ -117,7 +116,7 @@ jobs:
                   cd webview-ui
                   # Ensure coverage dependency is installed
                   npm install --no-save @vitest/coverage-v8
-                  npm run test:coverage > webview_coverage.txt 2>&1
+                  npm run test:coverage 2>&1 | tee webview_coverage.txt
                   cd ..
                   # Default the encoding to UTF-8 - It's not the default on Windows
                   PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage webview-ui/webview_coverage.txt --type=webview --github-output --verbose
@@ -132,21 +131,19 @@ jobs:
                   path: |
                       extension_coverage.txt
                       webview-ui/webview_coverage.txt
-                  retention-period: workflow # Artifacts are automatically deleted when the workflow completes
 
             # Set the check as failed if any of the tests failed
-            - name: Print test results and check for failures
+            - name: Check for test failures
               run: |
-                  echo "Extension Tests Result: ${{ steps.extension_coverage.outcome }}"
-                  cat extension_coverage.txt
-
-                  echo "Webview Tests Result: ${{ steps.webview_coverage.outcome }}"
-                  cat webview-ui/webview_coverage.txt
-
                   # Check if any of the test steps failed
                   # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#steps-context
+                  if [ "${{ steps.extension_coverage.outcome }}" != "success" ]; then
+                      echo "Extension Integration Tests failed, see previous step for test output."
+                  fi
+                  if [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
+                      echo "Webview Tests failed, see previous step for test output."
+                  fi
                   if [ "${{ steps.extension_coverage.outcome }}" != "success" ] || [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
-                      echo "Tests failed."
                       exit 1
                   fi
 

.gitignore

@@ -15,6 +15,9 @@ pnpm-lock.yaml
 .venv
 .actrc
 
+webview-ui/src/**/*.js
+webview-ui/src/**/*.js.map
+
 # Ignore coverage directories and files
 coverage
 # But don't ignore the coverage scripts in .github/scripts/
@@ -24,11 +27,7 @@ coverage
 
 ## Generated files ##
 src/generated/
-src/core/controller/*/methods.ts
-src/core/controller/*/index.ts
-src/core/controller/grpc-service-config.ts
-src/shared/proto/*.ts
-src/shared/proto/host/*.ts
+src/shared/proto/
 webview-ui/src/services/grpc-client.ts
 
 # E2E Tests

.vscode/launch.json

@@ -6,7 +6,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension",
+			"name": "Run Extension (production)",
 			"type": "extensionHost",
 			"request": "launch",
 			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
@@ -15,12 +15,35 @@
 			"env": {
 				"IS_DEV": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
-				// Use the environment variable to determine the backend URL
-				// Options: "production", "staging", "local"
-				// Require the extension to reload to apply changes
 				"CLINE_ENVIRONMENT": "production"
 			}
 		},
+		{
+			"name": "Run Extension (staging)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "${defaultBuildTask}",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "staging"
+			}
+		},
+		{
+			"name": "Run Extension (local)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "${defaultBuildTask}",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "local"
+			}
+		},
 		{
 			"name": "Run Extension (Fresh Install Mode)",
 			"type": "extensionHost",
@@ -48,7 +71,7 @@
 		{
 			"type": "node",
 			"request": "launch",
-			"name": "Run Standalone Service",
+			"name": "Run cline-core service",
 			"skipFiles": ["<node_internals>/**"],
 			"sourceMaps": true,
 			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
@@ -59,11 +82,9 @@
 				// Turns on grpc debug log.
 				//"GRPC_TRACE": "all",
 				//"GRPC_VERBOSITY": "DEBUG",
-				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules",
-
-				"HOST_BRIDGE_ADDRESS": "localhost:50052"
+				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules"
 			},
-			"program": "standalone.js"
+			"program": "cline-core.js"
 		}
 	]
 }

.vscode/settings.json

@@ -9,5 +9,9 @@
 		"dist": true // set this to false to include "dist" folder in search results
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off"
+	"typescript.tsc.autoDetect": "off",
+	// Protobuf settings
+	"protoc": {
+		"options": ["--proto_path=proto"]
+	}
 }

CONTRIBUTING.md

@@ -14,14 +14,11 @@ Bug reports help make Cline better for everyone! Before creating a new issue, pl
 ## Before Contributing
 
 All contributions must begin with a GitHub Issue, unless the change is for small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality.
-
-- **Check existing issues**: Search [GitHub Issues](https://github.com/cline/cline/issues).
-- **Create an issue**: Use appropriate templates:
-    - **Contributions:** Use the "Contribution Request" template to propose what you'd like to work on.
-    - **Bugs:** "Bug Report" template for reporting issues.
-    - **Features:** "Detailed Feature Proposal" template for suggesting new features.
-- **Wait for approval**: A core Cline contributor must approve your contribution request before you start implementation.
-- **Claim issues**: Once approved, the issue will be assigned to you.
+**For features and contributions**:
+- First check the [Feature Requests discussions board](https://github.com/cline/cline/discussions/categories/feature-requests) for similar ideas
+- If your idea is new, create a new feature request  
+- Wait for approval from core maintainers before starting implementation
+- Once approved, feel free to begin working on a PR with the help of our community!
 
 **PRs without approved issues may be closed.**
 

buf.yaml

@@ -9,7 +9,6 @@ lint:
 
     except: # Add exceptions for current patterns that contradict STANDARD settings
         - RPC_PASCAL_CASE # rpcs are camel case (start with lowercase)
-        - PACKAGE_DIRECTORY_MATCH # the protos in the cline package are not in a dir named cline.
         - RPC_REQUEST_RESPONSE_UNIQUE # request messages are not unique.
         - RPC_REQUEST_STANDARD_NAME # request messages dont all end with Request
         - RPC_RESPONSE_STANDARD_NAME # response messages dont all end with Response

docs/features/cline-rules.mdx

@@ -11,7 +11,19 @@ You can create a rule by clicking the `+` button in the Rules tab. This will ope
 Once you save the file:
 
 -   Your rule will be stored in the `.clinerules/` directory in your project (if it's a Workspace Rule)
--   Or in the `Documents/Cline/Rules` directory (if it's a Global Rule).
+-   Or in the Global Rules directory (if it's a Global Rule):
+
+### Global Rules Directory Location
+
+The location of your Global Rules directory depends on your operating system:
+
+| Operating System | Default Location | Notes |
+|------------------|------------------|-------|
+| **Windows** | `Documents\Cline\Rules` | Uses system Documents folder |
+| **macOS** | `~/Documents/Cline/Rules` | Uses user Documents folder |
+| **Linux/WSL** | `~/Documents/Cline/Rules` | May fall back to `~/Cline/Rules` on some systems |
+
+> **Note for Linux/WSL users**: If you don't find your global rules in `~/Documents/Cline/Rules`, check `~/Cline/Rules` as the location may vary depending on your system configuration and whether the Documents directory exists.
 
 You can also have Cline create a rule for you by using the [`/newrule` slash command](/features/slash-commands/new-rule) in the chat.
 

docs/mcp/adding-mcp-servers-from-github.mdx

@@ -17,6 +17,7 @@ There are multiple places online to find MCP servers:
     -   [mcpservers.org](https://mcpservers.org/)
     -   [mcp.so](https://mcp.so/)
     -   [glama.ai/mcp/servers](https://glama.ai/mcp/servers)
+    -   [mcp.composio.dev](https://mcp.composio.dev/)
 
     These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.
 

docs/more-info/telemetry.mdx

@@ -4,17 +4,17 @@ title: "Telemetry"
 
 ### Overview
 
-To help make Cline better for everyone, we collect anonymous usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
+To help make Cline better for everyone, we collect usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
 
 We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see exactly what we track.
 
 ### Tracking Policy
 
-Privacy is our priority. All collected data is anonymized before being sent to PostHog, with no personally identifiable information (PII) included. Your code, prompts, and conversation content always remain private and are never collected.
+Privacy is our priority. By default, all collected data is anonymized. If you log in with a Cline account, your telemetry data will be associated with your account to help us improve the product and provide better support when you encounter issues. Your code, prompts, and conversation content always remain private and are never collected.
 
 ### What We Track
 
-We collect basic anonymous usage data including:
+We collect basic usage data including:
 
 **Task Interactions:** When tasks start and finish, conversation flow (without content)\
 **Mode and Tool Usage:** Switches between plan/act modes, which tools are being used\
@@ -28,7 +28,7 @@ For complete transparency, you can inspect our [telemetry implementation](https:
 
 Telemetry in Cline is entirely optional:
 
--   When you update or install our VS Code extension, you'll see a message about our anonymous telemetry
+-   When you update or install our VS Code extension, you'll see a message about our telemetry
 -   You can change your preference anytime in settings
 
 Cline also respects VS Code's global telemetry settings. If you've disabled telemetry at the VS Code level, Cline's telemetry will automatically be disabled as well.

docs/provider-config/anthropic.mdx

@@ -16,6 +16,7 @@ description: "Learn how to configure and use Anthropic Claude models with Cline.
 
 Cline supports the following Anthropic Claude models:
 
+-   `claude-opus-4-1-20250805`
 -   `claude-opus-4-20250514`
 -   `claude-opus-4-20250514:thinking` (Extended Thinking variant)
 -   `claude-sonnet-4-20250514` (Recommended)

docs/provider-config/claude-code.mdx

@@ -52,6 +52,7 @@ If you're not sure where Claude Code is installed:
 The Claude Code provider supports these models:
 
 -   `claude-sonnet-4-20250514` (Recommended)
+-   `claude-opus-4-1-20250805`
 -   `claude-opus-4-20250514`
 -   `claude-3-7-sonnet-20250219`
 -   `claude-3-5-sonnet-20241022`

docs/troubleshooting/terminal-integration-guide.mdx

@@ -244,13 +244,60 @@ Recent macOS versions have stricter terminal permissions:
 
 ### Windows Issues
 
-#### PowerShell Execution Policy
+If you're using Windows and still experiencing issues with shell integration after trying the previous steps, it's recommended you use Git Bash (or PowerShell).
 
-If commands fail silently:
+### Git Bash
+
+Git Bash is a terminal emulator that provides a Unix-like command line experience on Windows. To use Git Bash, you need to:
+
+1. Download and run the Git for Windows installer from [https://git-scm.com/downloads/win](https://git-scm.com/downloads/win)
+2. Quit and re-open VSCode
+3. Press `Ctrl + Shift + P` to open the Command Palette
+4. Type "Terminal: Select Default Profile" and choose it
+5. Select "Git Bash"
+
+### PowerShell
+
+If you'd still like to use PowerShell, make sure you're using an updated version (at least v7+).
+  - Check your current PowerShell version by running: `$PSVersionTable.PSVersion`
+  - If your version is below 7, [update PowerShell](https://learn.microsoft.com/en-us/powershell/scripting/whats-new/migrating-from-windows-powershell-51-to-powershell-7?view=powershell-7.4#installing-powershell-7).
+
+You may also need to adjust your PowerShell execution policy. By default, PowerShell restricts script execution for security reasons.
+
+#### Understanding PowerShell Execution Policies
+
+PowerShell uses execution policies to determine which scripts can run on your system. Here are the most common policies:
+
+- `Restricted`: No PowerShell scripts can run. This is the default setting.
+- `AllSigned`: All scripts, including local ones, must be signed by a trusted publisher.
+- `RemoteSigned`: Scripts created locally can run, but scripts downloaded from the internet must be signed.
+- `Unrestricted`: No restrictions. Any script can run, though you will be warned before running internet-downloaded scripts.
+
+For development work in VSCode, the `RemoteSigned` policy is generally recommended. It allows locally created scripts to run without restrictions while maintaining security for downloaded scripts. To learn more about PowerShell execution policies and understand the security implications of changing them, visit Microsoft's documentation: [About Execution Policies](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_execution_policies).
+
+#### Steps to Change the Execution Policy
+
+1. Open PowerShell as an Administrator: Press `Win + X` and select "Windows PowerShell (Administrator)" or "Windows Terminal (Administrator)".
+
+2. Check Current Execution Policy by running this command:
+     ```powershell
+     Get-ExecutionPolicy
+     ```
+   - If the output is already `RemoteSigned`, `Unrestricted`, or `Bypass`, you likely don't need to change your execution policy. These policies should allow shell integration to work.
+   - If the output is `Restricted` or `AllSigned`, you may need to change your policy to enable shell integration.
+
+3. Change the Execution Policy by running the following command:
+     ```powershell
+     Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
+     ```
+   - This sets the policy to `RemoteSigned` for the current user only, which is safer than changing it system-wide.
+
+4. Confirm the Change by typing `Y` and pressing Enter when prompted.
+
+5. Verify the Policy Change by running `Get-ExecutionPolicy` again to confirm the new setting.
+
+6. Restart VSCode and try the shell integration again.
 
-```powershell
-Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-```
 
 #### WSL Integration
 

esbuild.mjs

@@ -1,6 +1,10 @@
-const esbuild = require("esbuild")
-const fs = require("fs")
-const path = require("path")
+import fs from "node:fs"
+import * as esbuild from "esbuild"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")
@@ -127,10 +131,8 @@ const baseConfig = {
 	sourcemap: !production,
 	logLevel: "silent",
 	define: production
-		? {
-				"process.env.IS_DEV": JSON.stringify(!production),
-			}
-		: undefined,
+		? { "import.meta.url": "_importMetaUrl", "process.env.IS_DEV": JSON.stringify(!production) }
+		: { "import.meta.url": "_importMetaUrl" },
 	tsconfig: path.resolve(__dirname, "tsconfig.json"),
 	plugins: [
 		copyWasmFiles,
@@ -141,6 +143,9 @@ const baseConfig = {
 	format: "cjs",
 	sourcesContent: false,
 	platform: "node",
+	banner: {
+		js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
+	},
 }
 
 // Extension-specific configuration

eslint-rules/__tests__/no-direct-vscode-api.test.ts

@@ -34,25 +34,30 @@ directApiRuleTester.run("no-direct-vscode-api", noDirectVscodeApiRule, {
 		},
 		// Should allow other vscode API calls
 		{
-			code: `vscode.window.showInformationMessage("Hello")`,
-			filename: "test.ts",
+			code: `vscode.commands.registerCommand("Hello")`,
+			filename: "/foo/bar.ts",
 		},
 		// Should allow postMessage calls on other objects
 		{
 			code: `window.postMessage({ type: "test" }, "*")`,
-			filename: "test.ts",
+			filename: "/foo/bar.ts",
 		},
 		// Should allow variables named vscode but not calling postMessage
 		{
 			code: `const vscode = { other: "method" }; vscode.other()`,
-			filename: "test.ts",
+			filename: "/foo/bar.ts",
+		},
+		// Should allow vscode.postMessage in test files
+		{
+			code: `vscode.postMessage({ type: "newTask", text: message.text })`,
+			filename: "/foo/bar.test.ts",
 		},
 	],
 	invalid: [
 		// Should disallow vscode.postMessage in regular files
 		{
 			code: `vscode.postMessage({ type: "test", data: {} })`,
-			filename: "test.ts",
+			filename: "/foo/bar.ts",
 			errors: [
 				{
 					messageId: "useGrpcClient",
@@ -69,23 +74,13 @@ directApiRuleTester.run("no-direct-vscode-api", noDirectVscodeApiRule, {
 				},
 			],
 		},
-		// Should disallow vscode.postMessage in test files
-		{
-			code: `vscode.postMessage({ type: "newTask", text: message.text })`,
-			filename: "test.test.ts",
-			errors: [
-				{
-					messageId: "useGrpcClient",
-				},
-			],
-		},
 		// Should disallow property access for disallowed APIs
 		{
 			code: `const folders = vscode.workspace.workspaceFolders;`,
 			filename: "workspace.ts",
 			errors: [
 				{
-					messageId: "useHostBridge",
+					messageId: "useHostBridgeWorkspace",
 				},
 			],
 		},

eslint-rules/__tests__/no-protobuf-object-literals.test.ts

@@ -1,214 +0,0 @@
-const { RuleTester } = require("eslint")
-const rule = require("../no-protobuf-object-literals")
-
-const ruleTester = new RuleTester({
-	parser: require.resolve("@typescript-eslint/parser"),
-	parserOptions: {
-		ecmaVersion: 2020,
-		sourceType: "module",
-		ecmaFeatures: {
-			jsx: true,
-		},
-	},
-})
-
-ruleTester.run("no-protobuf-object-literals", rule, {
-	valid: [
-		// Valid case: Using .create() method
-		{
-			code: `
-        import { State } from '@shared/proto/state';
-        
-        const state = State.create({
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        });
-      `,
-		},
-		// Valid case: Using .fromPartial() method
-		{
-			code: `
-        import { ChatSettings } from '@shared/proto/state';
-        
-        const settings = ChatSettings.fromPartial({
-          mode: 0,
-          preferredLanguage: 'en',
-          openAiReasoningEffort: 'thorough'
-        });
-      `,
-		},
-		// Valid case: Object literal not used with protobuf type
-		{
-			code: `
-        interface MyInterface {
-          id: number;
-          name: string;
-        }
-        
-        const obj: MyInterface = {
-          id: 123,
-          name: 'test'
-        };
-      `,
-		},
-		// Valid case: Using object literal for non-protobuf import
-		{
-			code: `
-        import { SomeType } from '@some/other/package';
-
-        const obj: SomeType = {
-          id: 123,
-          name: 'test'
-        };
-      `,
-		},
-		// Valid case: Regular function call with object literal (should not be flagged)
-		{
-			code: `
-        import { State } from '@shared/proto/state';
-
-        // This should not be flagged because it's a regular function call
-        // not directly tied to a protobuf type
-        process({
-          id: 123,
-          name: 'test',
-          data: { nested: true }
-        });
-      `,
-		},
-	],
-	invalid: [
-		// Invalid case: Using object literal with imported protobuf type
-		{
-			code: `
-        import { State } from '@shared/proto/state';
-
-        const state: State = {
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        };
-      `,
-			output: `
-        import { State } from '@shared/proto/state';
-
-        const state: State = State.create({
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        });
-      `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Invalid case: Using object literal with namespaced protobuf type
-		{
-			code: `
-        import * as stateProto from '@shared/proto/state';
-
-        const state: stateProto.State = {
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        };
-      `,
-			output: `
-        import * as stateProto from '@shared/proto/state';
-
-        const state: stateProto.State = stateProto.State.create({
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        });
-      `,
-			errors: [{ messageId: "useProtobufMethodGeneric" }],
-		},
-		// Invalid case: Using object literal in a return statement (with protobuf return type)
-		{
-			code: `
-        import { ChatSettings } from '@shared/proto/state';
-
-        function createSettings(): ChatSettings {
-          return {
-            mode: 0,
-            preferredLanguage: 'en',
-            openAiReasoningEffort: 'thorough'
-          };
-        }
-      `,
-			output: `
-        import { ChatSettings } from '@shared/proto/state';
-
-        function createSettings(): ChatSettings {
-          return ChatSettings.create({
-            mode: 0,
-            preferredLanguage: 'en',
-            openAiReasoningEffort: 'thorough'
-          });
-        }
-      `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Invalid case: Using object literal in a function parameter (with protobuf types imported)
-		{
-			code: `
-        import { ChatContent } from '@shared/proto/state';
-
-        function processContent(content: ChatContent) {
-          // process the content
-        }
-
-        processContent({
-          message: 'Hello, this is a test message',
-          images: ['image1.png', 'image2.jpg'],
-          files: ['file1.txt', 'file2.pdf']
-        });
-      `,
-			output: `
-        import { ChatContent } from '@shared/proto/state';
-
-        function processContent(content: ChatContent) {
-          // process the content
-        }
-
-        processContent(ChatContent.create({
-          message: 'Hello, this is a test message',
-          images: ['image1.png', 'image2.jpg'],
-          files: ['file1.txt', 'file2.pdf']
-        }));
-      `,
-			errors: [{ messageId: "useProtobufMethodGeneric" }],
-		},
-		// Invalid case: Using object literal in assignment expression
-		{
-			code: `
-        import { State } from '@shared/proto/state';
-
-        let state: State;
-        state = {
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        };
-      `,
-			output: `
-        import { State } from '@shared/proto/state';
-
-        let state: State;
-        state = State.create({
-          stateJson: '{"apiConfig":{"provider":"anthropic","model":"claude-3-haiku"}}'
-        });
-      `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Test with custom protobufPackages option
-		{
-			code: `
-        import { CustomProto } from 'custom/proto/package';
-
-        const obj: CustomProto = {
-          field1: 'value',
-          field2: 123
-        };
-      `,
-			output: `
-        import { CustomProto } from 'custom/proto/package';
-
-        const obj: CustomProto = CustomProto.create({
-          field1: 'value',
-          field2: 123
-        });
-      `,
-			options: [{ protobufPackages: ["custom/proto"] }],
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-	],
-})

eslint-rules/index.js

@@ -1,17 +1,14 @@
 // eslint-rules/index.js
-const noProtobufObjectLiterals = require("./no-protobuf-object-literals")
 const noDirectVscodeApi = require("./no-direct-vscode-api")
 
 module.exports = {
 	rules: {
-		"no-protobuf-object-literals": noProtobufObjectLiterals,
 		"no-direct-vscode-api": noDirectVscodeApi,
 	},
 	configs: {
 		recommended: {
 			plugins: ["local"],
 			rules: {
-				"local/no-protobuf-object-literals": "error",
 				"local/no-direct-vscode-api": "warn",
 			},
 		},

eslint-rules/no-direct-vscode-api.js

@@ -29,23 +29,30 @@ const disallowedApis = {
 	"vscode.workspace.applyEdit": {
 		messageId: "useHostBridge",
 	},
-	// "vscode.env.openExternal": {
-	// 	messageId: "useUtils",
-	// },
-	// "vscode.window.showWarningMessage": {
-	// 	messageId: "useHostBridgeShowMessage",
-	// },
+	"vscode.window.onDidChangeActiveTextEditor": {
+		messageId: "useHostBridge",
+	},
+	"vscode.env.openExternal": {
+		messageId: "useUtils",
+	},
+	"vscode.window.showWarningMessage": {
+		messageId: "useHostBridgeShowMessage",
+	},
 	"vscode.window.showOpenDialog": {
 		messageId: "useHostBridgeShowMessage",
 	},
-	// There are too many warnings for these calls, uncomment the following
-	// when the migration is finished.
-	// "vscode.window.showErrorMessage": {
-	// 	messageId: "useHostBridgeShowMessage",
-	// },
-	// "vscode.window.showInformationMessage": {
-	// 	messageId: "useHostBridgeShowMessage",
-	// },
+	"vscode.window.showErrorMessage": {
+		messageId: "useHostBridgeShowMessage",
+	},
+	"vscode.window.showInformationMessage": {
+		messageId: "useHostBridgeShowMessage",
+	},
+	"vscode.window.showInputBox": {
+		messageId: "useHostBridge",
+	},
+	"vscode.workspace.findFiles": {
+		messageId: "useNative",
+	},
 }
 
 module.exports = createRule({
@@ -86,6 +93,10 @@ module.exports = createRule({
 				"Use utilities in @/utils instead of calling vscode APIs directly.\n" +
 				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
 				"Found: {{code}}",
+			useNative:
+				"Use a native Javascript API instead of calling the vscode API.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
 		},
 		schema: [],
 	},
@@ -186,6 +197,10 @@ module.exports = createRule({
 			if (filename.includes("/standalone/runtime-files/")) {
 				return true
 			}
+			// Skip checking test files
+			if (filename.endsWith(".test.ts")) {
+				return true
+			}
 		}
 
 		return {

eslint-rules/no-protobuf-object-literals.js

@@ -1,556 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils")
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
-
-module.exports = createRule({
-	name: "no-protobuf-object-literals",
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce using .create() or .fromPartial() for protobuf objects instead of object literals",
-			recommended: "error",
-		},
-		fixable: "code",
-		messages: {
-			useProtobufMethod:
-				"Use {{typeName}}.create() or {{typeName}}.fromPartial() instead of " +
-				"object literal for protobuf type from @shared/proto\n" +
-				"Found: {{code}}\n  Suggestion: " +
-				"{{typeName}}.create({{objectContent}})",
-			useProtobufMethodGeneric:
-				"Use .create() or .fromPartial() instead of object literal for protobuf " +
-				"type from @shared/proto\n  Found: {{code}}",
-		},
-		schema: [
-			{
-				type: "object",
-				properties: {
-					protobufPackages: {
-						type: "array",
-						items: { type: "string" },
-						default: ["shared/proto/"],
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-	},
-	defaultOptions: [{ protobufPackages: ["shared/proto/"] }],
-
-	create(context, [options]) {
-		const protobufPackages = options.protobufPackages
-		const protobufImports = new Set() // Set of imported protobuf types
-		const protobufNamespaceImports = new Set() // For namespace imports like "import * as proto"
-		const safeObjectExpressions = new Set() // Track object expressions in create/fromPartial calls
-
-		return {
-			// Skip object literals inside create() or fromPartial() method calls
-			CallExpression(node) {
-				if (
-					node.callee &&
-					node.callee.type === "MemberExpression" &&
-					(node.callee.property.name === "create" || node.callee.property.name === "fromPartial") &&
-					node.arguments.length > 0 &&
-					node.arguments[0].type === "ObjectExpression"
-				) {
-					// Track this object expression as being used with create/fromPartial
-					safeObjectExpressions.add(node.arguments[0])
-				}
-			},
-
-			// Track imports from protobuf packages
-			ImportDeclaration(node) {
-				const packageName = node.source.value
-
-				if (matchesProtobufPackage(packageName, protobufPackages)) {
-					// This is a protobuf package.
-					node.specifiers.forEach((spec) => {
-						if (spec.type === "ImportSpecifier") {
-							// import { MyRequest } from '@shared/proto'
-							protobufImports.add(spec.imported.name)
-						} else if (spec.type === "ImportNamespaceSpecifier") {
-							// import * as proto from '@shared/proto'
-							protobufNamespaceImports.add(spec.local.name)
-						}
-					})
-				}
-			},
-
-			// Check variable declarations with type annotations
-			"VariableDeclarator > ObjectExpression"(node) {
-				// Skip if this is inside a create/fromPartial call
-				if (safeObjectExpressions.has(node)) {
-					return
-				}
-
-				// Found object literal in variable declaration
-				const declarator = node.parent
-
-				if (declarator.id && declarator.id.typeAnnotation) {
-					const typeName = getTypeName(declarator.id.typeAnnotation.typeAnnotation)
-					if (typeName) {
-						// Check if it's a direct protobuf import
-						if (protobufImports.has(typeName)) {
-							//console.log('🚨 VIOLATION: Using object literal for protobuf type:', typeName);
-							const sourceCode = context.getSourceCode()
-							const declaratorText = sourceCode.getText(declarator)
-							const objectText = sourceCode.getText(node)
-
-							context.report({
-								node,
-								messageId: "useProtobufMethod",
-								data: {
-									typeName,
-									code: declaratorText,
-									objectContent: objectText,
-								},
-								fix(fixer) {
-									// Replace the object literal with Type.create() call
-									return fixer.replaceText(node, `${typeName}.create(${objectText})`)
-								},
-							})
-							return
-						}
-
-						// Check if it's a namespaced protobuf type (e.g., proto.MyRequest)
-						if (isNamespacedProtobufType(protobufNamespaceImports, typeName)) {
-							//console.log('🚨 VIOLATION: Using object literal for namespaced protobuf type:', typeName);
-							const sourceCode = context.getSourceCode()
-							const declaratorText = sourceCode.getText(declarator)
-							context.report({
-								node,
-								messageId: "useProtobufMethodGeneric",
-								data: { code: declaratorText },
-								fix(fixer) {
-									// For namespaced types, use the full type name to call create()
-									return fixer.replaceText(node, `${typeName}.create(${sourceCode.getText(node)})`)
-								},
-							})
-						}
-					}
-				}
-			},
-
-			// Check assignment expressions
-			"AssignmentExpression > ObjectExpression"(node) {
-				// Skip if this is inside a create/fromPartial call
-				if (safeObjectExpressions.has(node)) {
-					return
-				}
-
-				const assignment = node.parent
-
-				// For assignment to variables without inline type annotation
-				if (assignment.left && assignment.right === node) {
-					let typeName = null
-
-					// Check if there's a typeAnnotation directly on the left
-					if (assignment.left.typeAnnotation) {
-						typeName = getTypeName(assignment.left.typeAnnotation.typeAnnotation)
-					}
-					// Otherwise try to infer from the variable name if it's a simple identifier
-					else if (assignment.left.type === "Identifier") {
-						const varName = assignment.left.name
-						// Check variable declarations in the current scope
-						const sourceCode = context.getSourceCode()
-						const scope = sourceCode.getScope(node)
-						const variable = scope.variables.find((v) => v.name === varName)
-						if (variable && variable.defs.length > 0) {
-							const def = variable.defs[0]
-							if (def.node.id && def.node.id.typeAnnotation) {
-								typeName = getTypeName(def.node.id.typeAnnotation.typeAnnotation)
-							}
-						}
-					}
-
-					if (typeName && protobufImports.has(typeName)) {
-						//console.log('🚨 VIOLATION: Using object literal in assignment for protobuf type:', typeName);
-						const sourceCode = context.getSourceCode()
-						const assignmentText = sourceCode.getText(assignment.left) + " = "
-						const objectText = sourceCode.getText(node)
-
-						context.report({
-							node,
-							messageId: "useProtobufMethod",
-							data: {
-								typeName,
-								code: assignmentText + "{",
-								objectContent: objectText,
-							},
-							fix(fixer) {
-								// Replace the object literal with Type.create() call in assignments
-								return fixer.replaceText(node, `${typeName}.create(${objectText})`)
-							},
-						})
-					}
-				}
-			},
-
-			// Check return statements
-			"ReturnStatement > ObjectExpression"(node) {
-				// Skip if this is inside a create/fromPartial call
-				if (safeObjectExpressions.has(node)) {
-					return
-				}
-
-				// Find the parent function to get its return type
-				const functionNode = findParentFunction(node)
-				if (!functionNode) {
-					return
-				}
-
-				// Try to get the return type using our enhanced helper
-				const sourceCode = context.getSourceCode()
-				let returnTypeName = getFunctionReturnType(functionNode, sourceCode)
-
-				// For async functions with Promise<Type> return type, extract the inner type
-				if (returnTypeName && returnTypeName.startsWith("Promise<") && returnTypeName.endsWith(">")) {
-					returnTypeName = returnTypeName.slice(8, -1)
-				}
-
-				// Check if the return type is a protobuf type
-				if (returnTypeName) {
-					if (protobufImports.has(returnTypeName)) {
-						//console.log('🚨 VIOLATION: Return type is a protobuf type:', returnTypeName);
-						const sourceCode = context.getSourceCode()
-						const returnText = sourceCode.getText(node.parent)
-						context.report({
-							node,
-							messageId: "useProtobufMethod",
-							data: {
-								typeName: returnTypeName,
-								code: returnText,
-								objectContent: sourceCode.getText(node),
-							},
-							fix(fixer) {
-								// Replace the object literal with Type.create() call in return statements
-								return fixer.replaceText(node, `${returnTypeName}.create(${sourceCode.getText(node)})`)
-							},
-						})
-						return
-					}
-
-					// Check if it's a namespaced protobuf type
-					if (isNamespacedProtobufType(protobufNamespaceImports, returnTypeName)) {
-						const sourceCode = context.getSourceCode()
-						const returnText = sourceCode.getText(node.parent)
-						//console.log('🚨 VIOLATION: Return type is a namespaced protobuf type:', returnTypeName);
-						context.report({
-							node,
-							messageId: "useProtobufMethodGeneric",
-							data: { code: returnText },
-							fix(fixer) {
-								// For namespaced types in return statements, we need to extract the full type name
-								const objectCode = sourceCode.getText(node)
-								// Since we may not know the exact type, we'll use the more generic namespaced type
-								return fixer.replaceText(node, `${returnTypeName}.create(${objectCode})`)
-							},
-						})
-						return
-					}
-				}
-
-				// Final fallback - if there are any protobuf imports and the function signature
-				// mentions a return type that matches one of the imported types
-				const functionText = functionNode ? sourceCode.getText(functionNode) : ""
-
-				for (const protoType of protobufImports) {
-					// Use more precise regex to match return type patterns specifically
-					// Rather than just checking if the type name appears anywhere in the signature
-					const returnTypeRegex = new RegExp(
-						// Match arrow function return type
-						`=>\\s*:?\\s*${protoType}\\b|` +
-							// Match function declaration return type
-							`\\)\\s*:?\\s*${protoType}\\b|` +
-							// Match Promise return type
-							`\\)\\s*:?\\s*Promise<\\s*${protoType}\\s*>|` +
-							// Match function type in variable declaration
-							`:\\s*\\(.*\\)\\s*=>\\s*${protoType}\\b`,
-					)
-
-					if (returnTypeRegex.test(functionText)) {
-						const returnText = sourceCode.getText(node.parent)
-						//console.log('🚨 VIOLATION: regex matched protobuf type:', functionText);
-						context.report({
-							node,
-							messageId: "useProtobufMethod",
-							data: {
-								typeName: protoType,
-								code: returnText,
-								objectContent: sourceCode.getText(node),
-							},
-							fix(fixer) {
-								// Replace the object literal with Type.create() call
-								return fixer.replaceText(node, `${protoType}.create(${sourceCode.getText(node)})`)
-							},
-						})
-						return
-					}
-				}
-				// Check for namespace imports too
-				for (const namespace of protobufNamespaceImports) {
-					// Similar to above, but for namespaced types
-					const namespaceReturnTypeRegex = new RegExp(
-						// Match arrow function return type
-						`=>\\s*:?\\s*${namespace}\\.\\w+\\b|` +
-							// Match function declaration return type
-							`\\)\\s*:?\\s*${namespace}\\.\\w+\\b|` +
-							// Match Promise return type
-							`\\)\\s*:?\\s*Promise<\\s*${namespace}\\.\\w+\\s*>|` +
-							// Match function type in variable declaration
-							`:\\s*\\(.*\\)\\s*=>\\s*${namespace}\\.\\w+\\b`,
-					)
-
-					if (namespaceReturnTypeRegex.test(functionText)) {
-						const returnText = sourceCode.getText(node.parent)
-						//console.log('🚨 VIOLATION: regex matched namespaced protobuf type:', functionText, "namespace:", namespace);
-						context.report({
-							node,
-							messageId: "useProtobufMethodGeneric",
-							data: { code: returnText },
-							fix(fixer) {
-								// For namespaced types based on function signature patterns
-								// Extract the namespace and type from the function text using more precise patterns
-								const match = functionText.match(
-									new RegExp(
-										// Match return type patterns more precisely
-										`\\)\\s*:?\\s*(${namespace}\\.[\\w]+)\\b|` + // Function declaration
-											`=>\\s*:?\\s*(${namespace}\\.[\\w]+)\\b|` + // Arrow function
-											`Promise<\\s*(${namespace}\\.[\\w]+)\\s*>`, // Promise wrapped
-									),
-								)
-								if (match) {
-									const fullType = match[1] || match[2]
-									return fixer.replaceText(node, `${fullType}.create(${sourceCode.getText(node)})`)
-								}
-								// Fallback - we can't determine the exact type, but we know it's from the namespace
-								// Use a namespace-based approach
-								return fixer.replaceText(node, `${namespace}.create(${sourceCode.getText(node)})`)
-							},
-						})
-						return
-					}
-				}
-			},
-
-			// Check function call arguments (more selective approach)
-			"CallExpression > ObjectExpression"(node) {
-				// Skip if this is inside a create/fromPartial call
-				if (safeObjectExpressions.has(node)) {
-					return
-				}
-
-				// We need to be more selective to avoid false positives
-				// Only warn if:
-				// 1. The function is called on a protobuf namespace
-				// 2. The call argument has a type annotation that matches a protobuf type
-				// 3. The call is to a function that we know takes a protobuf type
-
-				// Check if it's a call on a protobuf namespace
-				if (
-					node.parent.callee &&
-					node.parent.callee.type === "MemberExpression" &&
-					node.parent.callee.object.type === "Identifier"
-				) {
-					const namespace = node.parent.callee.object.name
-					if (protobufNamespaceImports.has(namespace)) {
-						const sourceCode = context.getSourceCode()
-						const callText = sourceCode.getText(node.parent)
-						//console.log('🚨 VIOLATION: Check function call arguments object literal:', callText);
-						context.report({
-							node,
-							messageId: "useProtobufMethodGeneric",
-							data: { code: callText },
-							fix(fixer) {
-								// For calls on a protobuf namespace
-								const memberExpr = node.parent.callee
-								// Try to determine if this is calling a method that expects a specific type
-								const methodName = memberExpr.property.name
-
-								// If method name looks like 'create' + Type, we can infer the type
-								const possibleTypeName = methodName.replace(/^create/, "")
-
-								// Check if namespace has a type with this name
-								// Since we can't directly check at lint time, we'll use the namespace + inferred type
-								if (possibleTypeName && possibleTypeName !== methodName) {
-									return fixer.replaceText(
-										node,
-										`${namespace}.${possibleTypeName}.create(${sourceCode.getText(node)})`,
-									)
-								}
-
-								// Fallback - use a more generic approach with namespace
-								return fixer.replaceText(node, `${namespace}.create(${sourceCode.getText(node)})`)
-							},
-						})
-						return
-					}
-				}
-
-				// For regular function calls with object literals, check if there are protobuf imports
-				// and if the function might expect a protobuf type
-				if (node.parent.callee) {
-					// This is a more permissive check to catch cases like processContent({ ... })
-					// which might be passing a protobuf type
-					const sourceCode = context.getSourceCode()
-					const scope = sourceCode.getScope(node)
-
-					// Try to find the function definition
-					if (node.parent.callee.type === "Identifier") {
-						const functionName = node.parent.callee.name
-						const variable = scope.variables.find((v) => v.name === functionName)
-
-						// If we found the function and it has parameter type annotations
-						// that match protobuf types, flag it
-						if (variable && variable.defs.length > 0) {
-							const def = variable.defs[0]
-							if (def.node.params && node.parent.arguments.indexOf(node) < def.node.params.length) {
-								const param = def.node.params[node.parent.arguments.indexOf(node)]
-								if (param.typeAnnotation) {
-									const typeName = getTypeName(param.typeAnnotation.typeAnnotation)
-									if (
-										typeName &&
-										(protobufImports.has(typeName) ||
-											isNamespacedProtobufType(protobufNamespaceImports, typeName))
-									) {
-										const callText = sourceCode.getText(node.parent)
-										//console.log('🚨 VIOLATION: Function call arguments object literal:', callText);
-										context.report({
-											node,
-											messageId: "useProtobufMethodGeneric",
-											data: { code: callText },
-											fix(fixer) {
-												// For function calls with protobuf type parameters
-												return fixer.replaceText(node, `${typeName}.create(${sourceCode.getText(node)})`)
-											},
-										})
-										return
-									}
-								}
-							}
-						}
-					}
-				}
-			},
-		}
-	},
-})
-
-// Helper functions
-function getTypeName(typeAnnotation) {
-	if (!typeAnnotation) {
-		return null
-	}
-
-	if (typeAnnotation.type === "TSTypeReference") {
-		if (typeAnnotation.typeName.type === "Identifier") {
-			return typeAnnotation.typeName.name
-		} else if (typeAnnotation.typeName.type === "TSQualifiedName") {
-			// Handle namespaced types like proto.MyRequest
-			return `${typeAnnotation.typeName.left.name}.${typeAnnotation.typeName.right.name}`
-		}
-	}
-	return null
-}
-
-function matchesProtobufPackage(packageName, protobufPackages) {
-	return protobufPackages.some((protobufPackage) => {
-		// Remove leading and trailing @ and / from protobufPackage
-		const cleanedPackage = protobufPackage.replace(/^[@\/]/, "").replace(/[\/]$/, "")
-		const pattern = new RegExp(`(.*[@/]|)${escapeRegex(cleanedPackage)}[/].*`)
-		return pattern.test(packageName)
-	})
-}
-
-// Helper function to escape special regex characters
-function escapeRegex(string) {
-	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-// Helper to extract function return type more reliably
-function getFunctionReturnType(functionNode, sourceCode) {
-	// 1. Check explicit return type annotation
-	if (functionNode.returnType) {
-		return getTypeName(functionNode.returnType.typeAnnotation)
-	}
-
-	// 2. For variable declarations like const foo: (arg: Type) => ReturnType = ...
-	if (functionNode.parent && functionNode.parent.type === "VariableDeclarator") {
-		const declarator = functionNode.parent
-		if (declarator.id && declarator.id.typeAnnotation) {
-			const typeAnnotation = declarator.id.typeAnnotation.typeAnnotation
-
-			// Handle function type annotations
-			if (typeAnnotation.type === "TSFunctionType" && typeAnnotation.typeAnnotation) {
-				return getTypeName(typeAnnotation.typeAnnotation)
-			}
-
-			// Handle type references to function types
-			if (typeAnnotation.type === "TSTypeReference") {
-				// This might be a type like Promise<ReturnType>
-				if (
-					typeAnnotation.typeName.name === "Promise" &&
-					typeAnnotation.typeParameters &&
-					typeAnnotation.typeParameters.params.length > 0
-				) {
-					return getTypeName(typeAnnotation.typeParameters.params[0])
-				}
-			}
-		}
-	}
-
-	// 3. For class methods, check if it's part of an interface implementation
-	if (
-		functionNode.parent &&
-		functionNode.parent.type === "MethodDefinition" &&
-		functionNode.parent.parent &&
-		functionNode.parent.parent.type === "ClassBody"
-	) {
-		const className = getEnclosingClassName(functionNode)
-		const methodName = functionNode.parent.key.name
-
-		if (className && methodName) {
-			// Look for interface declarations in the scope
-			const scope = sourceCode.getScope(functionNode)
-			// This would require more complex scope analysis which is limited in ESLint
-			// For now, we'll return null and rely on other methods
-		}
-	}
-
-	return null
-}
-
-// Helper to get the class name for a method
-function getEnclosingClassName(node) {
-	let current = node.parent
-	while (current) {
-		if (current.type === "ClassDeclaration" && current.id) {
-			return current.id.name
-		}
-		current = current.parent
-	}
-	return null
-}
-function isNamespacedProtobufType(protobufNamespaceImports, typeName) {
-	if (!typeName.includes(".")) {
-		return false
-	}
-
-	const namespace = typeName.split(".")[0]
-	return protobufNamespaceImports.has(namespace)
-}
-
-function findParentFunction(node) {
-	let current = node.parent
-	while (current) {
-		if (
-			current.type === "FunctionDeclaration" ||
-			current.type === "FunctionExpression" ||
-			current.type === "ArrowFunctionExpression"
-		) {
-			return current
-		}
-		current = current.parent
-	}
-	return null
-}

evals/cli/src/commands/runDiffEval.ts

@@ -10,6 +10,7 @@ interface RunDiffEvalOptions {
 	parsingFunction: string
 	diffEditFunction: string
 	thinkingBudget: number
+	provider: string
 	parallel: boolean
 	verbose: boolean
 	testPath: string
@@ -39,6 +40,8 @@ export async function runDiffEvalHandler(options: RunDiffEvalOptions) {
 		options.parsingFunction,
 		"--diff-edit-function",
 		options.diffEditFunction,
+		"--provider",
+		options.provider,
 	]
 
 	// Conditionally add the optional arguments

evals/cli/src/index.ts

@@ -92,6 +92,7 @@ program
 	.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 	.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
 	.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
+	.option("--provider <provider>", "API provider to use (openrouter, openai)", "openrouter")
 	.option("--parallel", "Run tests in parallel", false)
 	.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
 	.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")

evals/diff-edits/ClineWrapper.ts

@@ -1,9 +1,9 @@
 import { OpenRouterHandler } from "../../src/api/providers/openrouter"
+import { OpenAiNativeHandler } from "../../src/api/providers/openai-native"
 import { ApiHandlerOptions } from "../../src/shared/api"
 import { Anthropic } from "@anthropic-ai/sdk"
 
 import {
-	parseAssistantMessageV1,
 	parseAssistantMessageV2,
 	parseAssistantMessageV3,
 	AssistantMessageContent,
@@ -17,7 +17,6 @@ type ParseAssistantMessageFn = (message: string) => AssistantMessageContent[]
 type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string | any>
 
 const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
-	parseAssistantMessageV1: parseAssistantMessageV1,
 	parseAssistantMessageV2: parseAssistantMessageV2,
 	parseAssistantMessageV3: parseAssistantMessageV3,
 }
@@ -54,7 +53,7 @@ interface StreamResult {
  * Process the stream and return full response with timing data
  */
 async function processStream(
-	handler: OpenRouterHandler,
+	handler: OpenRouterHandler | OpenAiNativeHandler,
 	systemPrompt: string,
 	messages: Anthropic.Messages.MessageParam[],
 ): Promise<StreamResult> {
@@ -190,19 +189,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 			}
 		}
 
-		const options: ApiHandlerOptions = {
-			openRouterApiKey: apiKey,
-			openRouterModelId: modelId,
-			thinkingBudgetTokens: thinkingBudgetTokens,
-			openRouterModelInfo: {
-				maxTokens: 10_000,
-				contextWindow: 1_000_000,
-				supportsImages: true,
-				supportsPromptCache: true, // may need to turn this on
-				inputPrice: 0,
-				outputPrice: 0,
-			},
-		}
+		const provider = input.provider || "openrouter"
 
 		// Get the output of streaming output of this llm call
 		let streamResult: StreamResult
@@ -214,10 +201,34 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 				usage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, totalCost: 0 },
 			}
 		} else {
-			// Live mode: existing API call logic
+			// Live mode: provider-specific API call logic
 			try {
-				const openRouterHandler = new OpenRouterHandler(options)
-				streamResult = await processStream(openRouterHandler, systemPrompt, messages)
+				let handler: OpenRouterHandler | OpenAiNativeHandler
+				
+				if (provider === "openai") {
+					const openAiOptions = {
+						openAiNativeApiKey: apiKey,
+						apiModelId: modelId,
+					}
+					handler = new OpenAiNativeHandler(openAiOptions)
+				} else {
+					const openRouterOptions = {
+						openRouterApiKey: apiKey,
+						openRouterModelId: modelId,
+						thinkingBudgetTokens: thinkingBudgetTokens,
+						openRouterModelInfo: {
+							maxTokens: 10_000,
+							contextWindow: 1_000_000,
+							supportsImages: true,
+							supportsPromptCache: true,
+							inputPrice: 0,
+							outputPrice: 0,
+						},
+					}
+					handler = new OpenRouterHandler(openRouterOptions)
+				}
+				
+				streamResult = await processStream(handler, systemPrompt, messages)
 			} catch (error: any) {
 				return {
 					success: false,

evals/diff-edits/TestRunner.ts

@@ -49,16 +49,25 @@ type TestResultSet = { [test_id: string]: (TestResult & { test_id?: string })[]
 
 class NodeTestRunner {
 	private apiKey: string | undefined
+	private provider: string
 	private currentRunId: string | null = null
 	private systemPromptHash: string | null = null
 	private processingFunctionsHash: string | null = null
 	private caseIdMap: Map<string, string> = new Map() // test_id -> case_id mapping
 
-	constructor(isReplay: boolean) {
+	constructor(isReplay: boolean, provider: string = "openrouter") {
+		this.provider = provider
 		if (!isReplay) {
-			this.apiKey = process.env.OPENROUTER_API_KEY
-			if (!this.apiKey) {
-				throw new Error("OPENROUTER_API_KEY environment variable not set for a non-replay run.")
+			if (provider === "openai") {
+				this.apiKey = process.env.OPENAI_API_KEY
+				if (!this.apiKey) {
+					throw new Error("OPENAI_API_KEY environment variable not set for a non-replay run with OpenAI provider.")
+				}
+			} else {
+				this.apiKey = process.env.OPENROUTER_API_KEY
+				if (!this.apiKey) {
+					throw new Error("OPENROUTER_API_KEY environment variable not set for a non-replay run with OpenRouter provider.")
+				}
 			}
 		}
 	}
@@ -635,6 +644,7 @@ class NodeTestRunner {
 			thinkingBudgetTokens: testConfig.thinking_tokens_budget,
 			originalDiffEditToolCallMessage: testConfig.replay ? testCase.original_diff_edit_tool_call_message : undefined,
 			diffApplyFile: testConfig.diff_apply_file,
+			provider: this.provider,
 			isVerbose: isVerbose,
 		}
 
@@ -927,6 +937,7 @@ async function main() {
 		.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 		.option("--diff-edit-function <name>", "The diff editing function to use", "diff-06-26-25")
 		.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
+		.option("--provider <provider>", "API provider to use (openrouter, openai)", "openrouter")
 		.option("--parallel", "Run tests in parallel", false)
 		.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
 		.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
@@ -959,7 +970,7 @@ async function main() {
 		? parseInt(options.maxAttemptsPerCase, 10)
 		: validAttemptsPerCase * 10;
 
-	const runner = new NodeTestRunner(options.replay || !!options.replayRunId)
+	const runner = new NodeTestRunner(options.replay || !!options.replayRunId, options.provider)
 
 	if (options.replayRunId) {
 		if (!options.diffApplyFile) {
@@ -979,7 +990,7 @@ async function main() {
 			log(isVerbose, "Warning: Could not load OpenRouter model data. Context window filtering might be affected for OpenRouter models.");
 		}
 
-		const runner = new NodeTestRunner(options.replay)
+		const runner = new NodeTestRunner(options.replay, options.provider)
 		let allLoadedTestCases = runner.loadTestCases(testPath, isVerbose) // Pass isVerbose
 		
 		const allProcessedTestCasesGlobal: ProcessedTestCase[] = allLoadedTestCases.map((tc) => ({

evals/diff-edits/dashboard/app.py

@@ -331,6 +331,42 @@ def get_performance_grade(success_rate):
     else:
         return "C", "poor"
 
+def get_error_description(error_enum, error_string=None):
+    """Map error enum values to user-friendly descriptions"""
+    error_map = {
+        1: "No tool calls - Model didn't use the replace_in_file tool",
+        2: "Multiple tool calls - Model called multiple tools instead of one", 
+        3: "Wrong tool call - Model used wrong tool (not replace_in_file)",
+        4: "Missing parameters - Tool call missing required path or diff",
+        5: "Wrong file edited - Model edited different file than expected",
+        6: "Wrong tool call - Model used wrong tool type",
+        7: "Wrong file edited - Model targeted incorrect file path",
+        8: "API/Stream error - Problem with model API connection",
+        9: "Configuration error - Invalid evaluation parameters",
+        10: "Function error - Invalid parsing/diff functions",
+        11: "Other error - Unexpected failure"
+    }
+    
+    base_description = error_map.get(error_enum, f"Unknown error (code: {error_enum})")
+    
+    if error_string:
+        return f"{base_description}: {error_string}"
+    return base_description
+
+def get_error_guidance(error_enum):
+    """Provide specific guidance based on error type"""
+    guidance_map = {
+        1: "💡 The model provided a response but didn't use the replace_in_file tool. Check the raw output to see what the model actually said.",
+        2: "💡 The model called multiple tools when it should only call replace_in_file once. Check the parsed tool call section.",
+        3: "💡 The model used a different tool instead of replace_in_file. This might indicate confusion about the task.",
+        4: "💡 The model called replace_in_file but didn't provide the required 'path' or 'diff' parameters.",
+        5: "💡 The model tried to edit a different file than expected. Check the parsed tool call to see which file it targeted.",
+        6: "💡 The model used the wrong tool type. Check the raw output to see what tool it attempted to use.",
+        7: "💡 The model tried to edit a different file path than expected. This could indicate path confusion or hallucination.",
+    }
+    
+    return guidance_map.get(error_enum, "")
+
 def render_hero_section(current_run, model_performance):
     """Render the hero section with key metrics"""
     run_title = current_run['description'] if current_run['description'] else f"Run {current_run['run_id'][:8]}..."
@@ -570,12 +606,16 @@ def render_result_detail(result):
     """Render detailed view of a single result"""
     st.markdown("### 🔬 Result Deep Dive")
     
-    # Check if this is a valid result
-    is_valid = (result['error_enum'] not in [1, 6, 7]) if not pd.isna(result['error_enum']) else True
+    # Check if this is a valid result (only invalid if no tool calls or wrong file)
+    is_valid = True
+    if not pd.isna(result['error_enum']):
+        # Only these specific errors make a result "invalid" for the benchmark:
+        # 1 = no_tool_calls, 5 = wrong_file_edited, 7 = wrong_file_edited
+        is_valid = result['error_enum'] not in [1, 5, 7]
     
     # Show validity warning if needed
     if not is_valid:
-        st.warning("⚠️ **This is an invalid result** - The model didn't properly call the diff edit tool or edited the wrong file. This result is excluded from success rate calculations.")
+        st.warning("⚠️ **This is an invalid result** - The model didn't call the replace_in_file tool or edited the wrong file. This result is excluded from success rate calculations.")
     
     # Result metadata
     col1, col2, col3, col4 = st.columns(4)
@@ -591,7 +631,10 @@ def render_result_detail(result):
         st.markdown(f"**Round Trip:** {result['time_round_trip_ms']:.0f}ms")
     
     with col4:
-        st.markdown(f"**Cost:** ${result['cost_usd']:.4f}")
+        if pd.notna(result['cost_usd']) and result['cost_usd'] is not None:
+            st.markdown(f"**Cost:** ${result['cost_usd']:.4f}")
+        else:
+            st.markdown(f"**Cost:** Free")
     
     # Tabbed interface for different views
     tab1, tab2, tab3, tab4 = st.tabs(["📄 File & Edits", "🤖 Raw Output", "🔧 Parsed Tool Call", "📊 Metrics"])
@@ -693,8 +736,46 @@ def render_file_and_edits_view(result):
             # Show error information
             st.error("❌ **Edit Failed**")
             
+            # Show detailed error reason
             if not pd.isna(result['error_enum']):
-                st.markdown(f"**Error Code:** {result['error_enum']}")
+                error_description = get_error_description(
+                    result['error_enum'], 
+                    result.get('error_string')
+                )
+                st.markdown(f"**Reason:** {error_description}")
+                
+                # Show specific guidance based on error type
+                guidance = get_error_guidance(result['error_enum'])
+                if guidance:
+                    st.info(guidance)
+            
+            # For valid results that failed, check for diff application failures
+            elif not result['succeeded']:
+                # This is a valid result that failed - likely due to diff application issues
+                raw_output = result.get('raw_model_output', '')
+                
+                # Check if we have specific error information in the raw output
+                if 'does not match anything in the file' in str(raw_output).lower():
+                    st.warning("⚠️ **Diff Application Failed**")
+                    st.info("💡 The SEARCH block in the diff didn't match any content in the original file. This usually means the model hallucinated code that doesn't exist.")
+                elif 'malformatted' in str(raw_output).lower() or 'malformed' in str(raw_output).lower():
+                    st.warning("⚠️ **Diff Format Error**")
+                    st.info("💡 The diff format was incorrect. Check the raw tool call to see the formatting issues.")
+                elif 'error:' in str(raw_output).lower():
+                    # Try to extract the specific error message
+                    lines = str(raw_output).split('\n')
+                    error_lines = [line for line in lines if 'error:' in line.lower()]
+                    if error_lines:
+                        error_msg = error_lines[0].strip()
+                        st.warning("⚠️ **Diff Application Failed**")
+                        st.info(f"💡 {error_msg}")
+                    else:
+                        st.warning("⚠️ **Diff Application Failed**")
+                        st.info("💡 The diff couldn't be applied to the original file. Check the raw output and parsed tool call for more details.")
+                else:
+                    # Generic diff application failure
+                    st.warning("⚠️ **Diff Application Failed**")
+                    st.info("💡 The model made a valid tool call but the diff couldn't be applied to the original file. This usually indicates a mismatch between the expected and actual file content.")
         else:
             # Show successful edit information
             st.success("✅ **Edit Successful**")
@@ -725,8 +806,25 @@ def render_file_and_edits_view(result):
                     if len(edited_lines) > 50:
                         st.text(f"... ({len(edited_lines) - 50} more lines)")
         
-        # Show parsed tool call if available
+        # Show raw and parsed tool calls if available
         if not pd.isna(result['parsed_tool_call_json']):
+            with st.expander("View Raw Tool Call"):
+                # Extract the raw tool call text from the model output
+                raw_output = result['raw_model_output'] if not pd.isna(result['raw_model_output']) else ""
+                
+                # Try to extract just the tool call portion
+                if raw_output and '<replace_in_file>' in raw_output:
+                    # Find the tool call block
+                    start_idx = raw_output.find('<replace_in_file>')
+                    end_idx = raw_output.find('</replace_in_file>') + len('</replace_in_file>')
+                    if start_idx != -1 and end_idx != -1:
+                        raw_tool_call = raw_output[start_idx:end_idx]
+                        st.code(raw_tool_call, language='xml')
+                    else:
+                        st.text("Tool call not found in raw output")
+                else:
+                    st.text("No raw tool call available")
+            
             with st.expander("View Parsed Tool Call"):
                 try:
                     parsed_call = json.loads(result['parsed_tool_call_json'])
@@ -795,8 +893,10 @@ def render_metrics_view(result):
         if not pd.isna(result['completion_tokens']):
             st.metric("Completion Tokens", int(result['completion_tokens']))
         
-        if not pd.isna(result['cost_usd']):
+        if pd.notna(result['cost_usd']) and result['cost_usd'] is not None:
             st.metric("Cost", f"${result['cost_usd']:.4f}")
+        else:
+            st.metric("Cost", "Free")
         
         if not pd.isna(result['tokens_in_context']):
             st.metric("Context Tokens", int(result['tokens_in_context']))

evals/diff-edits/parsing/parse-assistant-message-06-06-25.ts

@@ -70,246 +70,7 @@ export interface ToolUse {
 	partial: boolean
 }
 
-/**
- * @description **Version 1**
- * Parses an assistant message string potentially containing mixed text and tool usage blocks
- * marked with XML-like tags into an array of structured content objects.
- *
- * This version iterates through the message character by character, building an accumulator string.
- * It maintains state to track whether it's currently parsing text, a tool use block, or a specific tool parameter.
- * It detects the start and end of tool uses and parameters by checking if the accumulator ends with
- * the corresponding opening or closing tags.
- * Special handling is included for `write_to_file` and `new_rule` tool uses to correctly parse
- * the `content` parameter, which might contain the closing tag itself, by looking for the *last*
- * occurrence of the closing tag.
- * If the input string ends mid-tag or mid-content, the last block (text or tool use) is marked as partial.
- *
- * @param assistantMessage The raw string output from the assistant.
- * @returns An array of `AssistantMessageContent` objects, which can be `TextContent` or `ToolUse`.
- *          Blocks that were not fully closed by the end of the input string will have their `partial` flag set to `true`.
- */
-export function parseAssistantMessageV1(assistantMessage: string): AssistantMessageContent[] {
-	const contentBlocks: AssistantMessageContent[] = []
-	let currentTextContent: TextContent | undefined = undefined
-	let currentTextContentStartIndex = 0
-	let currentToolUse: ToolUse | undefined = undefined
-	let currentToolUseStartIndex = 0
-	let currentParamName: ToolParamName | undefined = undefined
-	let currentParamValueStartIndex = 0
-	let accumulator = ""
-
-	for (let i = 0; i < assistantMessage.length; i++) {
-		const char = assistantMessage[i]
-		accumulator += char
-
-		// --- State: Parsing a Tool Parameter ---
-		// there should not be a param without a tool use
-		if (currentToolUse && currentParamName) {
-			const currentParamValue = accumulator.slice(currentParamValueStartIndex)
-			const paramClosingTag = `</${currentParamName}>`
-			if (currentParamValue.endsWith(paramClosingTag)) {
-				// End of param value found
-				currentToolUse.params[currentParamName] = currentParamValue.slice(0, -paramClosingTag.length).trim()
-				currentParamName = undefined // Go back to parsing tool content or looking for next param
-				continue // Move to next character
-			} else {
-				// Partial param value is accumulating
-				continue // Move to next character
-			}
-		}
-
-		// --- State: Parsing a Tool Use (but not a specific parameter) ---
-		// no currentParamName
-		if (currentToolUse) {
-			const currentToolValue = accumulator.slice(currentToolUseStartIndex)
-			const toolUseClosingTag = `</${currentToolUse.name}>`
-
-			if (currentToolValue.endsWith(toolUseClosingTag)) {
-				// End of a tool use found
-				currentToolUse.partial = false
-				contentBlocks.push(currentToolUse)
-				currentToolUse = undefined // Go back to parsing text or looking for next tool
-				// Reset text start index in case text follows immediately
-				currentTextContentStartIndex = i + 1
-				continue // Move to next character
-			} else {
-				// Check if starting a new parameter within the current tool use
-				const possibleParamOpeningTags = toolParamNames.map((name) => `<${name}>`)
-				let foundParamStart = false
-				for (const paramOpeningTag of possibleParamOpeningTags) {
-					if (accumulator.endsWith(paramOpeningTag)) {
-						// Start of a new parameter found
-						currentParamName = paramOpeningTag.slice(1, -1) as ToolParamName
-						currentParamValueStartIndex = accumulator.length
-						foundParamStart = true
-						break
-					}
-				}
-				if (foundParamStart) {
-					continue // Move to next character
-				}
-
-				// Special case for write_to_file/new_rule content param allowing nested tags
-				// Check if a </content> tag appears, potentially indicating the end of the content param
-				// even if the main tool closing tag hasn't been seen yet.
-				const contentParamName: ToolParamName = "content"
-				if (
-					(currentToolUse.name === "write_to_file" || currentToolUse.name === "new_rule") &&
-					accumulator.endsWith(`</${contentParamName}>`)
-				) {
-					const toolContent = accumulator.slice(currentToolUseStartIndex)
-					const contentStartTag = `<${contentParamName}>`
-					const contentEndTag = `</${contentParamName}>`
-					const contentStartIndex = toolContent.indexOf(contentStartTag) + contentStartTag.length
-					// Use lastIndexOf to handle cases where </content> might appear within the content itself
-					const contentEndIndex = toolContent.lastIndexOf(contentEndTag)
-
-					// Ensure we found valid start/end tags and end is after start
-					if (
-						contentStartIndex !== -1 &&
-						contentEndIndex !== -1 &&
-						contentEndIndex > contentStartIndex - contentStartTag.length // Ensure end tag is after start tag begins
-					) {
-						// Check if this content param was already being parsed. If so, update it.
-						// If not, and we just found the closing tag, assign it.
-						// This handles cases where the </content> detection might fire before
-						// the <content> tag detection logic, or if the content is very short.
-						if (currentParamName === contentParamName) {
-							// Already parsing content, now we found the end tag
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							currentParamName = undefined // Finished with this param
-						} else if (currentParamName === undefined) {
-							// Not parsing a param, but found </content>. Assume it closes the content block.
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							// We stay in the "parsing tool use" state, looking for more params or the tool end tag.
-						}
-					}
-				}
-
-				// If none of the above, partial tool value is accumulating
-				continue // Move to next character
-			}
-		}
-
-		// --- State: Parsing Text (or looking for start of a tool use) ---
-		// no currentToolUse
-		let didStartToolUse = false
-		const possibleToolUseOpeningTags = toolUseNames.map((name) => `<${name}>`)
-		for (const toolUseOpeningTag of possibleToolUseOpeningTags) {
-			if (accumulator.endsWith(toolUseOpeningTag)) {
-				// Start of a new tool use found
-				const toolName = toolUseOpeningTag.slice(1, -1) as ToolUseName
-				currentToolUse = {
-					type: "tool_use",
-					name: toolName,
-					params: {},
-					partial: true,
-				}
-				currentToolUseStartIndex = accumulator.length
-
-				// This also indicates the end of the current text content block (if any)
-				if (currentTextContent) {
-					currentTextContent.partial = false
-					// Extract text content, removing the part that formed the tool opening tag
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					currentTextContent.content = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					// Only add if there's actual content
-					if (currentTextContent.content.length > 0) {
-						contentBlocks.push(currentTextContent)
-					}
-					currentTextContent = undefined
-				} else {
-					// Check if there was text before this tool use started
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					const potentialText = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					if (potentialText.length > 0) {
-						contentBlocks.push({
-							type: "text",
-							content: potentialText,
-							partial: false, // Ended because tool use started
-						})
-					}
-				}
-
-				didStartToolUse = true
-				break // Found tool start, stop checking for others
-			}
-		}
-
-		if (!didStartToolUse) {
-			// No tool use started, so it must be text content accumulating
-			// (or continuing after a closed tool use)
-			if (currentTextContent === undefined) {
-				// Start of a new text block
-				currentTextContentStartIndex = i - (accumulator.length - currentTextContentStartIndex - 1) // Adjust start index based on how much we've accumulated since the last block ended or the beginning
-				// If accumulator starts from 0, start index is i
-				if (contentBlocks.length === 0 && currentToolUse === undefined) {
-					currentTextContentStartIndex = accumulator.length - 1 // i
-				} else {
-					// Re-calculate based on the actual start of the current text segment
-					// Find the end of the last block
-					let lastBlockEndIndex = 0
-					if (contentBlocks.length > 0) {
-						const lastBlock = contentBlocks[contentBlocks.length - 1]
-						// Approximation: find where the accumulator matches the end of the message string representation of the last block. This is complex.
-						// Simpler: Assume text starts right after the last block ended implicitly at index i.
-						lastBlockEndIndex = i // Where the loop *was* when the last block finished processing
-						// Need a more robust way to track the end index of the *raw string* corresponding to the last block.
-						// Let's stick to the accumulator slice approach for simplicity in this version.
-						// The start index should be where the current *unmatched* text began.
-						let lastProcessedIndex = -1
-						if (contentBlocks.length > 0) {
-							// This requires knowing the raw string length of the previous block, which V1 doesn't explicitly track easily.
-							// We'll approximate based on the current accumulator and start index logic.
-							// The issue arises if a tool tag was just closed. accumulator contains everything up to i.
-							// lastBlockEndIndex should point to the character *after* the closing tag of the last block.
-						}
-						// Reset start index to the beginning of the *current* potential text block
-						currentTextContentStartIndex = accumulator.length - 1 // Start accumulating from the current character `i`
-					}
-
-					// If we just closed a tool, text starts *after* its closing tag
-					// The logic needs refinement here for accurate start index after a tool closure.
-					// Let's assume for now the start index logic inside the loop handles it via slicing.
-				}
-
-				currentTextContent = {
-					type: "text",
-					content: "", // Content will be filled by slicing accumulator
-					partial: true,
-				}
-			}
-			// Update text content based on the accumulator from its start index
-			currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trimStart() // Trim start to avoid leading space if text follows tool
-		}
-	} // End of loop
-
-	// --- Finalization after loop ---
-
-	// If a tool use was open at the end
-	if (currentToolUse) {
-		// If a parameter was open within that tool use
-		if (currentParamName) {
-			// The remaining accumulator content belongs to this partial parameter
-			currentToolUse.params[currentParamName] = accumulator.slice(currentParamValueStartIndex).trim()
-		}
-		// Add the potentially partial tool use block
-		contentBlocks.push(currentToolUse)
-	}
-	// If text content was being accumulated at the end
-	// Note: Only one of currentToolUse or currentTextContent can be defined here,
-	// as starting a tool use finalizes the preceding text block.
-	else if (currentTextContent) {
-		// Update content one last time
-		currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trim()
-		// Add the potentially partial text block only if it contains content
-		if (currentTextContent.content.length > 0) {
-			contentBlocks.push(currentTextContent)
-		}
-	}
-
-	return contentBlocks
-}
+// parseAssistantmessageV1 removed in https://github.com/cline/cline/pull/5425
 
 /**
  * @description **Version 2**

evals/diff-edits/types.ts

@@ -104,5 +104,6 @@ export interface TestInput {
 	thinkingBudgetTokens: number
 	originalDiffEditToolCallMessage?: string
 	diffApplyFile?: string
+	provider?: string
 	isVerbose: boolean
 }

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.19.7",
+	"version": "3.23.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -119,7 +119,8 @@
 				{
 					"type": "webview",
 					"id": "claude-dev.SidebarProvider",
-					"name": ""
+					"name": "",
+					"icon": "assets/icons/icon.svg"
 				}
 			]
 		},
@@ -338,14 +339,14 @@
 	},
 	"scripts": {
 		"vscode:prepublish": "npm run package",
-		"compile": "npm run check-types && npm run lint && node esbuild.js",
-		"compile-standalone": "npm run check-types && npm run lint && node esbuild.js --standalone",
+		"compile": "npm run check-types && npm run lint && node esbuild.mjs",
+		"compile-standalone": "npm run check-types && npm run lint && node esbuild.mjs --standalone",
 		"postcompile-standalone": "node scripts/package-standalone.mjs",
 		"watch": "npm-run-all -p watch:*",
-		"watch:esbuild": "node esbuild.js --watch",
+		"watch:esbuild": "node esbuild.mjs --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
-		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.js --production",
-		"protos": "node scripts/build-proto.mjs && node scripts/generate-server-setup.mjs && node scripts/generate-host-bridge-client.mjs",
+		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.mjs --production",
+		"protos": "node scripts/build-proto.mjs",
 		"postprotos": "prettier src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --log-level warn",
 		"clean": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"compile-tests": "node ./scripts/build-tests.js",
@@ -361,8 +362,8 @@
 		"test:unit": "TS_NODE_PROJECT='./tsconfig.unit-test.json' mocha",
 		"test:coverage": "vscode-test --coverage",
 		"e2e": "playwright test -c playwright.config.ts",
-		"test:e2e": "playwright install && vsce package --no-dependencies --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
-		"test:e2e:optimal": "vsce package --no-dependencies --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
+		"test:e2e": "playwright install && vsce package --no-dependencies --allow-package-secrets sendgrid --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
+		"test:e2e:optimal": "vsce package --no-dependencies --allow-package-secrets sendgrid --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
 		"install:all": "npm install && cd webview-ui && npm install",
 		"dev:webview": "cd webview-ui && npm run dev",
 		"build:webview": "cd webview-ui && npm run build",
@@ -446,6 +447,7 @@
 		"@playwright/test": "^1.53.2",
 		"@sentry/browser": "^9.12.0",
 		"@streamparser/json": "^0.0.22",
+		"@types/uuid": "^10.0.0",
 		"@vscode/codicons": "^0.0.36",
 		"archiver": "^7.0.1",
 		"axios": "^1.8.2",
@@ -490,6 +492,8 @@
 		"tree-sitter-wasms": "^0.1.11",
 		"ts-morph": "^25.0.1",
 		"turndown": "^7.2.0",
+		"ulid": "^2.4.0",
+		"uuid": "^11.1.0",
 		"vscode-uri": "^3.1.0",
 		"web-tree-sitter": "^0.22.6",
 		"zod": "^3.24.2"

playwright.config.ts

@@ -1,17 +1,32 @@
 import { defineConfig } from "@playwright/test"
 
-const isGitHubAction = !!process.env.CI
+const isCI = !!process?.env?.CI
+const isWindow = process?.platform?.startsWith("win")
 
 export default defineConfig({
 	workers: 1,
 	retries: 1,
 	testDir: "src/test/e2e",
-	timeout: 20000,
+	timeout: isCI || isWindow ? 40000 : 20000,
 	expect: {
-		timeout: 20000,
+		timeout: isCI || isWindow ? 5000 : 2000,
 	},
 	fullyParallel: true,
-	reporter: isGitHubAction ? [["github"], ["list"]] : [["list"]],
-	globalSetup: require.resolve("./src/test/e2e/utils/setup"),
-	globalTeardown: require.resolve("./src/test/e2e/utils/teardown"),
+	reporter: isCI ? [["github"], ["list"]] : [["list"]],
+	projects: [
+		{
+			name: "setup test environment",
+			testMatch: /global\.setup\.ts/,
+			teardown: "cleanup test environment",
+		},
+		{
+			name: "cleanup test environment",
+			testMatch: /global\.teardown\.ts/,
+		},
+		{
+			name: "e2e tests",
+			testMatch: /.*\.test\.ts/,
+			dependencies: ["setup test environment"],
+		},
+	],
 })

proto/cline/account.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -127,4 +127,4 @@ message OrganizationUsageTransaction {
   int32 prompt_tokens = 10;
   int32 total_tokens = 11;
   string user_id = 12;
-}
+}

proto/cline/browser.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/checkpoints.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/common.proto

@@ -55,6 +55,11 @@ message Boolean {
   bool value = 1;
 }
 
+// the same as Boolean, but avoiding name conflicts
+message BooleanResponse {
+  bool value = 1;
+}
+
 message StringArray {
   repeated string values = 1;
 }

proto/cline/file.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -55,8 +55,11 @@ service FileService {
   // Toggles a workflow on or off
   rpc toggleWorkflow(ToggleWorkflowRequest) returns (ClineRulesToggles);
 
-  // Subscribe to workspace file updates
-  rpc subscribeToWorkspaceUpdates(EmptyRequest) returns (stream StringArray);
+  // Check if file exists in the project
+  rpc ifFileExistsRelativePath(StringRequest) returns (BooleanResponse);
+
+  // Open a file in editor by a relative path
+  rpc openFileRelativePath(StringRequest) returns (Empty);
 }
 
 // Response for refreshRules operation
@@ -87,12 +90,19 @@ message RelativePaths {
   repeated string paths = 1;
 }
 
+// Enum for file search type filtering
+enum FileSearchType {
+  FILE = 0;
+  FOLDER = 1;
+}
+
 // Request for file search operations
 message FileSearchRequest {
   Metadata metadata = 1;
   string query = 2;                  // Search query string
   optional string mentions_request_id = 3;  // Optional request ID for tracking requests
   optional int32 limit = 4;          // Optional limit for results (default: 20)
+  optional FileSearchType selected_type = 5;  // Optional selected type filter
 }
 
 // Result for file search operations

proto/cline/mcp.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/models.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -27,6 +27,8 @@ service ModelsService {
   rpc updateApiConfigurationProto(UpdateApiConfigurationRequest) returns (Empty);
    // Refreshes and returns Groq models
   rpc refreshGroqModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns Baseten models
+  rpc refreshBasetenModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
 }
 
 // List of VS Code LM models
@@ -129,6 +131,8 @@ enum ApiProvider {
   CLAUDE_CODE = 26;
   MOONSHOT = 27;
   HUGGINGFACE = 28;
+  HUAWEI_CLOUD_MAAS = 29;
+  BASETEN = 30;
 }
 
 // Model info for OpenAI-compatible models
@@ -229,6 +233,9 @@ message ModelsApiConfiguration {
   optional string cline_account_id = 58;
   optional string groq_api_key = 59;
   optional string hugging_face_api_key = 60;
+  optional string huawei_cloud_maas_api_key = 61;
+  optional string baseten_api_key = 62;
+  optional string ollama_api_key = 63;
 
   // Plan mode configurations
   optional ApiProvider plan_mode_api_provider = 100;
@@ -255,6 +262,10 @@ message ModelsApiConfiguration {
   optional OpenRouterModelInfo plan_mode_groq_model_info = 121;
   optional string plan_mode_hugging_face_model_id = 122;
   optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 123;
+  optional string plan_mode_huawei_cloud_maas_model_id = 124;
+  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 125; 
+  optional string plan_mode_baseten_model_id = 126;
+  optional OpenRouterModelInfo plan_mode_baseten_model_info = 127;
 
   // Act mode configurations
   optional ApiProvider act_mode_api_provider = 200;
@@ -281,6 +292,10 @@ message ModelsApiConfiguration {
   optional OpenRouterModelInfo act_mode_groq_model_info = 221;
   optional string act_mode_hugging_face_model_id = 222;
   optional OpenRouterModelInfo act_mode_hugging_face_model_info = 223;
+  optional string act_mode_huawei_cloud_maas_model_id = 224;
+  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 225;
+  optional string act_mode_baseten_model_id = 226;
+  optional OpenRouterModelInfo act_mode_baseten_model_info = 227;
 
   repeated string favorited_model_ids = 300;
 }

proto/cline/slash.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/state.proto

@@ -1,19 +1,19 @@
 syntax = "proto3";
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
 service StateService {
   rpc getLatestState(EmptyRequest) returns (State);
-  rpc updateTerminalConnectionTimeout(Int64Request) returns (Int64);
+  rpc updateTerminalConnectionTimeout(UpdateTerminalConnectionTimeoutRequest) returns (UpdateTerminalConnectionTimeoutResponse);
   rpc updateTerminalReuseEnabled(BooleanRequest) returns (Empty);
   rpc updateDefaultTerminalProfile(StringRequest) returns (TerminalProfileUpdateResponse);
   rpc getAvailableTerminalProfiles(EmptyRequest) returns (TerminalProfiles);
   rpc subscribeToState(EmptyRequest) returns (stream State);
   rpc toggleFavoriteModel(StringRequest) returns (Empty);
   rpc resetState(ResetStateRequest) returns (Empty);
-  rpc togglePlanActMode(TogglePlanActModeRequest) returns (Boolean);
+  rpc togglePlanActModeProto(TogglePlanActModeRequest) returns (Boolean);
   rpc updateAutoApprovalSettings(AutoApprovalSettingsRequest) returns (Empty);
   rpc updateSettings(UpdateSettingsRequest) returns (Empty);
   rpc updateTelemetrySetting(TelemetrySettingRequest) returns (Empty);
@@ -43,7 +43,7 @@ message TerminalProfileUpdateResponse {
 
 message TogglePlanActModeRequest {
   Metadata metadata = 1;
-  ChatSettings chat_settings = 2;
+  PlanActMode mode = 2;
   optional ChatContent chat_content = 3;
 }
 
@@ -52,12 +52,6 @@ enum PlanActMode {
   ACT = 1;
 }
 
-message ChatSettings {
-  PlanActMode mode = 1;
-  optional string preferred_language = 2;
-  optional string open_ai_reasoning_effort = 3;
-}
-
 message ChatContent {
   optional string message = 1;
   repeated string images = 2;
@@ -108,12 +102,15 @@ message UpdateSettingsRequest {
   optional bool plan_act_separate_models_setting = 4;
   optional bool enable_checkpoints_setting = 5;
   optional bool mcp_marketplace_enabled = 6;
-  optional ChatSettings chat_settings = 7;
-  optional int64 shell_integration_timeout = 8;
+  optional int32 shell_integration_timeout = 8;
   optional bool terminal_reuse_enabled = 9;
   optional bool mcp_responses_collapsed = 10;
   optional string mcp_display_mode = 11;
-  optional int64 terminal_output_line_limit = 12;
+  optional int32 terminal_output_line_limit = 12;
+  optional PlanActMode mode = 13;
+  optional string preferred_language = 14;
+  optional string openai_reasoning_effort = 15;
+  optional bool strict_plan_mode_enabled = 16;
 }
 
 // Complete API Configuration message
@@ -153,8 +150,8 @@ message ApiConfiguration {
   optional string requesty_api_key = 32;
   optional string together_api_key = 33;
   optional string fireworks_api_key = 34;
-  optional int64 fireworks_model_max_completion_tokens = 35;
-  optional int64 fireworks_model_max_tokens = 36;
+  optional int32 fireworks_model_max_completion_tokens = 35;
+  optional int32 fireworks_model_max_tokens = 36;
   optional string qwen_api_key = 37;
   optional string doubao_api_key = 38;
   optional string mistral_api_key = 39;
@@ -166,7 +163,7 @@ message ApiConfiguration {
   optional string xai_api_key = 45;
   optional string sambanova_api_key = 46;
   optional string cerebras_api_key = 47;
-  optional int64 request_timeout_ms = 48;
+  optional int32 request_timeout_ms = 48;
   optional string sap_ai_core_client_id = 49;
   optional string sap_ai_core_client_secret = 50;
   optional string sap_ai_resource_group = 51;
@@ -174,11 +171,13 @@ message ApiConfiguration {
   optional string sap_ai_core_base_url = 53;
   optional string moonshot_api_key = 54;
   optional string moonshot_api_line = 55;
+  optional string huawei_cloud_maas_api_key = 56;
+  optional string ollama_api_key = 57;
   
   // Plan mode configurations
   optional string plan_mode_api_provider = 100;
   optional string plan_mode_api_model_id = 101;
-  optional int64 plan_mode_thinking_budget_tokens = 102;
+  optional int32 plan_mode_thinking_budget_tokens = 102;
   optional string plan_mode_reasoning_effort = 103;
   optional string plan_mode_vscode_lm_model_selector = 104; // JSON string
   optional bool plan_mode_aws_bedrock_custom_selected = 105;
@@ -196,11 +195,13 @@ message ApiConfiguration {
   optional string plan_mode_together_model_id = 117;
   optional string plan_mode_fireworks_model_id = 118;
   optional string plan_mode_sap_ai_core_model_id = 119;
+  optional string plan_mode_huawei_cloud_maas_model_id = 120;
+  optional string plan_mode_huawei_cloud_maas_model_info = 121;
   
   // Act mode configurations
   optional string act_mode_api_provider = 200;
   optional string act_mode_api_model_id = 201;
-  optional int64 act_mode_thinking_budget_tokens = 202;
+  optional int32 act_mode_thinking_budget_tokens = 202;
   optional string act_mode_reasoning_effort = 203;
   optional string act_mode_vscode_lm_model_selector = 204; // JSON string
   optional bool act_mode_aws_bedrock_custom_selected = 205;
@@ -218,6 +219,8 @@ message ApiConfiguration {
   optional string act_mode_together_model_id = 217;
   optional string act_mode_fireworks_model_id = 218;
   optional string act_mode_sap_ai_core_model_id = 219;
+  optional string act_mode_huawei_cloud_maas_model_id = 220;
+  optional string act_mode_huawei_cloud_maas_model_info = 221;
   
   // Favorited model IDs
   repeated string favorited_model_ids = 300;
@@ -228,3 +231,11 @@ message ApiConfiguration {
 
   optional string cline_account_id = 303;
 }
+
+message UpdateTerminalConnectionTimeoutRequest {
+  optional int32 timeout_ms = 1;
+}
+
+message UpdateTerminalConnectionTimeoutResponse {
+  optional int32 timeout_ms = 1;
+}

proto/cline/task.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/cline/ui.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
@@ -227,7 +227,7 @@ service UiService {
   rpc onDidShowAnnouncement(EmptyRequest) returns (Boolean);
   
   // Subscribe to addToInput events (when user adds content via context menu)
-  rpc subscribeToAddToInput(EmptyRequest) returns (stream String);
+  rpc subscribeToAddToInput(StringRequest) returns (stream String);
   
   // Subscribe to MCP button clicked events
   rpc subscribeToMcpButtonClicked(WebviewProviderTypeRequest) returns (stream Empty);
@@ -267,4 +267,7 @@ service UiService {
   
   // Opens a URL in the default browser
   rpc openUrl(StringRequest) returns (Empty);
+  
+  // Opens the Cline walkthrough
+  rpc openWalkthrough(EmptyRequest) returns (Empty);
 }

proto/cline/web.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
 package cline;
-import "common.proto";
+import "cline/common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 

proto/host/diff.proto

@@ -4,7 +4,7 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
-import "common.proto";
+import "cline/common.proto";
 
 // Provides methods for diff views.
 service DiffService {
@@ -14,6 +14,7 @@ service DiffService {
   rpc getDocumentText(GetDocumentTextRequest) returns (GetDocumentTextResponse);
   // Replace a text selection in the diff.
   rpc replaceText(ReplaceTextRequest) returns (ReplaceTextResponse);
+  rpc scrollDiff(ScrollDiffRequest) returns (ScrollDiffResponse);
   // Truncate the diff document.
   rpc truncateDocument(TruncateDocumentRequest) returns (TruncateDocumentResponse);
   // Save the diff document.
@@ -54,10 +55,17 @@ message ReplaceTextRequest {
 
 message ReplaceTextResponse {}
 
+message ScrollDiffRequest {
+  optional string diff_id = 1;
+  optional int32 line = 2;
+}
+
+message ScrollDiffResponse {}
+
 message TruncateDocumentRequest {
   optional cline.Metadata metadata = 1;
   optional string diff_id = 2;
-  optional int32 end_line = 5;
+  optional int32 end_line = 3;
 }
 
 message TruncateDocumentResponse {}

proto/host/env.proto

@@ -4,7 +4,7 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
-import "common.proto";
+import "cline/common.proto";
 
 // Provides methods for working with the user's environment.
 service EnvService {
@@ -13,7 +13,4 @@ service EnvService {
 
   // Reads text from the system clipboard.
   rpc clipboardReadText(cline.EmptyRequest) returns (cline.String);
-
-  // Opens a URL in the user's default browser or application.
-  rpc openExternal(cline.StringRequest) returns (cline.Empty);
 }

proto/host/testing.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+// This is for use in integration tests to get the contents of the webview.
+service TestingService {
+  rpc getWebviewHtml(GetWebviewHtmlRequest) returns (GetWebviewHtmlResponse);
+}
+
+message GetWebviewHtmlRequest {
+}
+
+message GetWebviewHtmlResponse {
+  optional string html = 1;
+}

proto/host/watch.proto

@@ -4,7 +4,7 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
-import "common.proto";
+import "cline/common.proto";
 
 /** 
  * The watch service is only here as example of a streaming rpc in the host bridge. 

proto/host/window.proto

@@ -4,7 +4,7 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
-import "common.proto";
+import "cline/common.proto";
 
 // Provides methods for working with IDE windows and editors.
 service WindowService {
@@ -12,6 +12,11 @@ service WindowService {
   rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
   rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
   rpc showMessage(ShowMessageRequest) returns (SelectedResponse);
+  rpc showInputBox(ShowInputBoxRequest) returns (ShowInputBoxResponse);
+  rpc showSaveDialog(ShowSaveDialogRequest) returns (ShowSaveDialogResponse);
+  rpc openFile(OpenFileRequest) returns (OpenFileResponse);
+  rpc getOpenTabs(GetOpenTabsRequest) returns (GetOpenTabsResponse);
+  rpc getVisibleTabs(GetVisibleTabsRequest) returns (GetVisibleTabsResponse);
 }
 
 message ShowTextDocumentRequest {
@@ -70,4 +75,61 @@ message ShowMessageRequestOptions {
 
 message SelectedResponse {
   optional string selected_option = 1;
-}
+}
+
+message ShowSaveDialogRequest {
+  cline.Metadata metadata = 1;
+  optional ShowSaveDialogOptions options = 2;
+}
+
+message ShowSaveDialogOptions {
+  optional string default_path = 1;
+  // A map of file types to extensions, e.g
+  // "Text Files": { "extensions": ["txt", "md"] }
+  map<string, FileExtensionList> filters = 2;
+}
+
+message FileExtensionList {
+  repeated string extensions = 1;
+}
+
+message ShowSaveDialogResponse {
+  // If the user cancelled the dialog, this will be empty.
+  optional string selected_path = 1;
+}
+
+message ShowInputBoxRequest {
+  cline.Metadata metadata = 1;
+  string title = 2;
+  optional string prompt = 3;
+  optional string value = 4;
+}
+
+message ShowInputBoxResponse {
+  optional string response = 1;
+}
+
+message OpenFileRequest {
+  cline.Metadata metadata = 1;
+  string file_path = 2;
+}
+
+message OpenFileResponse {
+  // empty
+}
+
+message GetOpenTabsRequest {
+  // empty
+}
+
+message GetOpenTabsResponse {
+  repeated string paths = 1;
+}
+
+message GetVisibleTabsRequest {
+  // empty
+}
+
+message GetVisibleTabsResponse {
+  repeated string paths = 1;
+}

proto/host/workspace.proto

@@ -4,10 +4,18 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
+import "cline/common.proto";
+
 // Provides methods for working with workspaces/projects.
 service WorkspaceService {
   // Returns a list of the top level directories of the workspace.
   rpc getWorkspacePaths(GetWorkspacePathsRequest) returns (GetWorkspacePathsResponse);
+  // Saves an open document if it's open in the editor and has unsaved changes. 
+  // Returns true if the document was saved, returns false if the document was not found, or did not
+  // need to be saved.
+  rpc saveOpenDocumentIfDirty(SaveOpenDocumentIfDirtyRequest) returns (SaveOpenDocumentIfDirtyResponse);
+  // Get diagnostics from the workspace.
+  rpc getDiagnostics(GetDiagnosticsRequest) returns (GetDiagnosticsResponse);
 }
 
 message GetWorkspacePathsRequest {
@@ -22,3 +30,48 @@ message GetWorkspacePathsResponse {
   optional string id = 1;
   repeated string paths = 2;
 }
+
+message SaveOpenDocumentIfDirtyRequest {
+  optional string file_path = 2;
+}
+message SaveOpenDocumentIfDirtyResponse {
+  // Returns true if the document was saved. 
+  optional bool was_saved = 1;
+}
+
+message GetDiagnosticsRequest {
+  optional cline.Metadata metadata = 1;
+}
+
+message GetDiagnosticsResponse {
+  repeated FileDiagnostics file_diagnostics = 1;
+}
+
+message FileDiagnostics {
+  string file_path = 1;
+  repeated Diagnostic diagnostics = 2;
+}
+
+message Diagnostic {
+  string message = 1;
+  DiagnosticRange range = 2;
+  DiagnosticSeverity severity = 3;
+  optional string source = 4;
+}
+
+message DiagnosticRange {
+  DiagnosticPosition start = 1;
+  DiagnosticPosition end = 2;
+}
+
+message DiagnosticPosition {
+  int32 line = 1;
+  int32 character = 2;
+}
+
+enum DiagnosticSeverity {
+  DIAGNOSTIC_ERROR = 0;
+  DIAGNOSTIC_WARNING = 1;
+  DIAGNOSTIC_INFORMATION = 2;
+  DIAGNOSTIC_HINT = 3;
+}

scripts/build-proto-config.mjs

@@ -1,32 +0,0 @@
-// Configuration file for protocol buffer build scripts
-// Contains service name mappings used by both build-proto.js and build-go-proto.js
-
-// List of gRPC services
-// To add a new service, simply add it to this map and run the build scripts
-// The service handler will be automatically discovered and used by grpc-handler.ts
-export const serviceNameMap = {
-	account: "cline.AccountService",
-	browser: "cline.BrowserService",
-	checkpoints: "cline.CheckpointsService",
-	file: "cline.FileService",
-	mcp: "cline.McpService",
-	state: "cline.StateService",
-	task: "cline.TaskService",
-	web: "cline.WebService",
-	models: "cline.ModelsService",
-	slash: "cline.SlashService",
-	ui: "cline.UiService",
-	// Add new services here - no other code changes needed!
-}
-
-// List of host gRPC services (IDE API bridge)
-// These services are implemented in the IDE extension and called by the standalone Cline Core
-export const hostServiceNameMap = {
-	uri: "host.UriService",
-	watch: "host.WatchService",
-	workspace: "host.WorkspaceService",
-	env: "host.EnvService",
-	window: "host.WindowService",
-	diff: "host.DiffService",
-	// Add new host services here
-}

scripts/build-proto.mjs

@@ -1,21 +1,20 @@
 #!/usr/bin/env node
 
-import * as fs from "fs/promises"
-import * as path from "path"
-import { fileURLToPath } from "url"
-import { execSync } from "child_process"
-import { globby } from "globby"
 import chalk from "chalk"
-import os from "os"
-
+import { execSync } from "child_process"
+import * as fs from "fs/promises"
+import { globby } from "globby"
 import { createRequire } from "module"
-import { serviceNameMap } from "./build-proto-config.mjs"
+import os from "os"
+import * as path from "path"
+import { rmrf } from "./file-utils.mjs"
+import { main as generateProtoBusSetup } from "./generate-protobus-setup.mjs"
+import { main as generateHostBridgeClient } from "./generate-host-bridge-client.mjs"
+import { loadProtoDescriptorSet } from "./proto-utils.mjs"
 
 const require = createRequire(import.meta.url)
 const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 
-const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
-
 const PROTO_DIR = path.resolve("proto")
 const TS_OUT_DIR = path.resolve("src/shared/proto")
 const GRPC_JS_OUT_DIR = path.resolve("src/generated/grpc-js")
@@ -36,13 +35,15 @@ const TS_PROTO_OPTIONS = [
 	"useDate=false", // Timestamp fields will not be automatically converted to Date.
 ]
 
-// Service directories derived from imported serviceNameMap
-const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join("src/core/controller", serviceKey))
-
 async function main() {
-	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))
-
 	await cleanup()
+	await compileProtos()
+	await checkProtos()
+	await generateProtoBusSetup()
+	await generateHostBridgeClient()
+}
+async function compileProtos() {
+	console.log(chalk.bold.blue("Compiling Protocol Buffers..."))
 
 	// Check for Apple Silicon compatibility before proceeding
 	checkAppleSiliconCompatibility()
@@ -52,9 +53,6 @@ async function main() {
 		await fs.mkdir(dir, { recursive: true })
 	}
 
-	// Check for missing proto files for services in serviceNameMap
-	await ensureProtoFilesExist()
-
 	// Process all proto files
 	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR, realpath: true })
 	console.log(chalk.cyan(`Processing ${protoFiles.length} proto files from`), PROTO_DIR)
@@ -83,11 +81,6 @@ async function main() {
 
 	log_verbose(chalk.green("Protocol Buffer code generation completed successfully."))
 	log_verbose(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))
-
-	await generateProtoBusServiceConfig()
-	await generateProtoBusMethodRegistrations()
-
-	console.log(chalk.bold.blue("Finished Protocol Buffer code generation."))
 }
 
 async function tsProtoc(outDir, protoFiles, protoOptions) {
@@ -110,267 +103,6 @@ async function tsProtoc(outDir, protoFiles, protoOptions) {
 	}
 }
 
-/**
- * Parse proto files to extract streaming method information
- * @param protoFiles Array of proto file names
- * @param scriptDir Directory containing proto files
- * @returns Map of service names to their streaming methods
- */
-async function parseProtoForStreamingMethods(protoFiles, scriptDir) {
-	log_verbose(chalk.cyan("Parsing proto files for streaming methods..."))
-
-	// Map of service name to array of streaming method names
-	const streamingMethodsMap = new Map()
-
-	for (const protoFile of protoFiles) {
-		const content = await fs.readFile(path.join(scriptDir, protoFile), "utf8")
-
-		// Extract package name
-		const packageMatch = content.match(/package\s+([^;]+);/)
-		const packageName = packageMatch ? packageMatch[1].trim() : "unknown"
-
-		// Extract service definitions
-		const serviceMatches = Array.from(content.matchAll(/service\s+(\w+)\s*\{([^}]+)\}/g))
-		for (const serviceMatch of serviceMatches) {
-			const serviceName = serviceMatch[1]
-			const serviceBody = serviceMatch[2]
-			const fullServiceName = `${packageName}.${serviceName}`
-
-			// Extract method definitions with streaming
-			const methodMatches = Array.from(
-				serviceBody.matchAll(/rpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s*returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g),
-			)
-
-			const streamingMethods = []
-			for (const methodMatch of methodMatches) {
-				const methodName = methodMatch[1]
-				const isRequestStreaming = !!methodMatch[2]
-				const requestType = methodMatch[3]
-				const isResponseStreaming = !!methodMatch[4]
-				const responseType = methodMatch[5]
-
-				if (isResponseStreaming) {
-					streamingMethods.push({
-						name: methodName,
-						requestType,
-						responseType,
-						isRequestStreaming,
-					})
-				}
-			}
-
-			if (streamingMethods.length > 0) {
-				streamingMethodsMap.set(fullServiceName, streamingMethods)
-			}
-		}
-	}
-
-	return streamingMethodsMap
-}
-
-async function generateProtoBusMethodRegistrations() {
-	log_verbose(chalk.cyan("Generating method registration files..."))
-
-	// Parse proto files for streaming methods
-	const protoFiles = await globby("*.proto", { cwd: PROTO_DIR })
-	const streamingMethodsMap = await parseProtoForStreamingMethods(protoFiles, PROTO_DIR)
-
-	for (const serviceDir of serviceDirs) {
-		const serviceName = path.basename(serviceDir)
-		const fullServiceName = serviceNameMap[serviceName]
-		const streamingMethods = streamingMethodsMap.get(fullServiceName) || []
-
-		log_verbose(chalk.cyan(`Generating method registrations for ${serviceName}...`))
-
-		// Get all TypeScript files in the service directory
-		const files = await globby("*.ts", { cwd: serviceDir })
-
-		// Filter out index.ts and methods.ts
-		const implementationFiles = files.filter((file) => file !== "index.ts" && file !== "methods.ts")
-
-		// Create the methods.ts file with header
-		let methodsContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-// Import all method implementations
-import { registerMethod } from "./index"\n`
-
-		// Import implementations directly
-		for (const file of implementationFiles) {
-			const baseName = path.basename(file, ".ts")
-			methodsContent += `import { ${baseName} } from "./${baseName}"\n`
-		}
-
-		// Add streaming methods information
-		if (streamingMethods.length > 0) {
-			methodsContent += `\n// Streaming methods for this service
-export const streamingMethods = ${JSON.stringify(
-				streamingMethods.map((m) => m.name),
-				null,
-				2,
-			)}\n`
-		}
-
-		// Add registration function
-		methodsContent += `\n// Register all ${serviceName} service methods
-export function registerAllMethods(): void {
-\t// Register each method with the registry\n`
-
-		// Add registration statements
-		for (const file of implementationFiles) {
-			const baseName = path.basename(file, ".ts")
-			const isStreaming = streamingMethods.some((m) => m.name === baseName)
-
-			if (isStreaming) {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName}, { isStreaming: true })\n`
-			} else {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName})\n`
-			}
-		}
-
-		// Close the function
-		methodsContent += `}`
-
-		// Write the methods.ts file
-		const registryFile = path.join(serviceDir, "methods.ts")
-		await writeFileWithMkdirs(registryFile, methodsContent)
-		log_verbose(chalk.green(`Generated ${registryFile}`))
-
-		// Generate index.ts file
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1)
-		const indexContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
-import { registerAllMethods } from "./methods"
-
-// Create ${serviceName} service registry
-const ${serviceName}Service = createServiceRegistry("${serviceName}")
-
-// Export the method handler types and registration function
-export type ${capitalizedServiceName}MethodHandler = ServiceMethodHandler
-export type ${capitalizedServiceName}StreamingMethodHandler = StreamingMethodHandler
-export const registerMethod = ${serviceName}Service.registerMethod
-
-// Export the request handlers
-export const handle${capitalizedServiceName}ServiceRequest = ${serviceName}Service.handleRequest
-export const handle${capitalizedServiceName}ServiceStreamingRequest = ${serviceName}Service.handleStreamingRequest
-export const isStreamingMethod = ${serviceName}Service.isStreamingMethod
-
-// Register all ${serviceName} methods
-registerAllMethods()`
-
-		// Write the index.ts file
-		const indexFile = path.join(serviceDir, "index.ts")
-		await writeFileWithMkdirs(indexFile, indexContent)
-		log_verbose(chalk.green(`Generated ${indexFile}`))
-	}
-
-	log_verbose(chalk.green("Method registration files generated successfully."))
-}
-
-/**
- * Generate a service configuration file that maps service names to their handlers
- * This eliminates the need for manual switch/case statements in grpc-handler.ts
- */
-async function generateProtoBusServiceConfig() {
-	log_verbose(chalk.cyan("Generating service configuration file..."))
-
-	const serviceImports = []
-	const serviceConfigs = []
-
-	// Add all services from the serviceNameMap
-	for (const [dirName, fullServiceName] of Object.entries(serviceNameMap)) {
-		const capitalizedName = dirName.charAt(0).toUpperCase() + dirName.slice(1)
-		serviceImports.push(
-			`import { handle${capitalizedName}ServiceRequest, handle${capitalizedName}ServiceStreamingRequest } from "./${dirName}/index"`,
-		)
-		serviceConfigs.push(`
-  "${fullServiceName}": {
-    requestHandler: handle${capitalizedName}ServiceRequest,
-    streamingHandler: handle${capitalizedName}ServiceStreamingRequest
-  }`)
-	}
-
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-import { Controller } from "./index"
-import { StreamingResponseHandler } from "./grpc-handler"
-${serviceImports.join("\n")}
-
-/**
- * Configuration for a service handler
- */
-export interface ServiceHandlerConfig {
-  requestHandler: (controller: Controller, method: string, message: any) => Promise<any>;
-  streamingHandler: (controller: Controller, method: string, message: any, responseStream: StreamingResponseHandler, requestId?: string) => Promise<void>;
-}
-
-/**
- * Map of service names to their handler configurations
- */
-export const serviceHandlers: Record<string, ServiceHandlerConfig> = {${serviceConfigs.join(",")}
-};`
-
-	const configPath = path.resolve("src/core/controller/grpc-service-config.ts")
-	await writeFileWithMkdirs(configPath, content)
-	log_verbose(chalk.green(`Generated service configuration at ${configPath}`))
-}
-
-/**
- * Ensure that a .proto file exists for each service in the serviceNameMap
- * If a .proto file doesn't exist, create a template file
- */
-async function ensureProtoFilesExist() {
-	log_verbose(chalk.cyan("Checking for missing proto files..."))
-
-	// Get existing proto files
-	const existingProtoFiles = await globby("*.proto", { cwd: PROTO_DIR })
-	const existingProtoServices = existingProtoFiles.map((file) => path.basename(file, ".proto"))
-
-	// Check each service in serviceNameMap
-	for (const [serviceName, fullServiceName] of Object.entries(serviceNameMap)) {
-		if (!existingProtoServices.includes(serviceName)) {
-			log_verbose(chalk.yellow(`Creating template proto file for ${serviceName}...`))
-
-			// Extract service class name from full name (e.g., "cline.ModelsService" -> "ModelsService")
-			const serviceClassName = fullServiceName.split(".").pop()
-
-			// Create template proto file
-			const protoContent = `syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// ${serviceClassName} provides methods for managing ${serviceName}
-service ${serviceClassName} {
-  // Add your RPC methods here
-  // Example (String is from common.proto, responses should be generic types):
-  // rpc YourMethod(YourRequest) returns (String);
-}
-
-// Add your message definitions here
-// Example (Requests must always start with Metadata):
-// message YourRequest {
-//   Metadata metadata = 1;
-//   string stringField = 2;
-//   int32 int32Field = 3;
-// }
-`
-
-			// Write the template proto file
-			const protoFilePath = path.join(PROTO_DIR, `${serviceName}.proto`)
-			await fs.writeFile(protoFilePath, protoContent)
-			log_verbose(chalk.green(`Created template proto file at ${protoFilePath}`))
-		}
-	}
-}
-
 async function cleanup() {
 	// Clean up existing generated files
 	log_verbose(chalk.cyan("Cleaning up existing generated TypeScript files..."))
@@ -381,6 +113,7 @@ async function cleanup() {
 	await rmrf("src/standalone/services/host-grpc-client.ts")
 	await rmrf("src/standalone/server-setup.ts")
 	await rmrf("src/hosts/vscode/host-grpc-service-config.ts")
+	await rmrf("src/core/controller/grpc-service-config.ts")
 	const oldhostbridgefiles = [
 		"src/hosts/vscode/workspace/methods.ts",
 		"src/hosts/vscode/workspace/index.ts",
@@ -395,37 +128,35 @@ async function cleanup() {
 		"src/hosts/vscode/uri/methods.ts",
 		"src/hosts/vscode/uri/index.ts",
 	]
-	for (const file of oldhostbridgefiles) {
+	const oldprotobusfiles = [
+		"src/core/controller/account/index.ts",
+		"src/core/controller/account/methods.ts",
+		"src/core/controller/browser/index.ts",
+		"src/core/controller/browser/methods.ts",
+		"src/core/controller/checkpoints/index.ts",
+		"src/core/controller/checkpoints/methods.ts",
+		"src/core/controller/file/index.ts",
+		"src/core/controller/file/methods.ts",
+		"src/core/controller/mcp/index.ts",
+		"src/core/controller/mcp/methods.ts",
+		"src/core/controller/models/index.ts",
+		"src/core/controller/models/methods.ts",
+		"src/core/controller/slash/index.ts",
+		"src/core/controller/slash/methods.ts",
+		"src/core/controller/state/index.ts",
+		"src/core/controller/state/methods.ts",
+		"src/core/controller/task/index.ts",
+		"src/core/controller/task/methods.ts",
+		"src/core/controller/ui/index.ts",
+		"src/core/controller/ui/methods.ts",
+		"src/core/controller/web/index.ts",
+		"src/core/controller/web/methods.ts",
+	]
+	for (const file of [...oldhostbridgefiles, ...oldprotobusfiles]) {
 		await rmrf(file)
 	}
 }
 
-/**
- * Write `contents` to `filePath`, creating any necessary directories in `filePath`.
- */
-async function writeFileWithMkdirs(filePath, content) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true })
-	await fs.writeFile(filePath, content)
-}
-
-/**
- * Remove an empty dir, do nothing if the directory doesn't exist or is not empty.
- */
-async function rmdir(path) {
-	try {
-		await fs.rmdir(path)
-	} catch (error) {
-		if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT") {
-			// Only re-throw if it's not "not empty" or "doesn't exist"
-			throw error
-		}
-	}
-}
-
-async function rmrf(path) {
-	await fs.rm(path, { force: true, recursive: true })
-}
-
 // Check for Apple Silicon compatibility
 function checkAppleSiliconCompatibility() {
 	// Only run check on macOS
@@ -456,6 +187,51 @@ function checkAppleSiliconCompatibility() {
 	}
 }
 
+const int64TypeNames = ["TYPE_INT64", "TYPE_UINT64", "TYPE_SINT64", "TYPE_FIXED64", "TYPE_SFIXED64"]
+
+async function checkProtos() {
+	const proto = await loadProtoDescriptorSet()
+	const int64Fields = []
+
+	for (const [packageName, packageDef] of Object.entries(proto)) {
+		for (const [messageName, def] of Object.entries(packageDef)) {
+			// Skip service definitions
+			if (def && typeof def === "object" && "service" in def) {
+				continue
+			}
+			// Check message fields
+			if (def && def.type && def.type.field) {
+				for (const field of def.type.field) {
+					if (int64TypeNames.includes(field.type)) {
+						const name = `${packageName}.${messageName}.${field.name}`
+						int64Fields.push({
+							name: name,
+							type: field.type,
+						})
+					}
+				}
+			}
+		}
+	}
+
+	if (int64Fields.length > 0) {
+		console.log(chalk.yellow(`\nWarning: Found ${int64Fields.length} fields using 64-bit integer types`))
+		for (const field of int64Fields) {
+			const typeNames = {
+				TYPE_INT64: "int64",
+				TYPE_UINT64: "uint64",
+				TYPE_SINT64: "sint64",
+				TYPE_FIXED64: "fixed64",
+				TYPE_SFIXED64: "sfixed64",
+			}
+			log_verbose(chalk.yellow(`  - ${field.name} (${typeNames[field.type]})`))
+		}
+		log_verbose(chalk.yellow("\nWARNING: 64-bit integer fields detected in proto definitions"))
+		log_verbose(chalk.yellow("JavaScript cannot safely represent integers larger than 2^53-1 (Number.MAX_SAFE_INTEGER)."))
+		log_verbose(chalk.yellow("Consider using string representation for large numbers or implementing BigInt support.\n"))
+	}
+}
+
 function log_verbose(s) {
 	if (process.argv.includes("-v") || process.argv.includes("--verbose")) {
 		console.log(s)

scripts/build-tests.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 const { execSync } = require("child_process")
 const esbuild = require("esbuild")
 

scripts/file-utils.mjs

@@ -0,0 +1,27 @@
+import * as fs from "fs/promises"
+import * as path from "path"
+/**
+ * Write `contents` to `filePath`, creating any necessary directories in `filePath`.
+ */
+export async function writeFileWithMkdirs(filePath, content) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true })
+	await fs.writeFile(filePath, content)
+}
+
+export async function rmrf(path) {
+	await fs.rm(path, { force: true, recursive: true })
+}
+
+/**
+ * Remove an empty dir, do nothing if the directory doesn't exist or is not empty.
+ */
+export async function rmdir(path) {
+	try {
+		await fs.rmdir(path)
+	} catch (error) {
+		if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT") {
+			// Only re-throw if it's not "not empty" or "doesn't exist"
+			throw error
+		}
+	}
+}

scripts/generate-host-bridge-client.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import * as fs from "fs/promises"
+import { writeFileWithMkdirs } from "./file-utils.mjs"
 import * as path from "path"
 import chalk from "chalk"
 import { loadServicesFromProtoDescriptor, getFqn } from "./proto-utils.mjs"
@@ -15,14 +15,14 @@ const VSCODE_CLIENT_FILE = path.resolve("src/generated/hosts/vscode/hostbridge-g
 /**
  * Main function to generate the host bridge client
  */
-async function main() {
+export async function main() {
 	const { hostServices } = await loadServicesFromProtoDescriptor()
 
 	await generateTypesFile(hostServices)
 	await generateExternalClientFile(hostServices)
 	await generateVscodeClientFile(hostServices)
 
-	console.log(`Generated host bridge client files at:`)
+	console.log(`Generated Host Bridge client files at:`)
 	console.log(`- ${TYPES_FILE}`)
 	console.log(`- ${EXTERNAL_CLIENT_FILE}`)
 	console.log(`- ${VSCODE_CLIENT_FILE}`)
@@ -45,8 +45,7 @@ import { StreamingCallbacks } from "@hosts/host-provider-types"
 ${clientInterfaces.join("\n\n")}
 `
 	// Write output file
-	await fs.mkdir(path.dirname(TYPES_FILE), { recursive: true })
-	await fs.writeFile(TYPES_FILE, content)
+	await writeFileWithMkdirs(TYPES_FILE, content)
 }
 
 /**
@@ -107,8 +106,7 @@ ${imports.join("\n")}
 ${clientImplementations.join("\n\n")}
 `
 	// Write output file
-	await fs.mkdir(path.dirname(EXTERNAL_CLIENT_FILE), { recursive: true })
-	await fs.writeFile(EXTERNAL_CLIENT_FILE, content)
+	await writeFileWithMkdirs(EXTERNAL_CLIENT_FILE, content)
 }
 
 /**
@@ -211,8 +209,7 @@ ${handlerMap.join("\n")}
 `
 
 	// Write output file
-	await fs.mkdir(path.dirname(VSCODE_CLIENT_FILE), { recursive: true })
-	await fs.writeFile(VSCODE_CLIENT_FILE, content)
+	await writeFileWithMkdirs(VSCODE_CLIENT_FILE, content)
 }
 
 function generateVscodeClientImplementation(serviceName, serviceDefinition) {
@@ -237,8 +234,10 @@ const ${name}ServiceRegistry = createServiceRegistry("${name}")
 ${methods}`
 }
 
-// Run the main function
-main().catch((error) => {
-	console.error(chalk.red("Error:"), error)
-	process.exit(1)
-})
+// Only run main if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((error) => {
+		console.error(chalk.red("Error:"), error)
+		process.exit(1)
+	})
+}

scripts/generate-protobus-setup.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import { writeFileWithMkdirs } from "./file-utils.mjs"
+import path from "path"
+import { fileURLToPath } from "url"
+import { loadServicesFromProtoDescriptor, getFqn } from "./proto-utils.mjs"
+
+const WEBVIEW_CLIENTS_FILE = path.resolve("webview-ui/src/services/grpc-client.ts")
+const VSCODE_SERVICES_FILE = path.resolve("src/generated/hosts/vscode/protobus-services.ts")
+const VSCODE_SERVICE_TYPES_FILE = path.resolve("src/generated/hosts/vscode/protobus-service-types.ts")
+const STANDALONE_SERVER_SETUP_FILE = path.resolve("src/generated/hosts/standalone/protobus-server-setup.ts")
+
+const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
+
+export async function main() {
+	const { protobusServices } = await loadServicesFromProtoDescriptor()
+	await generateWebviewProtobusClients(protobusServices)
+	await generateVscodeServiceTypes(protobusServices)
+	await generateVscodeProtobusServers(protobusServices)
+	await generateStandaloneProtobusServiceSetup(protobusServices)
+
+	console.log(`Generated ProtoBus files at:`)
+	console.log(`- ${WEBVIEW_CLIENTS_FILE}`)
+	console.log(`- ${VSCODE_SERVICE_TYPES_FILE}`)
+	console.log(`- ${VSCODE_SERVICES_FILE}`)
+	console.log(`- ${STANDALONE_SERVER_SETUP_FILE}`)
+}
+
+async function generateWebviewProtobusClients(protobusServices) {
+	const clients = []
+
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const rpcs = []
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			const requestType = getFqn(rpc.requestType.type.name)
+			const responseType = getFqn(rpc.responseType.type.name)
+
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (!rpc.responseStream) {
+				rpcs.push(`    static async ${rpcName}(request: ${requestType}): Promise<${responseType}> {
+		return this.makeUnaryRequest("${rpcName}", request, ${requestType}.toJSON, ${responseType}.fromJSON)
+	}`)
+			} else {
+				rpcs.push(`    static ${rpcName}(request: ${requestType}, callbacks: Callbacks<${responseType}>): ()=>void {
+		return this.makeStreamingRequest("${rpcName}", request, ${requestType}.toJSON, ${responseType}.fromJSON, callbacks)
+	}`)
+			}
+		}
+		clients.push(`export class ${serviceName}Client extends ProtoBusClient {
+	static override serviceName: string = "cline.${serviceName}"
+${rpcs.join("\n")}
+}`)
+	}
+
+	// Create output file
+	let output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as proto from "@shared/proto/index"
+import { ProtoBusClient, Callbacks } from "./grpc-client-base"
+
+${clients.join("\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(WEBVIEW_CLIENTS_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateVscodeServiceTypes(protobusServices) {
+	const servers = []
+
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(serviceName)
+		servers.push(`// ${domain} Service Handler Types`)
+		servers.push(`export type ${serviceName}Handlers = {`)
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			const requestType = getFqn(rpc.requestType.type.name)
+			const responseType = getFqn(rpc.responseType.type.name)
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (!rpc.responseStream) {
+				servers.push(`     ${rpcName}:(controller: Controller, request: ${requestType}) => Promise<${responseType}>`)
+			} else {
+				servers.push(
+					`     ${rpcName}:(controller: Controller, request: ${requestType}, responseStream: StreamingResponseHandler<${responseType}>, requestId?: string) => Promise<void>`,
+				)
+			}
+		}
+		servers.push(`}\n`)
+	}
+
+	// Create output file
+	let output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as proto from "@shared/proto/index"
+import { Controller } from "@core/controller"
+import { StreamingResponseHandler } from "@/core/controller/grpc-handler"
+
+${servers.join("\n")}
+`
+	// Write output file
+	await writeFileWithMkdirs(VSCODE_SERVICE_TYPES_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateVscodeProtobusServers(protobusServices) {
+	const imports = []
+	const servers = []
+	const serviceMap = []
+	for (const [serviceName, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(serviceName)
+		const dir = getDirName(serviceName)
+		imports.push(`// ${domain} Service`)
+		servers.push(`const ${serviceName}Handlers: serviceTypes.${serviceName}Handlers = {`)
+		for (const [rpcName, _rpc] of Object.entries(def.service)) {
+			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
+			servers.push(`    ${rpcName}: ${rpcName},`)
+		}
+		servers.push(`} \n`)
+		serviceMap.push(`    "cline.${serviceName}": ${serviceName}Handlers,`)
+		imports.push("")
+	}
+
+	// Create output file
+	let output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as serviceTypes from "src/generated/hosts/vscode/protobus-service-types"
+
+${imports.join("\n")}
+${servers.join("\n")}
+export const serviceHandlers: Record<string, any> = {
+${serviceMap.join("\n")}
+}
+`
+	// Write output file
+	await writeFileWithMkdirs(VSCODE_SERVICES_FILE, output)
+}
+
+/**
+ * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
+ */
+async function generateStandaloneProtobusServiceSetup(protobusServices) {
+	const imports = []
+	const handlerSetup = []
+
+	for (const [name, def] of Object.entries(protobusServices)) {
+		const domain = getDomainName(name)
+		const dir = getDirName(name)
+		imports.push(`// ${domain} Service`)
+		handlerSetup.push(`    // ${domain} Service`)
+		handlerSetup.push(`    server.addService(cline.${name}Service, {`)
+		for (const [rpcName, rpc] of Object.entries(def.service)) {
+			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
+			const requestType = "cline." + rpc.requestType.type.name
+			const responseType = "cline." + rpc.responseType.type.name
+			if (rpc.requestStream) {
+				throw new Error("Request streaming is not supported")
+			}
+			if (rpc.responseStream) {
+				handlerSetup.push(
+					`        ${rpcName}: wrapStreamingResponse<${requestType},${responseType}>(${rpcName}, controller),`,
+				)
+			} else {
+				handlerSetup.push(`         ${rpcName}: wrapper<${requestType},${responseType}>(${rpcName}, controller),`)
+			}
+		}
+		handlerSetup.push(`    });`)
+		imports.push("")
+		handlerSetup.push("")
+	}
+
+	// Create output file
+	let output = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by ${SCRIPT_NAME}
+import * as grpc from "@grpc/grpc-js"
+import { cline } from "@generated/grpc-js"
+import { Controller } from "@core/controller"
+import { GrpcHandlerWrapper, GrpcStreamingResponseHandlerWrapper } from "@hosts/external/grpc-types"
+
+${imports.join("\n")}
+export function addProtobusServices(
+	server: grpc.Server,
+	controller: Controller,
+	wrapper: GrpcHandlerWrapper,
+	wrapStreamingResponse: GrpcStreamingResponseHandlerWrapper,
+): void {
+${handlerSetup.join("\n")}
+}
+`
+	// Write output file
+	await writeFileWithMkdirs(STANDALONE_SERVER_SETUP_FILE, output)
+}
+
+function getDomainName(serviceName) {
+	return serviceName.replace(/Service$/, "")
+}
+function getDirName(serviceName) {
+	const domain = getDomainName(serviceName)
+	return domain.charAt(0).toLowerCase() + domain.slice(1)
+}
+
+// Only run main if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((error) => {
+		console.error(chalk.red("Error:"), error)
+		process.exit(1)
+	})
+}

scripts/generate-server-setup.mjs

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-
-import * as fs from "fs"
-import path, { dirname } from "path"
-import { fileURLToPath } from "url"
-import { loadServicesFromProtoDescriptor, getFqn } from "./proto-utils.mjs"
-
-const STANDALONE_SERVER_SETUP_FILE = path.resolve("src/generated/standalone/server-setup.ts")
-const WEBVIEW_CLIENTS_FILE = path.resolve("webview-ui/src/services/grpc-client.ts")
-
-const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
-
-async function main() {
-	const { protobusServices } = await loadServicesFromProtoDescriptor()
-	await generateWebviewProtobusClients(protobusServices)
-	await generateStandaloneProtobusServiceSetup(protobusServices)
-
-	console.log(`Generated ProtoBus files at:`)
-	console.log(`- ${WEBVIEW_CLIENTS_FILE}`)
-	console.log(`- ${STANDALONE_SERVER_SETUP_FILE}`)
-}
-
-async function generateWebviewProtobusClients(protobusServices) {
-	const clients = []
-
-	for (const [serviceName, def] of Object.entries(protobusServices)) {
-		const rpcs = []
-		for (const [rpcName, rpc] of Object.entries(def.service)) {
-			const requestType = getFqn(rpc.requestType.type.name)
-			const responseType = getFqn(rpc.responseType.type.name)
-
-			if (rpc.requestStream) {
-				throw new Error("Request streaming is not supported")
-			}
-			if (!rpc.responseStream) {
-				rpcs.push(`    static async ${rpcName}(request: ${requestType}): Promise<${responseType}> {
-		return this.makeRequest("${rpcName}", request, ${requestType}.toJSON, ${responseType}.fromJSON)
-	}`)
-			} else {
-				rpcs.push(`    static ${rpcName}(request: ${requestType}, callbacks: Callbacks<${responseType}>): ()=>void {
-		return this.makeStreamingRequest("${rpcName}", request, callbacks, ${requestType}.toJSON, ${responseType}.fromJSON)
-	}`)
-			}
-		}
-		clients.push(`export class ${serviceName}Client extends ProtoBusClient {
-	static override serviceName: string = "${serviceName}"
-${rpcs.join("\n")}
-}`)
-	}
-
-	// Create output file
-	let output = `// GENERATED CODE -- DO NOT EDIT!
-// Generated by ${SCRIPT_NAME}
-import * as proto from "@shared/proto/index"
-import { ProtoBusClient, Callbacks } from "./grpc-client-base"
-
-${clients.join("\n")}
-`
-	// Write output file
-	fs.mkdirSync(dirname(WEBVIEW_CLIENTS_FILE), { recursive: true })
-	fs.writeFileSync(WEBVIEW_CLIENTS_FILE, output)
-}
-
-/**
- * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
- */
-async function generateStandaloneProtobusServiceSetup(protobusServices) {
-	const imports = []
-	const handlerSetup = []
-
-	for (const [name, def] of Object.entries(protobusServices)) {
-		const domain = name.replace(/Service$/, "")
-		const dir = domain.charAt(0).toLowerCase() + domain.slice(1)
-		imports.push(`// ${domain} Service`)
-		handlerSetup.push(`    // ${domain} Service`)
-		handlerSetup.push(`    server.addService(cline.${name}Service, {`)
-		for (const [rpcName, rpc] of Object.entries(def.service)) {
-			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
-			const requestType = "cline." + rpc.requestType.type.name
-			if (rpc.requestStream) {
-				throw new Error("Request streaming is not supported")
-			}
-			if (rpc.responseStream) {
-				handlerSetup.push(`        ${rpcName}: wrapStreamingResponse<${requestType},void>(${rpcName}, controller),`)
-			} else {
-				const responseType = "cline." + rpc.responseType.type.name
-				handlerSetup.push(`         ${rpcName}: wrapper<${requestType},${responseType}>(${rpcName}, controller),`)
-			}
-		}
-		handlerSetup.push(`    });`)
-		imports.push("")
-		handlerSetup.push("")
-	}
-
-	// Create output file
-	let output = `// GENERATED CODE -- DO NOT EDIT!
-// Generated by ${SCRIPT_NAME}
-import * as grpc from "@grpc/grpc-js"
-import { cline } from "@generated/grpc-js"
-import { Controller } from "@core/controller"
-import { GrpcHandlerWrapper, GrpcStreamingResponseHandlerWrapper } from "@hosts/external/grpc-types"
-
-${imports.join("\n")}
-export function addProtobusServices(
-	server: grpc.Server,
-	controller: Controller,
-	wrapper: GrpcHandlerWrapper,
-	wrapStreamingResponse: GrpcStreamingResponseHandlerWrapper,
-): void {
-${handlerSetup.join("\n")}
-}
-`
-	// Write output file
-	fs.mkdirSync(dirname(STANDALONE_SERVER_SETUP_FILE), { recursive: true })
-	fs.writeFileSync(STANDALONE_SERVER_SETUP_FILE, output)
-}
-
-main()

scripts/proto-utils.mjs

@@ -10,7 +10,7 @@ const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
 const typeNameToFQN = new Map()
 
 function addTypeNameToFqn(name, fqn) {
-	if (typeNameToFQN.has(name)) {
+	if (typeNameToFQN.has(name) && typeNameToFQN.get(name) !== fqn) {
 		throw new Error(`Proto type ${name} redefined (${fqn}).`)
 	}
 	typeNameToFQN.set(name, fqn)
@@ -23,11 +23,15 @@ export function getFqn(name) {
 	return typeNameToFQN.get(name)
 }
 
-export async function loadServicesFromProtoDescriptor() {
-	// Load service definitions from descriptor set
+export async function loadProtoDescriptorSet() {
 	const descriptorBuffer = await fs.readFile(DESCRIPTOR_SET)
 	const packageDefinition = protoLoader.loadFileDescriptorSetFromBuffer(descriptorBuffer)
-	const proto = grpc.loadPackageDefinition(packageDefinition)
+	return grpc.loadPackageDefinition(packageDefinition)
+}
+
+export async function loadServicesFromProtoDescriptor() {
+	// Load service definitions from descriptor set
+	const proto = await loadProtoDescriptorSet()
 
 	// Extract host services and proto messages from the proto definition
 	const hostServices = {}

src/api/index.ts

@@ -1,5 +1,5 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import { ApiConfiguration, ModelInfo } from "../shared/api"
+import { ApiConfiguration, ModelInfo, QwenApiRegions } from "../shared/api"
 import { AnthropicHandler } from "./providers/anthropic"
 import { AwsBedrockHandler } from "./providers/bedrock"
 import { OpenRouterHandler } from "./providers/openrouter"
@@ -29,8 +29,10 @@ import { SapAiCoreHandler } from "./providers/sapaicore"
 import { ClaudeCodeHandler } from "./providers/claude-code"
 import { MoonshotHandler } from "./providers/moonshot"
 import { GroqHandler } from "./providers/groq"
-import { Mode } from "../shared/ChatSettings"
+import { Mode } from "@shared/storage/types"
 import { HuggingFaceHandler } from "./providers/huggingface"
+import { HuaweiCloudMaaSHandler } from "./providers/huawei-cloud-maas"
+import { BasetenHandler } from "./providers/baseten"
 
 export interface ApiHandler {
 	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
@@ -111,6 +113,7 @@ function createHandlerForProvider(
 		case "ollama":
 			return new OllamaHandler({
 				ollamaBaseUrl: options.ollamaBaseUrl,
+				ollamaApiKey: options.ollamaApiKey,
 				ollamaModelId: mode === "plan" ? options.planModeOllamaModelId : options.actModeOllamaModelId,
 				ollamaApiOptionsCtxNum: options.ollamaApiOptionsCtxNum,
 				requestTimeoutMs: options.requestTimeoutMs,
@@ -166,7 +169,8 @@ function createHandlerForProvider(
 		case "qwen":
 			return new QwenHandler({
 				qwenApiKey: options.qwenApiKey,
-				qwenApiLine: options.qwenApiLine,
+				qwenApiLine:
+					options.qwenApiLine === QwenApiRegions.INTERNATIONAL ? QwenApiRegions.INTERNATIONAL : QwenApiRegions.CHINA,
 				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 				thinkingBudgetTokens:
 					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
@@ -255,6 +259,13 @@ function createHandlerForProvider(
 				groqModelInfo: mode === "plan" ? options.planModeGroqModelInfo : options.actModeGroqModelInfo,
 				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
+		case "baseten":
+			return new BasetenHandler({
+				basetenApiKey: options.basetenApiKey,
+				basetenModelId: mode === "plan" ? options.planModeBasetenModelId : options.actModeBasetenModelId,
+				basetenModelInfo: mode === "plan" ? options.planModeBasetenModelInfo : options.actModeBasetenModelInfo,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
 		case "sapaicore":
 			return new SapAiCoreHandler({
 				sapAiCoreClientId: options.sapAiCoreClientId,
@@ -263,6 +274,8 @@ function createHandlerForProvider(
 				sapAiResourceGroup: options.sapAiResourceGroup,
 				sapAiCoreBaseUrl: options.sapAiCoreBaseUrl,
 				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "claude-code":
 			return new ClaudeCodeHandler({
@@ -271,6 +284,14 @@ function createHandlerForProvider(
 				thinkingBudgetTokens:
 					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
+		case "huawei-cloud-maas":
+			return new HuaweiCloudMaaSHandler({
+				huaweiCloudMaasApiKey: options.huaweiCloudMaasApiKey,
+				huaweiCloudMaasModelId:
+					mode === "plan" ? options.planModeHuaweiCloudMaasModelId : options.actModeHuaweiCloudMaasModelId,
+				huaweiCloudMaasModelInfo:
+					mode === "plan" ? options.planModeHuaweiCloudMaasModelInfo : options.actModeHuaweiCloudMaasModelInfo,
+			})
 		default:
 			return new AnthropicHandler({
 				apiKey: options.apiKey,

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

@@ -612,101 +612,102 @@ describe("AwsBedrockHandler", () => {
 		})
 	})
 
-	describe("getModelId", () => {
-		it("should return raw model ID for custom models", async () => {
-			const customOptions: ApiHandlerOptions = {
-				...mockOptions,
-				actModeAwsBedrockCustomSelected: true,
-				actModeApiModelId:
-					"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
-			}
-			const customHandler = new AwsBedrockHandler(customOptions)
+	// TODO: Re-enable or remove these tests.
+	// describe("getModelId", () => {
+	// 	it("should return raw model ID for custom models", async () => {
+	// 		const customOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			actModeAwsBedrockCustomSelected: true,
+	// 			actModeApiModelId:
+	// 				"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
+	// 		}
+	// 		const customHandler = new AwsBedrockHandler(customOptions)
 
-			const modelId = await customHandler.getModelId()
-			modelId.should.equal(
-				"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
-			)
-		})
+	// 		const modelId = await customHandler.getModelId()
+	// 		modelId.should.equal(
+	// 			"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
+	// 		)
+	// 	})
 
-		it("should not encode custom model IDs with slashes", async () => {
-			const customOptions: ApiHandlerOptions = {
-				...mockOptions,
-				actModeAwsBedrockCustomSelected: true,
-				actModeApiModelId: "my-namespace/my-custom-model",
-			}
-			const customHandler = new AwsBedrockHandler(customOptions)
+	// 	it("should not encode custom model IDs with slashes", async () => {
+	// 		const customOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			actModeAwsBedrockCustomSelected: true,
+	// 			actModeApiModelId: "my-namespace/my-custom-model",
+	// 		}
+	// 		const customHandler = new AwsBedrockHandler(customOptions)
 
-			const modelId = await customHandler.getModelId()
-			modelId.should.equal("my-namespace/my-custom-model")
-			modelId.should.not.match(/%2F/)
-		})
+	// 		const modelId = await customHandler.getModelId()
+	// 		modelId.should.equal("my-namespace/my-custom-model")
+	// 		modelId.should.not.match(/%2F/)
+	// 	})
 
-		it("should apply cross-region prefix for non-custom models when enabled", async () => {
-			const crossRegionOptions: ApiHandlerOptions = {
-				...mockOptions,
-				awsUseCrossRegionInference: true,
-				awsRegion: "us-west-2",
-			}
-			const crossRegionHandler = new AwsBedrockHandler(crossRegionOptions)
+	// 	it("should apply cross-region prefix for non-custom models when enabled", async () => {
+	// 		const crossRegionOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			awsUseCrossRegionInference: true,
+	// 			awsRegion: "us-west-2",
+	// 		}
+	// 		const crossRegionHandler = new AwsBedrockHandler(crossRegionOptions)
 
-			const modelId = await crossRegionHandler.getModelId()
-			modelId.should.equal("us.anthropic.claude-3-7-sonnet-20250219-v1:0")
-		})
+	// 		const modelId = await crossRegionHandler.getModelId()
+	// 		modelId.should.equal("us.anthropic.claude-3-7-sonnet-20250219-v1:0")
+	// 	})
 
-		it("should apply EU cross-region prefix", async () => {
-			const euOptions: ApiHandlerOptions = {
-				...mockOptions,
-				awsUseCrossRegionInference: true,
-				awsRegion: "eu-central-1",
-			}
-			const euHandler = new AwsBedrockHandler(euOptions)
+	// 	it("should apply EU cross-region prefix", async () => {
+	// 		const euOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			awsUseCrossRegionInference: true,
+	// 			awsRegion: "eu-central-1",
+	// 		}
+	// 		const euHandler = new AwsBedrockHandler(euOptions)
 
-			const modelId = await euHandler.getModelId()
-			modelId.should.equal("eu.anthropic.claude-3-7-sonnet-20250219-v1:0")
-		})
+	// 		const modelId = await euHandler.getModelId()
+	// 		modelId.should.equal("eu.anthropic.claude-3-7-sonnet-20250219-v1:0")
+	// 	})
 
-		it("should apply APAC cross-region prefix", async () => {
-			const apacOptions: ApiHandlerOptions = {
-				...mockOptions,
-				awsUseCrossRegionInference: true,
-				awsRegion: "ap-northeast-1",
-			}
-			const apacHandler = new AwsBedrockHandler(apacOptions)
+	// 	it("should apply APAC cross-region prefix", async () => {
+	// 		const apacOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			awsUseCrossRegionInference: true,
+	// 			awsRegion: "ap-northeast-1",
+	// 		}
+	// 		const apacHandler = new AwsBedrockHandler(apacOptions)
 
-			const modelId = await apacHandler.getModelId()
-			modelId.should.equal("apac.anthropic.claude-3-7-sonnet-20250219-v1:0")
-		})
+	// 		const modelId = await apacHandler.getModelId()
+	// 		modelId.should.equal("apac.anthropic.claude-3-7-sonnet-20250219-v1:0")
+	// 	})
 
-		it("should not apply cross-region prefix for custom models even when enabled", async () => {
-			const customCrossRegionOptions: ApiHandlerOptions = {
-				...mockOptions,
-				actModeAwsBedrockCustomSelected: true,
-				actModeApiModelId: "arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model",
-				awsUseCrossRegionInference: true,
-			}
-			const customCrossRegionHandler = new AwsBedrockHandler(customCrossRegionOptions)
+	// 	it("should not apply cross-region prefix for custom models even when enabled", async () => {
+	// 		const customCrossRegionOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			actModeAwsBedrockCustomSelected: true,
+	// 			actModeApiModelId: "arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model",
+	// 			awsUseCrossRegionInference: true,
+	// 		}
+	// 		const customCrossRegionHandler = new AwsBedrockHandler(customCrossRegionOptions)
 
-			const modelId = await customCrossRegionHandler.getModelId()
-			modelId.should.equal("arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model")
-		})
+	// 		const modelId = await customCrossRegionHandler.getModelId()
+	// 		modelId.should.equal("arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model")
+	// 	})
 
-		it("should handle UltraThink model ARN correctly", async () => {
-			const ultraThinkOptions: ApiHandlerOptions = {
-				...mockOptions,
-				actModeAwsBedrockCustomSelected: true,
-				actModeApiModelId:
-					"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
-				actModeAwsBedrockCustomModelBaseId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
-			}
-			const ultraThinkHandler = new AwsBedrockHandler(ultraThinkOptions)
+	// 	it("should handle UltraThink model ARN correctly", async () => {
+	// 		const ultraThinkOptions: ApiHandlerOptions = {
+	// 			...mockOptions,
+	// 			actModeAwsBedrockCustomSelected: true,
+	// 			actModeApiModelId:
+	// 				"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
+	// 			actModeAwsBedrockCustomModelBaseId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+	// 		}
+	// 		const ultraThinkHandler = new AwsBedrockHandler(ultraThinkOptions)
 
-			const modelId = await ultraThinkHandler.getModelId()
-			// Should return the raw ARN without any encoding
-			modelId.should.equal(
-				"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
-			)
-			modelId.should.not.match(/%2F/)
-			modelId.should.not.match(/%3A/)
-		})
-	})
+	// 		const modelId = await ultraThinkHandler.getModelId()
+	// 		// Should return the raw ARN without any encoding
+	// 		modelId.should.equal(
+	// 			"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
+	// 		)
+	// 		modelId.should.not.match(/%2F/)
+	// 		modelId.should.not.match(/%3A/)
+	// 	})
+	// })
 })

src/api/providers/anthropic.ts

@@ -55,6 +55,7 @@ export class AnthropicHandler implements ApiHandler {
 			case "claude-3-5-sonnet-20241022":
 			case "claude-3-5-haiku-20241022":
 			case "claude-opus-4-20250514":
+			case "claude-opus-4-1-20250805":
 			case "claude-3-opus-20240229":
 			case "claude-3-haiku-20240307": {
 				/*
@@ -122,6 +123,7 @@ export class AnthropicHandler implements ApiHandler {
 						switch (modelId) {
 							case "claude-sonnet-4-20250514":
 							case "claude-opus-4-20250514":
+							case "claude-opus-4-1-20250805":
 							case "claude-3-7-sonnet-20250219":
 							case "claude-3-5-sonnet-20241022":
 							case "claude-3-5-haiku-20241022":

src/api/providers/baseten.ts

@@ -0,0 +1,165 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { withRetry } from "../retry"
+import { ApiHandler } from "../"
+import { BasetenModelId, ModelInfo, basetenDefaultModelId, basetenModels } from "@shared/api"
+import { calculateApiCostOpenAI } from "../../utils/cost"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+
+interface BasetenHandlerOptions {
+	basetenApiKey?: string
+	basetenModelId?: string
+	basetenModelInfo?: ModelInfo
+	apiModelId?: string // For backward compatibility
+}
+
+export class BasetenHandler implements ApiHandler {
+	private options: BasetenHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: BasetenHandlerOptions) {
+		this.options = options
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.basetenApiKey) {
+				throw new Error("Baseten API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://inference.baseten.co/v1",
+					apiKey: this.options.basetenApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Baseten client: ${error.message}`)
+			}
+		}
+		return this.client
+	}
+
+	/**
+	 * Gets the optimal max_tokens based on model capabilities
+	 */
+	private getOptimalMaxTokens(model: { id: BasetenModelId; info: ModelInfo }): number {
+		// Use model-specific max tokens if available
+		if (model.info.maxTokens && model.info.maxTokens > 0) {
+			return model.info.maxTokens
+		}
+
+		// Default fallback
+		return 8192
+	}
+
+	getModel(): { id: BasetenModelId; info: ModelInfo } {
+		// First priority: basetenModelId and basetenModelInfo
+		const basetenModelId = this.options.basetenModelId
+		const basetenModelInfo = this.options.basetenModelInfo
+		if (basetenModelId && basetenModelInfo) {
+			return { id: basetenModelId as BasetenModelId, info: basetenModelInfo }
+		}
+
+		// Second priority: basetenModelId with static model info
+		if (basetenModelId && basetenModelId in basetenModels) {
+			const id = basetenModelId as BasetenModelId
+			return { id, info: basetenModels[id] }
+		}
+
+		// Third priority: apiModelId (for backward compatibility)
+		const apiModelId = this.options.apiModelId
+		if (apiModelId && apiModelId in basetenModels) {
+			const id = apiModelId as BasetenModelId
+			return { id, info: basetenModels[id] }
+		}
+
+		// Default fallback
+		return {
+			id: basetenDefaultModelId,
+			info: basetenModels[basetenDefaultModelId],
+		}
+	}
+
+	private async *yieldUsage(modelInfo: ModelInfo, usage: any): ApiStream {
+		if (usage.prompt_tokens || usage.completion_tokens) {
+			const cost = calculateApiCostOpenAI(modelInfo, usage.prompt_tokens || 0, usage.completion_tokens || 0)
+
+			yield {
+				type: "usage",
+				inputTokens: usage.prompt_tokens || 0,
+				outputTokens: usage.completion_tokens || 0,
+				cacheWriteTokens: 0,
+				cacheReadTokens: 0,
+				totalCost: cost,
+			}
+		}
+	}
+
+	@withRetry()
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+		const model = this.getModel()
+		const maxTokens = this.getOptimalMaxTokens(model)
+
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+
+		const stream = await client.chat.completions.create({
+			model: model.id,
+			max_tokens: maxTokens,
+			messages: openAiMessages,
+			stream: true,
+			stream_options: { include_usage: true },
+			temperature: 0,
+		})
+
+		let didOutputUsage = false
+
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+
+			// Handle reasoning field if present (for reasoning models with parsed output)
+			if ((delta as any)?.reasoning) {
+				const reasoningContent = (delta as any).reasoning as string
+				yield {
+					type: "reasoning",
+					reasoning: reasoningContent,
+				}
+				continue
+			}
+
+			// Handle content field
+			if (delta?.content) {
+				yield {
+					type: "text",
+					text: delta.content,
+				}
+			}
+
+			// Handle usage information - only output once
+			if (!didOutputUsage && chunk.usage) {
+				yield* this.yieldUsage(model.info, chunk.usage)
+				didOutputUsage = true
+			}
+		}
+	}
+
+	/**
+	 * Checks if the current model supports vision/images
+	 */
+	supportsImages(): boolean {
+		const model = this.getModel()
+		return model.info.supportsImages === true
+	}
+
+	/**
+	 * Checks if the current model supports tools
+	 */
+	supportsTools(): boolean {
+		const model = this.getModel()
+		// Baseten models support tools via OpenAI-compatible API
+		return true
+	}
+}

src/api/providers/cerebras.ts

@@ -39,7 +39,11 @@ export class CerebrasHandler implements ApiHandler {
 		return this.client
 	}
 
-	@withRetry()
+	@withRetry({
+		maxRetries: 6, // More retries to be patient with rate limits
+		baseDelay: 5000, // Start with 5 second delay
+		maxDelay: 60000, // Allow up to 60 second delays to respect rate limits
+	})
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
 		const client = this.ensureClient()
 
@@ -102,6 +106,7 @@ export class CerebrasHandler implements ApiHandler {
 				messages: cerebrasMessages,
 				temperature: 0,
 				stream: true,
+				max_tokens: this.getModel().info.maxTokens,
 			})
 
 			// Handle streaming response
@@ -169,15 +174,39 @@ export class CerebrasHandler implements ApiHandler {
 					}
 				}
 			}
-		} catch (error) {
+		} catch (error: any) {
+			// Enhanced error handling for Cerebras API
+			if (error?.status === 429 || error?.code === "rate_limit_exceeded") {
+				// Rate limit error - will be handled by retry decorator with patient backoff
+				const limits = this.getRateLimits()
+				throw new Error(`Cerebras API rate limit exceeded.`)
+			} else if (error?.status === 401) {
+				throw new Error("Cerebras API authentication failed. Please check your API key.")
+			} else if (error?.status === 403) {
+				throw new Error("Cerebras API access denied. Please check your API key permissions.")
+			} else if (error?.status >= 500) {
+				// Server errors - retryable
+				throw new Error(`Cerebras API server error (${error.status}): ${error.message || "Unknown server error"}`)
+			} else if (error?.status === 400) {
+				// Client errors - not retryable
+				throw new Error(`Cerebras API bad request: ${error.message || "Invalid request parameters"}`)
+			}
+
+			// Re-throw original error for other cases
 			throw error
 		}
 	}
 
 	getModel(): { id: string; info: ModelInfo } {
-		const modelId = this.options.apiModelId
-		if (modelId && modelId in cerebrasModels) {
-			const id = modelId as CerebrasModelId
+		const originalModelId = this.options.apiModelId
+		let apiModelId = originalModelId
+		if (originalModelId === "qwen-3-coder-480b-free") {
+			apiModelId = "qwen-3-coder-480b"
+			return { id: apiModelId, info: cerebrasModels[originalModelId as CerebrasModelId] }
+		}
+
+		if (originalModelId && originalModelId in cerebrasModels) {
+			const id = originalModelId as CerebrasModelId
 			return { id, info: cerebrasModels[id] }
 		}
 		return {
@@ -186,6 +215,35 @@ export class CerebrasHandler implements ApiHandler {
 		}
 	}
 
+	/**
+	 * Get rate limit information for the current model
+	 *
+	 * These limits are used for informational purposes and to calculate appropriate
+	 * retry delays. Since Cerebras inference is extremely fast, users hit these limits
+	 * quickly, so we need to be patient with retries to maximize usage efficiency.
+	 *
+	 * @returns Rate limit configuration for the model
+	 */
+	private getRateLimits(): { requestsPerMinute: number; tokensPerMinute: number } {
+		const modelId = this.getModel().id
+
+		switch (modelId) {
+			case "qwen-3-coder-480b":
+			case "qwen-3-coder-480b-free":
+				return { requestsPerMinute: 10, tokensPerMinute: 150_000 }
+			case "qwen-3-235b-a22b-instruct-2507":
+			case "qwen-3-235b-a22b-thinking-2507":
+				return { requestsPerMinute: 30, tokensPerMinute: 60_000 }
+			case "llama-3.3-70b":
+			case "gpt-oss-120b":
+			case "qwen-3-32b":
+				return { requestsPerMinute: 30, tokensPerMinute: 64_000 }
+			default:
+				// Default rate limits for unknown models
+				return { requestsPerMinute: 30, tokensPerMinute: 60_000 }
+		}
+	}
+
 	private calculateCost({ inputTokens, outputTokens }: { inputTokens: number; outputTokens: number }): number {
 		const model = this.getModel()
 		const inputPrice = model.info.inputPrice || 0

src/api/providers/cline.ts

@@ -24,6 +24,14 @@ interface ClineHandlerOptions {
 	clineAccountId?: string
 }
 
+interface ClineStreamUsageChunk extends OpenAI.CompletionUsage {
+	cost?: number
+	cost_details?: {
+		upstream_inference_cost?: number
+		downstream_inference_cost?: number
+	}
+}
+
 export class ClineHandler implements ApiHandler {
 	private options: ClineHandlerOptions
 	private clineAccountService = ClineAccountService.getInstance()
@@ -31,7 +39,6 @@ export class ClineHandler implements ApiHandler {
 	private client: OpenAI | undefined
 	private readonly _baseUrl = clineEnvConfig.apiBaseUrl
 	lastGenerationId?: string
-	private counter = 0
 
 	constructor(options: ClineHandlerOptions) {
 		this.options = options
@@ -55,8 +62,9 @@ export class ClineHandler implements ApiHandler {
 						"X-Cline-Version": extensionVersion,
 					},
 				})
-			} catch (error: any) {
-				throw new Error(`Error creating Cline client: ${error.message}`)
+			} catch (error) {
+				console.error(`Error creating Cline client: ${error.message}`)
+				throw error
 			}
 		}
 		// Ensure the client is always using the latest auth token
@@ -87,10 +95,10 @@ export class ClineHandler implements ApiHandler {
 				// openrouter returns an error object instead of the openai sdk throwing an error
 				if ("error" in chunk) {
 					const error = chunk.error as OpenRouterErrorResponse["error"]
-					console.error(`Cline API Error: ${error?.code} - ${error?.message}`)
 					// Include metadata in the error message if available
 					const metadataStr = error.metadata ? `\nMetadata: ${JSON.stringify(error.metadata, null, 2)}` : ""
-					throw new Error(`Cline API Error ${error.code}: ${error.message}${metadataStr}`)
+					console.error(`Cline API Error ${error.code}: ${error.message}${metadataStr}`)
+					throw error
 				}
 				if (!this.lastGenerationId && chunk.id) {
 					this.lastGenerationId = chunk.id
@@ -99,12 +107,9 @@ export class ClineHandler implements ApiHandler {
 				// Check for mid-stream error via finish_reason
 				const choice = chunk.choices?.[0]
 				// OpenRouter may return finish_reason = "error" with error details
-				if ((choice?.finish_reason as string) === "error") {
-					const choiceWithError = choice as any
-					if (choiceWithError.error) {
-						const error = choiceWithError.error
-						console.error(`Cline Mid-Stream Error: ${error.code || error.type || "Unknown"} - ${error.message}`)
-						throw new Error(`Cline Mid-Stream Error: ${error.code || error.type || "Unknown"} - ${error.message}`)
+				if (choice?.finish_reason && String(choice?.finish_reason) === "error") {
+					if ("error" in choice && choice?.error) {
+						throw choice.error
 					} else {
 						throw new Error(
 							"Cline Mid-Stream Error: Stream terminated with error status but no error details provided",
@@ -130,38 +135,15 @@ export class ClineHandler implements ApiHandler {
 					}
 				}
 
-				if (!didOutputUsage && chunk.usage) {
-					// @ts-ignore-next-line
-					let totalCost = (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0)
-					const modelId = this.getModel().id
-
-					// const provider = modelId.split("/")[0]
-					// // If provider is x-ai, set totalCost to 0 (we're doing a promo)
-					// if (provider === "x-ai") {
-					// 	totalCost = 0
-					// }
-
-					if (modelId.includes("gemini")) {
-						yield {
-							type: "usage",
-							cacheWriteTokens: 0,
-							cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-							inputTokens:
-								(chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
-							outputTokens: chunk.usage.completion_tokens || 0,
-							// @ts-ignore-next-line
-							totalCost,
-						}
-					} else {
-						yield {
-							type: "usage",
-							cacheWriteTokens: 0,
-							cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-							inputTokens: chunk.usage.prompt_tokens || 0,
-							outputTokens: chunk.usage.completion_tokens || 0,
-							// @ts-ignore-next-line
-							totalCost,
-						}
+				const streamUsage = chunk.usage as ClineStreamUsageChunk | undefined
+				if (!didOutputUsage && streamUsage) {
+					yield {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: streamUsage.prompt_tokens_details?.cached_tokens || 0,
+						inputTokens: (streamUsage.prompt_tokens || 0) - (streamUsage.prompt_tokens_details?.cached_tokens || 0),
+						outputTokens: streamUsage.completion_tokens || 0,
+						totalCost: (streamUsage.cost || 0) + (streamUsage.cost_details?.upstream_inference_cost || 0),
 					}
 					didOutputUsage = true
 				}
@@ -195,27 +177,14 @@ export class ClineHandler implements ApiHandler {
 				})
 
 				const generation = response.data
-				let modelId = this.options.openRouterModelId
-				if (modelId && modelId.includes("gemini")) {
-					return {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: generation?.native_tokens_cached || 0,
-						// openrouter generation endpoint fails often
-						inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
-						outputTokens: generation?.native_tokens_completion || 0,
-						totalCost: generation?.total_cost || 0,
-					}
-				} else {
-					return {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: generation?.native_tokens_cached || 0,
-						// openrouter generation endpoint fails often
-						inputTokens: generation?.native_tokens_prompt || 0,
-						outputTokens: generation?.native_tokens_completion || 0,
-						totalCost: generation?.total_cost || 0,
-					}
+				return {
+					type: "usage",
+					cacheWriteTokens: 0,
+					cacheReadTokens: generation?.native_tokens_cached || 0,
+					// openrouter generation endpoint fails often
+					inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
+					outputTokens: generation?.native_tokens_completion || 0,
+					totalCost: generation?.total_cost || 0,
 				}
 			} catch (error) {
 				// ignore if fails
@@ -226,7 +195,7 @@ export class ClineHandler implements ApiHandler {
 	}
 
 	getModel(): { id: string; info: ModelInfo } {
-		let modelId = this.options.openRouterModelId
+		const modelId = this.options.openRouterModelId
 		const modelInfo = this.options.openRouterModelInfo
 		if (modelId && modelInfo) {
 			return { id: modelId, info: modelInfo }

src/api/providers/gemini-mock.test.ts

@@ -0,0 +1,53 @@
+// Mock for @google/genai module to avoid ESM compatibility issues in tests
+
+export class GoogleGenAI {
+	constructor(options: any) {
+		// Mock constructor
+	}
+
+	models = {
+		generateContentStream: async (params: any) => {
+			// Mock implementation that returns an async iterator
+			return {
+				async *[Symbol.asyncIterator]() {
+					yield {
+						text: "Mock response",
+						candidates: [],
+						usageMetadata: {
+							promptTokenCount: 100,
+							candidatesTokenCount: 50,
+							thoughtsTokenCount: 0,
+							cachedContentTokenCount: 0,
+						},
+					}
+				},
+			}
+		},
+		countTokens: async (params: any) => {
+			// Mock token counting
+			return {
+				totalTokens: 100,
+			}
+		},
+	}
+}
+
+// Export mock types
+export interface GenerateContentConfig {
+	httpOptions?: any
+	systemInstruction?: string
+	temperature?: number
+	thinkingConfig?: any
+}
+
+export interface GenerateContentResponseUsageMetadata {
+	promptTokenCount?: number
+	candidatesTokenCount?: number
+	thoughtsTokenCount?: number
+	cachedContentTokenCount?: number
+}
+
+export interface Part {
+	thought?: boolean
+	text?: string
+}

src/api/providers/gemini.ts

@@ -7,7 +7,7 @@ import { ApiHandler } from "../"
 import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "@shared/api"
 import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
 import { ApiStream } from "../transform/stream"
-import { telemetryService } from "@services/posthog/telemetry/TelemetryService"
+import { telemetryService } from "@services/posthog/PostHogClientProvider"
 
 // Define a default TTL for the cache (e.g., 15 minutes in seconds)
 const DEFAULT_CACHE_TTL_SECONDS = 900

src/api/providers/huawei-cloud-maas.ts

@@ -0,0 +1,132 @@
+import { ApiHandler } from ".."
+import { huaweiCloudMaasDefaultModelId, HuaweiCloudMaasModelId, huaweiCloudMaasModels, ModelInfo } from "@shared/api"
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+import { withRetry } from "../retry"
+
+interface HuaweiCloudMaaSHandlerOptions {
+	huaweiCloudMaasApiKey?: string
+	huaweiCloudMaasModelId?: string
+	huaweiCloudMaasModelInfo?: ModelInfo
+}
+
+export class HuaweiCloudMaaSHandler implements ApiHandler {
+	private options: HuaweiCloudMaaSHandlerOptions
+	private client: OpenAI | undefined
+	constructor(options: HuaweiCloudMaaSHandlerOptions) {
+		this.options = options
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.huaweiCloudMaasApiKey) {
+				throw new Error("Huawei Cloud MaaS API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.modelarts-maas.com/v1/",
+					apiKey: this.options.huaweiCloudMaasApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Huawei Cloud MaaS client: ${error.message}`)
+			}
+		}
+		return this.client
+	}
+
+	getModel(): { id: HuaweiCloudMaasModelId; info: ModelInfo } {
+		// First priority: huaweiCloudMaasModelId and huaweiCloudMaasModelInfo (like Groq does)
+		const huaweiCloudMaasModelId = this.options.huaweiCloudMaasModelId
+		const huaweiCloudMaasModelInfo = this.options.huaweiCloudMaasModelInfo
+		if (huaweiCloudMaasModelId && huaweiCloudMaasModelInfo) {
+			return { id: huaweiCloudMaasModelId as HuaweiCloudMaasModelId, info: huaweiCloudMaasModelInfo }
+		}
+
+		// Second priority: huaweiCloudMaasModelId with static model info
+		if (huaweiCloudMaasModelId && huaweiCloudMaasModelId in huaweiCloudMaasModels) {
+			const id = huaweiCloudMaasModelId as HuaweiCloudMaasModelId
+			return { id, info: huaweiCloudMaasModels[id] }
+		}
+
+		// Default fallback
+		return {
+			id: huaweiCloudMaasDefaultModelId,
+			info: huaweiCloudMaasModels[huaweiCloudMaasDefaultModelId],
+		}
+	}
+
+	@withRetry()
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+		const model = this.getModel()
+		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+		const stream = await client.chat.completions.create({
+			model: model.id,
+			max_completion_tokens: model.info.maxTokens,
+			messages: openAiMessages,
+			stream: true,
+			stream_options: { include_usage: true },
+			temperature: 0,
+		})
+
+		let reasoning: string | null = null
+		let didOutputUsage: boolean = false
+		let finalUsage: any = null
+
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+
+			// Handle reasoning content detection
+			if (delta?.content) {
+				if (reasoning || delta.content.includes("<think>")) {
+					reasoning = (reasoning || "") + delta.content
+				} else if (!reasoning) {
+					yield {
+						type: "text",
+						text: delta.content,
+					}
+				}
+			}
+
+			// Handle reasoning output
+			if (reasoning || (delta && "reasoning_content" in delta && delta.reasoning_content)) {
+				const reasoningContent = delta?.content || ((delta as any)?.reasoning_content as string | undefined) || ""
+				if (reasoningContent.trim()) {
+					yield {
+						type: "reasoning",
+						reasoning: reasoningContent,
+					}
+				}
+
+				// Check if reasoning is complete
+				if (reasoning?.includes("</think>")) {
+					reasoning = null
+				}
+			}
+
+			// Store usage information for later output
+			if (chunk.usage) {
+				finalUsage = chunk.usage
+			}
+
+			// Output usage when stream is finished
+			if (!didOutputUsage && chunk.choices?.[0]?.finish_reason) {
+				if (finalUsage) {
+					yield {
+						type: "usage",
+						inputTokens: finalUsage.prompt_tokens || 0,
+						outputTokens: finalUsage.completion_tokens || 0,
+						cacheWriteTokens: 0,
+						cacheReadTokens: 0,
+					}
+				}
+				didOutputUsage = true
+			}
+		}
+	}
+}

src/api/providers/litellm.ts

@@ -16,9 +16,29 @@ interface LiteLlmHandlerOptions {
 	taskId?: string
 }
 
+interface LiteLlmModelInfoResponse {
+	data: Array<{
+		model_name: string
+		litellm_params: {
+			model: string
+			[key: string]: any
+		}
+		model_info: {
+			input_cost_per_token: number
+			output_cost_per_token: number
+			cache_creation_input_token_cost?: number
+			cache_read_input_token_cost?: number
+			[key: string]: any
+		}
+	}>
+}
+
 export class LiteLlmHandler implements ApiHandler {
 	private options: LiteLlmHandlerOptions
 	private client: OpenAI | undefined
+	private modelInfoCache: LiteLlmModelInfoResponse | undefined
+	private modelInfoCacheTimestamp: number = 0
+	private readonly modelInfoCacheTTL = 5 * 60 * 1000 // 5 minutes
 
 	constructor(options: LiteLlmHandlerOptions) {
 		this.options = options
@@ -41,35 +61,112 @@ export class LiteLlmHandler implements ApiHandler {
 		return this.client
 	}
 
-	async calculateCost(prompt_tokens: number, completion_tokens: number): Promise<number | undefined> {
-		// Reference: https://github.com/BerriAI/litellm/blob/122ee634f434014267af104814022af1d9a0882f/litellm/proxy/spend_tracking/spend_management_endpoints.py#L1473
+	private async fetchModelInfo(): Promise<LiteLlmModelInfoResponse | undefined> {
+		// Check if cache is still valid
+		const now = Date.now()
+		if (this.modelInfoCache && now - this.modelInfoCacheTimestamp < this.modelInfoCacheTTL) {
+			return this.modelInfoCache
+		}
+
 		const client = this.ensureClient()
-		const modelId = this.options.liteLlmModelId || liteLlmDefaultModelId
+		// Handle base URLs that already include /v1 to avoid double /v1/v1/
+		const baseUrl = client.baseURL.endsWith("/v1") ? client.baseURL : `${client.baseURL}/v1`
+		const url = `${baseUrl}/model/info`
+
 		try {
-			const response = await fetch(`${client.baseURL}/spend/calculate`, {
-				method: "POST",
+			const response = await fetch(url, {
+				method: "GET",
 				headers: {
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${this.options.liteLlmApiKey}`,
+					accept: "application/json",
+					"x-litellm-api-key": this.options.liteLlmApiKey || "",
 				},
-				body: JSON.stringify({
-					completion_response: {
-						model: modelId,
-						usage: {
-							prompt_tokens,
-							completion_tokens,
-						},
-					},
-				}),
 			})
 
 			if (response.ok) {
-				const data: { cost: number } = await response.json()
-				return data.cost
+				const data: LiteLlmModelInfoResponse = await response.json()
+				this.modelInfoCache = data
+				this.modelInfoCacheTimestamp = now
+				return data
 			} else {
-				console.error("Error calculating spend:", response.statusText)
-				return undefined
+				console.warn("Failed to fetch LiteLLM model info:", response.statusText)
+				// Try with Authorization header instead
+				const retryResponse = await fetch(url, {
+					method: "GET",
+					headers: {
+						accept: "application/json",
+						Authorization: `Bearer ${this.options.liteLlmApiKey || ""}`,
+					},
+				})
+
+				if (retryResponse.ok) {
+					const data: LiteLlmModelInfoResponse = await retryResponse.json()
+					this.modelInfoCache = data
+					this.modelInfoCacheTimestamp = now
+					return data
+				} else {
+					console.warn("Failed to fetch LiteLLM model info with Authorization header:", retryResponse.statusText)
+					return undefined
+				}
 			}
+		} catch (error) {
+			console.warn("Error fetching LiteLLM model info:", error)
+			return undefined
+		}
+	}
+
+	private async getModelCostInfo(publicModelName: string): Promise<{
+		inputCostPerToken: number
+		outputCostPerToken: number
+		cacheCreationCostPerToken?: number
+		cacheReadCostPerToken?: number
+	}> {
+		try {
+			const modelInfo = await this.fetchModelInfo()
+
+			if (modelInfo?.data) {
+				// Find the model by public name
+				const matchingModel = modelInfo.data.find((model) => model.model_name === publicModelName)
+
+				if (matchingModel?.model_info) {
+					return {
+						inputCostPerToken: matchingModel.model_info.input_cost_per_token || 0,
+						outputCostPerToken: matchingModel.model_info.output_cost_per_token || 0,
+						cacheCreationCostPerToken: matchingModel.model_info.cache_creation_input_token_cost,
+						cacheReadCostPerToken: matchingModel.model_info.cache_read_input_token_cost,
+					}
+				}
+			}
+		} catch (error) {
+			console.warn("Error getting LiteLLM model cost info:", error)
+		}
+
+		// Fallback to zero costs if we can't get the information
+		return {
+			inputCostPerToken: 0,
+			outputCostPerToken: 0,
+		}
+	}
+
+	async calculateCost(
+		prompt_tokens: number,
+		completion_tokens: number,
+		cache_creation_tokens?: number,
+		cache_read_tokens?: number,
+	): Promise<number | undefined> {
+		const publicModelId = this.options.liteLlmModelId || liteLlmDefaultModelId
+
+		try {
+			const costInfo = await this.getModelCostInfo(publicModelId)
+
+			// Calculate costs for different token types
+			const inputCost = Math.max(0, prompt_tokens - (cache_read_tokens || 0)) * costInfo.inputCostPerToken
+			const outputCost = completion_tokens * costInfo.outputCostPerToken
+			const cacheCreationCost = (cache_creation_tokens || 0) * (costInfo.cacheCreationCostPerToken || 0)
+			const cacheReadCost = (cache_read_tokens || 0) * (costInfo.cacheReadCostPerToken || 0)
+
+			const totalCost = inputCost + outputCost + cacheCreationCost + cacheReadCost
+
+			return totalCost
 		} catch (error) {
 			console.error("Error calculating spend:", error)
 			return undefined
@@ -136,9 +233,6 @@ export class LiteLlmHandler implements ApiHandler {
 			...(this.options.taskId && { litellm_session_id: `cline-${this.options.taskId}` }), // Add session ID for LiteLLM tracking
 		})
 
-		const inputCost = (await this.calculateCost(1e6, 0)) || 0
-		const outputCost = (await this.calculateCost(0, 1e6)) || 0
-
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 
@@ -165,9 +259,6 @@ export class LiteLlmHandler implements ApiHandler {
 
 			// Handle token usage information
 			if (chunk.usage) {
-				const totalCost =
-					(inputCost * chunk.usage.prompt_tokens) / 1e6 + (outputCost * chunk.usage.completion_tokens) / 1e6
-
 				// Extract cache-related information if available
 				// Need to use type assertion since these properties are not in the standard OpenAI types
 				const usage = chunk.usage as {
@@ -182,6 +273,15 @@ export class LiteLlmHandler implements ApiHandler {
 				const cacheWriteTokens = usage.cache_creation_input_tokens || usage.prompt_cache_miss_tokens || 0
 				const cacheReadTokens = usage.cache_read_input_tokens || usage.prompt_cache_hit_tokens || 0
 
+				// Calculate cost using the actual token usage including cache tokens
+				const totalCost =
+					(await this.calculateCost(
+						usage.prompt_tokens || 0,
+						usage.completion_tokens || 0,
+						cacheWriteTokens > 0 ? cacheWriteTokens : undefined,
+						cacheReadTokens > 0 ? cacheReadTokens : undefined,
+					)) || 0
+
 				yield {
 					type: "usage",
 					inputTokens: usage.prompt_tokens || 0,

src/api/providers/ollama.ts

@@ -1,5 +1,5 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import { Message, Ollama } from "ollama"
+import { Message, Ollama, Config } from "ollama"
 import { ApiHandler } from "../"
 import { ApiHandlerOptions, ModelInfo, openAiModelInfoSaneDefaults } from "../../shared/api"
 import { convertToOllamaMessages } from "../transform/ollama-format"
@@ -8,6 +8,7 @@ import { withRetry } from "../retry"
 
 interface OllamaHandlerOptions {
 	ollamaBaseUrl?: string
+	ollamaApiKey?: string
 	ollamaModelId?: string
 	ollamaApiOptionsCtxNum?: string
 	requestTimeoutMs?: number
@@ -24,7 +25,18 @@ export class OllamaHandler implements ApiHandler {
 	private ensureClient(): Ollama {
 		if (!this.client) {
 			try {
-				this.client = new Ollama({ host: this.options.ollamaBaseUrl || "http://localhost:11434" })
+				const clientOptions: Partial<Config> = {
+					host: this.options.ollamaBaseUrl || "http://localhost:11434",
+				}
+
+				// Add API key if provided (for Ollama cloud or authenticated instances)
+				if (this.options.ollamaApiKey) {
+					clientOptions.headers = {
+						Authorization: `Bearer ${this.options.ollamaApiKey}`,
+					}
+				}
+
+				this.client = new Ollama(clientOptions)
 			} catch (error) {
 				throw new Error(`Error creating Ollama client: ${error.message}`)
 			}

src/api/providers/openai-native.ts

@@ -104,6 +104,33 @@ export class OpenAiNativeHandler implements ApiHandler {
 				}
 				break
 			}
+			case "nectarine-alpha-new-reasoning-effort-2025-07-25":
+			case "gpt-5-2025-08-07":
+			case "gpt-5-mini-2025-08-07":
+			case "gpt-5-nano-2025-08-07":
+				const stream = await client.chat.completions.create({
+					model: model.id,
+					temperature: 1,
+					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
+					stream: true,
+					stream_options: { include_usage: true },
+					reasoning_effort: (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium",
+				})
+
+				for await (const chunk of stream) {
+					const delta = chunk.choices[0]?.delta
+					if (delta?.content) {
+						yield {
+							type: "text",
+							text: delta.content,
+						}
+					}
+					if (chunk.usage) {
+						// Only last chunk contains usage
+						yield* this.yieldUsage(model.info, chunk.usage)
+					}
+				}
+				break
 			default: {
 				const stream = await client.chat.completions.create({
 					model: model.id,

src/api/providers/openrouter.ts

@@ -132,27 +132,14 @@ export class OpenRouterHandler implements ApiHandler {
 			}
 
 			if (!didOutputUsage && chunk.usage) {
-				let modelId = this.options.openRouterModelId
-				if (modelId && modelId.includes("gemini")) {
-					yield {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-						inputTokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
-						outputTokens: chunk.usage.completion_tokens || 0,
-						// @ts-ignore-next-line
-						totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
-					}
-				} else {
-					yield {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-						inputTokens: chunk.usage.prompt_tokens || 0,
-						outputTokens: chunk.usage.completion_tokens || 0,
-						// @ts-ignore-next-line
-						totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
-					}
+				yield {
+					type: "usage",
+					cacheWriteTokens: 0,
+					cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+					inputTokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+					outputTokens: chunk.usage.completion_tokens || 0,
+					// @ts-ignore-next-line
+					totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
 				}
 				didOutputUsage = true
 			}
@@ -174,27 +161,14 @@ export class OpenRouterHandler implements ApiHandler {
 				const generationIterator = this.fetchGenerationDetails(this.lastGenerationId)
 				const generation = (await generationIterator.next()).value
 				// console.log("OpenRouter generation details:", generation)
-				let modelId = this.options.openRouterModelId
-				if (modelId && modelId.includes("gemini")) {
-					return {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: generation?.native_tokens_cached || 0,
-						// openrouter generation endpoint fails often
-						inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
-						outputTokens: generation?.native_tokens_completion || 0,
-						totalCost: generation?.total_cost || 0,
-					}
-				} else {
-					return {
-						type: "usage",
-						cacheWriteTokens: 0,
-						cacheReadTokens: generation?.native_tokens_cached || 0,
-						// openrouter generation endpoint fails often
-						inputTokens: generation?.native_tokens_prompt || 0,
-						outputTokens: generation?.native_tokens_completion || 0,
-						totalCost: generation?.total_cost || 0,
-					}
+				return {
+					type: "usage",
+					cacheWriteTokens: 0,
+					cacheReadTokens: generation?.native_tokens_cached || 0,
+					// openrouter generation endpoint fails often
+					inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
+					outputTokens: generation?.native_tokens_completion || 0,
+					totalCost: generation?.total_cost || 0,
 				}
 			} catch (error) {
 				// ignore if fails

src/api/providers/qwen.ts

@@ -9,6 +9,7 @@ import {
 	internationalQwenDefaultModelId,
 	MainlandQwenModelId,
 	InternationalQwenModelId,
+	QwenApiRegions,
 } from "@shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
@@ -17,7 +18,7 @@ import { withRetry } from "../retry"
 
 interface QwenHandlerOptions {
 	qwenApiKey?: string
-	qwenApiLine?: string
+	qwenApiLine?: QwenApiRegions
 	apiModelId?: string
 	thinkingBudgetTokens?: number
 }
@@ -27,7 +28,15 @@ export class QwenHandler implements ApiHandler {
 	private client: OpenAI | undefined
 
 	constructor(options: QwenHandlerOptions) {
-		this.options = options
+		// Ensure options start with defaults but allow overrides
+		this.options = {
+			qwenApiLine: QwenApiRegions.CHINA,
+			...options,
+		}
+	}
+
+	private useChinaApi(): boolean {
+		return this.options.qwenApiLine === QwenApiRegions.CHINA
 	}
 
 	private ensureClient(): OpenAI {
@@ -37,10 +46,9 @@ export class QwenHandler implements ApiHandler {
 			}
 			try {
 				this.client = new OpenAI({
-					baseURL:
-						this.options.qwenApiLine === "china"
-							? "https://dashscope.aliyuncs.com/compatible-mode/v1"
-							: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+					baseURL: this.useChinaApi()
+						? "https://dashscope.aliyuncs.com/compatible-mode/v1"
+						: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
 					apiKey: this.options.qwenApiKey,
 				})
 			} catch (error: any) {
@@ -53,7 +61,7 @@ export class QwenHandler implements ApiHandler {
 	getModel(): { id: MainlandQwenModelId | InternationalQwenModelId; info: ModelInfo } {
 		const modelId = this.options.apiModelId
 		// Branch based on API line to let poor typescript know what to do
-		if (this.options.qwenApiLine === "china") {
+		if (this.useChinaApi()) {
 			return {
 				id: (modelId as MainlandQwenModelId) ?? mainlandQwenDefaultModelId,
 				info: mainlandQwenModels[modelId as MainlandQwenModelId] ?? mainlandQwenModels[mainlandQwenDefaultModelId],

src/api/providers/requesty.ts

@@ -74,7 +74,10 @@ export class RequestyHandler implements ApiHandler {
 				? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
 				: { thinking: { type: "disabled" } }
 		const thinkingArgs =
-			model.id.includes("claude-3-7-sonnet") || model.id.includes("claude-sonnet-4") || model.id.includes("claude-opus-4")
+			model.id.includes("claude-3-7-sonnet") ||
+			model.id.includes("claude-sonnet-4") ||
+			model.id.includes("claude-opus-4") ||
+			model.id.includes("claude-opus-4-1")
 				? thinking
 				: {}
 

src/api/providers/sapaicore.ts

@@ -5,6 +5,11 @@ import { ApiHandler } from "../"
 import { ModelInfo, sapAiCoreDefaultModelId, SapAiCoreModelId, sapAiCoreModels } from "../../shared/api"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import {
+	type Message as BedrockMessage,
+	type ContentBlock as BedrockContentBlock,
+	ConversationRole as BedrockConversationRole,
+} from "@aws-sdk/client-bedrock-runtime"
 
 interface SapAiCoreHandlerOptions {
 	sapAiCoreClientId?: string
@@ -13,6 +18,7 @@ interface SapAiCoreHandlerOptions {
 	sapAiResourceGroup?: string
 	sapAiCoreBaseUrl?: string
 	apiModelId?: string
+	thinkingBudgetTokens?: number
 }
 
 interface Deployment {
@@ -27,6 +33,307 @@ interface Token {
 	token_type: string
 	expires_at: number
 }
+
+// Bedrock namespace containing caching-related functions
+namespace Bedrock {
+	// Define cache point type for AWS Bedrock
+	interface CachePointContentBlock {
+		cachePoint: {
+			type: "default"
+		}
+	}
+
+	// Define types for supported content types
+	type SupportedContentType = "text" | "image" | "thinking"
+
+	interface ContentItem {
+		type: SupportedContentType
+		text?: string
+		source?: {
+			data: string | Buffer | Uint8Array
+			media_type?: string
+		}
+	}
+
+	/**
+	 * Prepares system messages with optional caching support
+	 */
+	export function prepareSystemMessages(systemPrompt: string, enableCaching: boolean): any[] | undefined {
+		if (!systemPrompt) {
+			return undefined
+		}
+
+		if (enableCaching) {
+			return [{ text: systemPrompt }, { cachePoint: { type: "default" } }]
+		}
+
+		return [{ text: systemPrompt }]
+	}
+
+	/**
+	 * Applies cache control to messages for prompt caching using AWS Bedrock's cachePoint system
+	 * AWS Bedrock uses cachePoint objects instead of Anthropic's cache_control approach
+	 */
+	export function applyCacheControlToMessages(
+		messages: BedrockMessage[],
+		lastUserMsgIndex: number,
+		secondLastMsgUserIndex: number,
+	): BedrockMessage[] {
+		return messages.map((message, index) => {
+			// Add cachePoint to the last user message and second-to-last user message
+			if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
+				// Clone the message to avoid modifying the original
+				const messageWithCache = { ...message }
+
+				if (messageWithCache.content && Array.isArray(messageWithCache.content)) {
+					// Add cachePoint to the end of the content array
+					messageWithCache.content = [
+						...messageWithCache.content,
+						{
+							cachePoint: {
+								type: "default",
+							},
+						} as CachePointContentBlock, // Properly typed cache point for AWS SDK
+					]
+				}
+
+				return messageWithCache
+			}
+
+			return message
+		})
+	}
+
+	/**
+	 * Formats messages for models using the Converse API specification
+	 * Used by both Anthropic and Nova models to avoid code duplication
+	 */
+	export function formatMessagesForConverseAPI(messages: Anthropic.Messages.MessageParam[]): BedrockMessage[] {
+		return messages.map((message) => {
+			// Determine role (user or assistant)
+			const role = message.role === "user" ? BedrockConversationRole.USER : BedrockConversationRole.ASSISTANT
+
+			// Process content based on type
+			let content: BedrockContentBlock[] = []
+
+			if (typeof message.content === "string") {
+				// Simple text content
+				content = [{ text: message.content }]
+			} else if (Array.isArray(message.content)) {
+				// Convert Anthropic content format to Converse API content format
+				const processedContent = message.content
+					.map((item) => {
+						// Text content
+						if (item.type === "text") {
+							return { text: item.text }
+						}
+
+						// Image content
+						if (item.type === "image") {
+							return processImageContent(item)
+						}
+
+						// Log unsupported content types for debugging
+						console.warn(`Unsupported content type: ${(item as ContentItem).type}`)
+						return null
+					})
+					.filter((item): item is BedrockContentBlock => item !== null)
+
+				content = processedContent
+			}
+
+			// Return formatted message
+			return {
+				role,
+				content,
+			}
+		})
+	}
+
+	/**
+	 * Processes image content with proper error handling and user notification
+	 */
+	function processImageContent(item: any): BedrockContentBlock | null {
+		let imageData: Uint8Array
+		let format: "png" | "jpeg" | "gif" | "webp" = "jpeg" // default format
+
+		// Extract format from media_type if available
+		if (item.source.media_type) {
+			// Extract format from media_type (e.g., "image/jpeg" -> "jpeg")
+			const formatMatch = item.source.media_type.match(/image\/(\w+)/)
+			if (formatMatch && formatMatch[1]) {
+				const extractedFormat = formatMatch[1]
+				// Ensure format is one of the allowed values
+				if (["png", "jpeg", "gif", "webp"].includes(extractedFormat)) {
+					format = extractedFormat as "png" | "jpeg" | "gif" | "webp"
+				}
+			}
+		}
+
+		// Get image data with improved error handling
+		try {
+			if (typeof item.source.data === "string") {
+				// Handle base64 encoded data
+				const base64Data = item.source.data.replace(/^data:image\/\w+;base64,/, "")
+				imageData = new Uint8Array(Buffer.from(base64Data, "base64"))
+			} else if (item.source.data && typeof item.source.data === "object") {
+				// Try to convert to Uint8Array
+				imageData = new Uint8Array(Buffer.from(item.source.data as Buffer | Uint8Array))
+			} else {
+				throw new Error("Unsupported image data format")
+			}
+
+			return {
+				image: {
+					format,
+					source: {
+						bytes: imageData,
+					},
+				},
+			}
+		} catch (error) {
+			console.error("Failed to process image content:", error)
+			// Return a text content indicating the error instead of null
+			// This ensures users are aware of the issue
+			return {
+				text: `[ERROR: Failed to process image - ${error instanceof Error ? error.message : "Unknown error"}]`,
+			}
+		}
+	}
+}
+
+// Gemini namespace containing caching-related functions and types
+namespace Gemini {
+	/**
+	 * Process Gemini streaming response with enhanced thinking content support and caching awareness
+	 */
+	export function processStreamChunk(data: any): {
+		text?: string
+		reasoning?: string
+		usageMetadata?: {
+			promptTokenCount?: number
+			candidatesTokenCount?: number
+			thoughtsTokenCount?: number
+			cachedContentTokenCount?: number
+		}
+	} {
+		const result: ReturnType<typeof processStreamChunk> = {}
+
+		// Handle thinking content from Gemini's response
+		const candidateForThoughts = data?.candidates?.[0]
+		const partsForThoughts = candidateForThoughts?.content?.parts
+		let thoughts = ""
+
+		if (partsForThoughts) {
+			for (const part of partsForThoughts) {
+				const { thought, text } = part
+				if (thought && text) {
+					thoughts += text + "\n"
+				}
+			}
+		}
+
+		if (thoughts.trim() !== "") {
+			result.reasoning = thoughts.trim()
+		}
+
+		// Handle regular text content
+		if (data.text) {
+			result.text = data.text
+		}
+
+		// Handle content parts for non-thought text
+		if (data.candidates && data.candidates[0]?.content?.parts) {
+			let nonThoughtText = ""
+			for (const part of data.candidates[0].content.parts) {
+				if (part.text && !part.thought) {
+					nonThoughtText += part.text
+				}
+			}
+			if (nonThoughtText && !result.text) {
+				result.text = nonThoughtText
+			}
+		}
+
+		// Handle usage metadata with caching support
+		if (data.usageMetadata) {
+			result.usageMetadata = {
+				promptTokenCount: data.usageMetadata.promptTokenCount,
+				candidatesTokenCount: data.usageMetadata.candidatesTokenCount,
+				thoughtsTokenCount: data.usageMetadata.thoughtsTokenCount,
+				cachedContentTokenCount: data.usageMetadata.cachedContentTokenCount,
+			}
+		}
+
+		return result
+	}
+
+	function convertAnthropicMessageToGemini(message: Anthropic.Messages.MessageParam) {
+		const role = message.role === "assistant" ? "model" : "user"
+		const parts = []
+
+		if (typeof message.content === "string") {
+			parts.push({ text: message.content })
+		} else if (Array.isArray(message.content)) {
+			for (const block of message.content) {
+				if (block.type === "text") {
+					parts.push({ text: block.text })
+				} else if (block.type === "image") {
+					parts.push({
+						inlineData: {
+							mimeType: block.source.media_type,
+							data: block.source.data,
+						},
+					})
+				}
+			}
+		}
+
+		return { role, parts }
+	}
+
+	/**
+	 * Prepare Gemini request payload with thinking configuration and implicit caching support
+	 */
+	export function prepareRequestPayload(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		model: { id: SapAiCoreModelId; info: ModelInfo },
+		thinkingBudgetTokens?: number,
+	): any {
+		const contents = messages.map(convertAnthropicMessageToGemini)
+
+		const payload = {
+			contents,
+			systemInstruction: {
+				parts: [
+					{
+						text: systemPrompt,
+					},
+				],
+			},
+			generationConfig: {
+				maxOutputTokens: model.info.maxTokens,
+				temperature: 0.0,
+			},
+		}
+
+		// Add thinking config if the model supports it and budget is provided
+		const thinkingBudget = thinkingBudgetTokens ?? 0
+		const maxBudget = model.info.thinkingConfig?.maxBudget ?? 0
+
+		if (thinkingBudget > 0 && model.info.thinkingConfig) {
+			// Add thinking configuration to the payload
+			;(payload as any).thinkingConfig = {
+				thinkingBudget: thinkingBudget,
+				includeThoughts: true,
+			}
+		}
+
+		return payload
+	}
+}
+
 export class SapAiCoreHandler implements ApiHandler {
 	private options: SapAiCoreHandlerOptions
 	private token?: Token
@@ -142,7 +449,20 @@ export class SapAiCoreHandler implements ApiHandler {
 			"anthropic--claude-3-opus",
 		]
 
-		const openAIModels = ["gpt-4o", "gpt-4", "gpt-4o-mini", "o1", "gpt-4.1", "gpt-4.1-nano", "o3-mini", "o3", "o4-mini"]
+		const openAIModels = [
+			"gpt-4o",
+			"gpt-4",
+			"gpt-4o-mini",
+			"o1",
+			"gpt-4.1",
+			"gpt-4.1-nano",
+			"gpt-5",
+			"gpt-5-nano",
+			"gpt-5-mini",
+			"o3-mini",
+			"o3",
+			"o4-mini",
+		]
 
 		const geminiModels = ["gemini-2.5-flash", "gemini-2.5-pro"]
 
@@ -151,21 +471,47 @@ export class SapAiCoreHandler implements ApiHandler {
 		if (anthropicModels.includes(model.id)) {
 			url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/invoke-with-response-stream`
 
+			// Format messages for Converse API. Note that the Invoke API has
+			// the same format for messages as the Converse API.
+			const formattedMessages = Bedrock.formatMessagesForConverseAPI(messages)
+
+			// Get message indices for caching
+			const userMsgIndices = messages.reduce(
+				(acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc),
+				[] as number[],
+			)
+			const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
+			const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
+
 			if (
 				model.id === "anthropic--claude-4-sonnet" ||
 				model.id === "anthropic--claude-4-opus" ||
 				model.id === "anthropic--claude-3.7-sonnet"
 			) {
+				// Use converse-stream endpoint with caching support
 				url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/converse-stream`
+
+				// Apply caching controls to messages (enabled by default)
+				const messagesWithCache = Bedrock.applyCacheControlToMessages(
+					formattedMessages,
+					lastUserMsgIndex,
+					secondLastMsgUserIndex,
+				)
+
+				// Prepare system message with caching support (enabled by default)
+				const systemMessages = Bedrock.prepareSystemMessages(systemPrompt, true)
+
 				payload = {
 					inferenceConfig: {
 						maxTokens: model.info.maxTokens,
 						temperature: 0.0,
 					},
-					system: systemPrompt ? [{ text: systemPrompt }] : undefined,
-					messages: this.formatAnthropicMessages(messages),
+					system: systemMessages,
+					messages: messagesWithCache,
 				}
 			} else {
+				// Use invoke-with-response-stream endpoint
+				// TODO: add caching support using Anthropic-native cache_control blocks
 				payload = {
 					max_tokens: model.info.maxTokens,
 					system: systemPrompt,
@@ -191,7 +537,7 @@ export class SapAiCoreHandler implements ApiHandler {
 				stream_options: { include_usage: true },
 			}
 
-			if (["o1", "o3-mini", "o3", "o4-mini"].includes(model.id)) {
+			if (["o1", "o3-mini", "o3", "o4-mini", "gpt-5", "gpt-5-nano", "gpt-5-mini"].includes(model.id)) {
 				delete payload.max_tokens
 				delete payload.temperature
 			}
@@ -202,7 +548,7 @@ export class SapAiCoreHandler implements ApiHandler {
 			}
 		} else if (geminiModels.includes(model.id)) {
 			url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/models/${model.id}:streamGenerateContent`
-			payload = this.convertToGeminiFormat(systemPrompt, messages)
+			payload = Gemini.prepareRequestPayload(systemPrompt, messages, model, this.options.thinkingBudgetTokens)
 		} else {
 			throw new Error(`Unsupported model: ${model.id}`)
 		}
@@ -359,9 +705,17 @@ export class SapAiCoreHandler implements ApiHandler {
 
 							// Handle metadata (token usage)
 							if (data.metadata?.usage) {
-								const inputTokens = data.metadata.usage.inputTokens || 0
+								let inputTokens = data.metadata.usage.inputTokens || 0
 								const outputTokens = data.metadata.usage.outputTokens || 0
 
+								// calibrate input token
+								const totalTokens = data.metadata.usage.totalTokens || 0
+								const cacheReadInputTokens = data.metadata.usage.cacheReadInputTokens || 0
+								const cacheWriteOutputTokens = data.metadata.usage.cacheWriteOutputTokens || 0
+								if (inputTokens + outputTokens + cacheReadInputTokens + cacheWriteOutputTokens !== totalTokens) {
+									inputTokens = totalTokens - outputTokens - cacheReadInputTokens - cacheWriteOutputTokens
+								}
+
 								yield {
 									type: "usage",
 									inputTokens,
@@ -493,50 +847,31 @@ export class SapAiCoreHandler implements ApiHandler {
 						const jsonData = line.slice(6)
 						try {
 							const data = JSON.parse(jsonData)
-							const candidateForThoughts = data?.candidates?.[0]
-							const partsForThoughts = candidateForThoughts?.content?.parts
-							let thoughts = ""
 
-							if (partsForThoughts) {
-								for (const part of partsForThoughts) {
-									const { thought, text } = part
-									if (thought && text) {
-										thoughts += text + "\n"
-									}
-								}
-							}
+							// Use Gemini namespace to process the chunk
+							const processed = Gemini.processStreamChunk(data)
 
-							if (thoughts.trim() !== "") {
+							// Yield reasoning if present
+							if (processed.reasoning) {
 								yield {
 									type: "reasoning",
-									reasoning: thoughts.trim(),
+									reasoning: processed.reasoning,
 								}
 							}
 
-							if (data.text) {
+							// Yield text if present
+							if (processed.text) {
 								yield {
 									type: "text",
-									text: data.text,
+									text: processed.text,
 								}
 							}
 
-							if (data.candidates && data.candidates[0]?.content?.parts) {
-								for (const part of data.candidates[0].content.parts) {
-									if (part.text && !part.thought) {
-										// Only non-thought text
-										yield {
-											type: "text",
-											text: part.text,
-										}
-									}
-								}
-							}
-
-							if (data.usageMetadata) {
-								promptTokens = data.usageMetadata.promptTokenCount ?? promptTokens
-								outputTokens = data.usageMetadata.candidatesTokenCount ?? outputTokens
-								thoughtsTokenCount = data.usageMetadata.thoughtsTokenCount ?? thoughtsTokenCount
-								cacheReadTokens = data.usageMetadata.cachedContentTokenCount ?? cacheReadTokens
+							if (processed.usageMetadata) {
+								promptTokens = processed.usageMetadata.promptTokenCount ?? promptTokens
+								outputTokens = processed.usageMetadata.candidatesTokenCount ?? outputTokens
+								thoughtsTokenCount = processed.usageMetadata.thoughtsTokenCount ?? thoughtsTokenCount
+								cacheReadTokens = processed.usageMetadata.cachedContentTokenCount ?? cacheReadTokens
 
 								yield {
 									type: "usage",
@@ -544,6 +879,7 @@ export class SapAiCoreHandler implements ApiHandler {
 									outputTokens,
 									thoughtsTokenCount,
 									cacheReadTokens,
+									cacheWriteTokens: 0,
 								}
 							}
 						} catch (error) {
@@ -581,111 +917,4 @@ export class SapAiCoreHandler implements ApiHandler {
 		}
 		return { id: sapAiCoreDefaultModelId, info: sapAiCoreModels[sapAiCoreDefaultModelId] }
 	}
-
-	private getValidImageFormat(mediaType: string): string {
-		const format = mediaType.split("/")[1]?.toLowerCase()
-		const validFormats = ["png", "jpeg", "gif", "webp"]
-
-		if (validFormats.includes(format)) {
-			return format
-		}
-		throw new Error(`Unsupported image format: ${format}`)
-	}
-
-	private convertToGeminiFormat(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]) {
-		const contents = messages.map(this.convertAnthropicMessageToGemini)
-
-		const payload = {
-			contents,
-			systemInstruction: {
-				parts: [
-					{
-						text: systemPrompt,
-					},
-				],
-			},
-			generationConfig: {
-				maxOutputTokens: this.getModel().info.maxTokens,
-				temperature: 0.0,
-			},
-		}
-
-		return payload
-	}
-
-	private convertAnthropicMessageToGemini(message: Anthropic.Messages.MessageParam) {
-		const role = message.role === "assistant" ? "model" : "user"
-		const parts = []
-
-		if (typeof message.content === "string") {
-			parts.push({ text: message.content })
-		} else if (Array.isArray(message.content)) {
-			for (const block of message.content) {
-				if (block.type === "text") {
-					parts.push({ text: block.text })
-				} else if (block.type === "image") {
-					parts.push({
-						inlineData: {
-							mimeType: block.source.media_type,
-							data: block.source.data,
-						},
-					})
-				}
-			}
-		}
-
-		return { role, parts }
-	}
-	private formatAnthropicMessages(messages: Anthropic.Messages.MessageParam[]): any[] {
-		return messages.map((m) => {
-			const contentBlocks: any[] = []
-
-			if (typeof m.content === "string") {
-				contentBlocks.push({ text: m.content })
-			} else if (Array.isArray(m.content)) {
-				for (const block of m.content) {
-					if (block.type === "text") {
-						if (!block.text) {
-							throw new Error('Text block is missing the "text" field.')
-						}
-						contentBlocks.push({ text: block.text })
-					} else if (block.type === "image") {
-						if (!block.source) {
-							throw new Error('Image block is missing the "source" field.')
-						}
-
-						const { type, media_type, data } = block.source
-
-						if (!type || !media_type || !data) {
-							throw new Error('Image source must have "type", "media_type", and "data" fields.')
-						}
-
-						if (type !== "base64") {
-							throw new Error(`Unsupported image source type: ${type}. Only "base64" is supported.`)
-						}
-
-						const format = this.getValidImageFormat(media_type)
-
-						contentBlocks.push({
-							image: {
-								format,
-								source: {
-									bytes: data,
-								},
-							},
-						})
-					} else {
-						throw new Error(`Unsupported content block type: ${block.type}`)
-					}
-				}
-			} else {
-				throw new Error("Unsupported content format.")
-			}
-
-			return {
-				role: m.role,
-				content: contentBlocks,
-			}
-		})
-	}
 }

src/api/providers/vertex.ts

@@ -86,6 +86,7 @@ export class VertexHandler implements ApiHandler {
 
 		switch (modelId) {
 			case "claude-sonnet-4@20250514":
+			case "claude-opus-4-1@20250805":
 			case "claude-opus-4@20250514":
 			case "claude-3-7-sonnet@20250219":
 			case "claude-3-5-sonnet-v2@20241022":

src/api/providers/vscode-lm.ts

@@ -1,13 +1,13 @@
 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 { ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
-import type { LanguageModelChatSelector as LanguageModelChatSelectorFromTypes } from "./types"
+import { SELECTOR_SEPARATOR, stringifyVsCodeLmModelSelector } from "@shared/vsCodeSelectorUtils"
+import { calculateApiCostAnthropic } from "@utils/cost"
+import * as vscode from "vscode"
+import { ApiHandler, SingleCompletionHandler } from "../"
 import { withRetry } from "../retry"
+import type { LanguageModelChatSelector as LanguageModelChatSelectorFromTypes } from "./types"
 
 interface VsCodeLmHandlerOptions {
 	vsCodeLmModelSelector?: any
@@ -237,82 +237,40 @@ export class VsCodeLmHandler implements ApiHandler, SingleCompletionHandler {
 		}
 	}
 
-	private async countTokens(text: string | vscode.LanguageModelChatMessage): Promise<number> {
-		// Check for required dependencies
-		if (!this.client) {
-			console.warn("Cline <Language Model API>: No client available for token counting")
-			return 0
-		}
-
-		if (!this.currentRequestCancellation) {
-			console.warn("Cline <Language Model API>: No cancellation token available for token counting")
-			return 0
-		}
-
-		// Validate input
-		if (!text) {
-			console.debug("Cline <Language Model API>: Empty text provided for token counting")
-			return 0
-		}
-
-		try {
-			// Handle different input types
-			let tokenCount: number
-
-			if (typeof text === "string") {
-				tokenCount = await this.client.countTokens(text, this.currentRequestCancellation.token)
-			} else if (text instanceof vscode.LanguageModelChatMessage) {
-				// For chat messages, ensure we have content
-				if (!text.content || (Array.isArray(text.content) && text.content.length === 0)) {
-					console.debug("Cline <Language Model API>: Empty chat message content")
-					return 0
-				}
-				tokenCount = await this.client.countTokens(text, this.currentRequestCancellation.token)
-			} else {
-				console.warn("Cline <Language Model API>: Invalid input type for token counting")
-				return 0
-			}
-
-			// Validate the result
-			if (typeof tokenCount !== "number") {
-				console.warn("Cline <Language Model API>: Non-numeric token count received:", tokenCount)
-				return 0
-			}
-
-			if (tokenCount < 0) {
-				console.warn("Cline <Language Model API>: Negative token count received:", tokenCount)
-				return 0
-			}
-
-			return tokenCount
-		} catch (error) {
-			// Handle specific error types
-			if (error instanceof vscode.CancellationError) {
-				console.debug("Cline <Language Model API>: Token counting cancelled by user")
-				return 0
-			}
-
-			const errorMessage = error instanceof Error ? error.message : "Unknown error"
-			console.warn("Cline <Language Model API>: Token counting failed:", errorMessage)
-
-			// Log additional error details if available
-			if (error instanceof Error && error.stack) {
-				console.debug("Token counting error stack:", error.stack)
-			}
-
-			return 0 // Fallback to prevent stream interruption
+	private extractTextFromMessage(message: vscode.LanguageModelChatMessage): string {
+		if (Array.isArray(message.content)) {
+			return message.content
+				.filter((part) => part instanceof vscode.LanguageModelTextPart)
+				.map((part) => (part as vscode.LanguageModelTextPart).value)
+				.join("")
 		}
+		return ""
 	}
 
-	private async calculateTotalInputTokens(
-		systemPrompt: string,
-		vsCodeLmMessages: vscode.LanguageModelChatMessage[],
-	): Promise<number> {
-		const systemTokens: number = await this.countTokens(systemPrompt)
+	private isClaudeModel(): boolean {
+		return this.client?.family?.startsWith("claude") || false
+	}
 
+	private async countTokens(text: string | vscode.LanguageModelChatMessage): Promise<number> {
+		/**
+		 * NOTE (intentional trade-off):
+		 * We use a coarse chars/4 heuristic here instead of a real tokenizer (e.g., js-tiktoken with o200k_base).
+		 * Rationale:
+		 *  - Avoid pulling multi‑MB rank files and increasing the extension install/download size.
+		 *  - Eliminate encoder lifecycle/memory concerns in long-running sessions.
+		 * Consequences:
+		 *  - This is not model-accurate and can under/over-estimate tokens, especially with tool/function calls.
+		 *  - It is “good enough” for budgeting/context checks, and we accept the inaccuracy by design.
+		 * If precise accounting becomes a requirement, reintroduce a tokenizer behind a feature flag or backend-only path.
+		 */
+		const textContent = typeof text === "string" ? text : this.extractTextFromMessage(text)
+		return Math.ceil((textContent || "").length / 4)
+	}
+
+	private async calculateTotalInputTokens(vsCodeLmMessages: vscode.LanguageModelChatMessage[]): Promise<number> {
 		const messageTokens: number[] = await Promise.all(vsCodeLmMessages.map((msg) => this.countTokens(msg)))
 
-		return systemTokens + messageTokens.reduce((sum: number, tokens: number): number => sum + tokens, 0)
+		return messageTokens.reduce((sum: number, tokens: number): number => sum + tokens, 0)
 	}
 
 	private ensureCleanState(): void {
@@ -434,7 +392,7 @@ export class VsCodeLmHandler implements ApiHandler, SingleCompletionHandler {
 		this.currentRequestCancellation = new vscode.CancellationTokenSource()
 
 		// Calculate input tokens before starting the stream
-		const totalInputTokens: number = await this.calculateTotalInputTokens(systemPrompt, vsCodeLmMessages)
+		const totalInputTokens: number = await this.calculateTotalInputTokens(vsCodeLmMessages)
 
 		// Accumulate the text and count at the end of the stream to reduce token counting overhead.
 		let accumulatedText: string = ""

src/api/transform/openrouter-stream.ts

@@ -24,6 +24,7 @@ export async function createOpenRouterStream(
 	// handles direct model.id match logic
 	switch (model.id) {
 		case "anthropic/claude-sonnet-4":
+		case "anthropic/claude-opus-4.1":
 		case "anthropic/claude-opus-4":
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":
@@ -82,6 +83,7 @@ export async function createOpenRouterStream(
 	let maxTokens: number | undefined
 	switch (model.id) {
 		case "anthropic/claude-sonnet-4":
+		case "anthropic/claude-opus-4.1":
 		case "anthropic/claude-opus-4":
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":
@@ -117,6 +119,7 @@ export async function createOpenRouterStream(
 	let reasoning: { max_tokens: number } | undefined = undefined
 	switch (model.id) {
 		case "anthropic/claude-sonnet-4":
+		case "anthropic/claude-opus-4.1":
 		case "anthropic/claude-opus-4":
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":

src/common.ts

@@ -0,0 +1,92 @@
+import * as vscode from "vscode"
+import {
+	migrateCustomInstructionsToGlobalRules,
+	migrateWelcomeViewCompleted,
+	migrateWorkspaceToGlobalStorage,
+} from "./core/storage/state-migrations"
+import { WebviewProvider } from "./core/webview"
+import { Logger } from "./services/logging/Logger"
+import { PostHogClientProvider } from "./services/posthog/PostHogClientProvider"
+import { WebviewProviderType } from "./shared/webview/types"
+import "./utils/path" // necessary to have access to String.prototype.toPosix
+
+import { HostProvider } from "@/hosts/host-provider"
+import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
+import { telemetryService } from "./services/posthog/PostHogClientProvider"
+import { ShowMessageType } from "./shared/proto/host/window"
+import { getLatestAnnouncementId } from "./utils/announcements"
+/**
+ * Performs intialization for Cline that is common to all platforms.
+ *
+ * @param context
+ * @returns The webview provider
+ */
+export async function initialize(context: vscode.ExtensionContext): Promise<WebviewProvider> {
+	// Initialize PostHog client provider
+	const distinctId = context.globalState.get<string>("cline.distinctId")
+	PostHogClientProvider.getInstance(distinctId)
+
+	// Migrate custom instructions to global Cline rules (one-time cleanup)
+	await migrateCustomInstructionsToGlobalRules(context)
+
+	// Migrate welcomeViewCompleted setting based on existing API keys (one-time cleanup)
+	await migrateWelcomeViewCompleted(context)
+
+	// Migrate workspace storage values back to global storage (reverting previous migration)
+	await migrateWorkspaceToGlobalStorage(context)
+
+	// Clean up orphaned file context warnings (startup cleanup)
+	await FileContextTracker.cleanupOrphanedWarnings(context)
+
+	const sidebarWebview = HostProvider.get().createWebviewProvider(WebviewProviderType.SIDEBAR)
+
+	await showVersionUpdateAnnouncement(context)
+
+	telemetryService.captureExtensionActivated()
+
+	return sidebarWebview
+}
+
+async function showVersionUpdateAnnouncement(context: vscode.ExtensionContext) {
+	// Version checking for autoupdate notification
+	const currentVersion = context.extension.packageJSON.version
+	const previousVersion = context.globalState.get<string>("clineVersion")
+	// Perform post-update actions if necessary
+	try {
+		if (!previousVersion || currentVersion !== previousVersion) {
+			Logger.log(`Cline version changed: ${previousVersion} -> ${currentVersion}. First run or update detected.`)
+
+			// Use the same condition as announcements: focus when there's a new announcement to show
+			const lastShownAnnouncementId = context.globalState.get<string>("lastShownAnnouncementId")
+			const latestAnnouncementId = getLatestAnnouncementId(context)
+
+			if (lastShownAnnouncementId !== latestAnnouncementId) {
+				// Focus Cline when there's a new announcement to show (major/minor updates or fresh installs)
+				const message = previousVersion
+					? `Cline has been updated to v${currentVersion}`
+					: `Welcome to Cline v${currentVersion}`
+				await vscode.commands.executeCommand("claude-dev.SidebarProvider.focus")
+				await new Promise((resolve) => setTimeout(resolve, 200))
+				HostProvider.window.showMessage({
+					type: ShowMessageType.INFORMATION,
+					message,
+				})
+			}
+			// Always update the main version tracker for the next launch.
+			await context.globalState.update("clineVersion", currentVersion)
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		console.error(`Error during post-update actions: ${errorMessage}, Stack trace: ${error.stack}`)
+	}
+}
+
+/**
+ * Performs cleanup when Cline is deactivated that is common to all platforms.
+ */
+export async function tearDown(): Promise<void> {
+	PostHogClientProvider.getInstance().dispose()
+
+	// Dispose all webview instances
+	await WebviewProvider.disposeAllInstances()
+}

src/core/assistant-message/index.ts

@@ -1,6 +1,6 @@
 export type AssistantMessageContent = TextContent | ToolUse
 
-export { parseAssistantMessageV1, parseAssistantMessageV2, parseAssistantMessageV3 } from "./parse-assistant-message"
+export { parseAssistantMessageV2, parseAssistantMessageV3 } from "./parse-assistant-message"
 
 export interface TextContent {
 	type: "text"
@@ -60,6 +60,7 @@ export const toolParamNames = [
 	"steps_to_reproduce",
 	"api_request_output",
 	"additional_context",
+	"needs_more_exploration",
 ] as const
 
 export type ToolParamName = (typeof toolParamNames)[number]

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

@@ -1,245 +1,6 @@
 import { AssistantMessageContent, TextContent, ToolUse, ToolParamName, toolParamNames, toolUseNames, ToolUseName } from "." // Assuming types are defined in index.ts or a similar file
 
-/**
- * @description **Version 1**
- * Parses an assistant message string potentially containing mixed text and tool usage blocks
- * marked with XML-like tags into an array of structured content objects.
- *
- * This version iterates through the message character by character, building an accumulator string.
- * It maintains state to track whether it's currently parsing text, a tool use block, or a specific tool parameter.
- * It detects the start and end of tool uses and parameters by checking if the accumulator ends with
- * the corresponding opening or closing tags.
- * Special handling is included for `write_to_file` and `new_rule` tool uses to correctly parse
- * the `content` parameter, which might contain the closing tag itself, by looking for the *last*
- * occurrence of the closing tag.
- * If the input string ends mid-tag or mid-content, the last block (text or tool use) is marked as partial.
- *
- * @param assistantMessage The raw string output from the assistant.
- * @returns An array of `AssistantMessageContent` objects, which can be `TextContent` or `ToolUse`.
- *          Blocks that were not fully closed by the end of the input string will have their `partial` flag set to `true`.
- */
-export function parseAssistantMessageV1(assistantMessage: string): AssistantMessageContent[] {
-	const contentBlocks: AssistantMessageContent[] = []
-	let currentTextContent: TextContent | undefined = undefined
-	let currentTextContentStartIndex = 0
-	let currentToolUse: ToolUse | undefined = undefined
-	let currentToolUseStartIndex = 0
-	let currentParamName: ToolParamName | undefined = undefined
-	let currentParamValueStartIndex = 0
-	let accumulator = ""
-
-	for (let i = 0; i < assistantMessage.length; i++) {
-		const char = assistantMessage[i]
-		accumulator += char
-
-		// --- State: Parsing a Tool Parameter ---
-		// there should not be a param without a tool use
-		if (currentToolUse && currentParamName) {
-			const currentParamValue = accumulator.slice(currentParamValueStartIndex)
-			const paramClosingTag = `</${currentParamName}>`
-			if (currentParamValue.endsWith(paramClosingTag)) {
-				// End of param value found
-				currentToolUse.params[currentParamName] = currentParamValue.slice(0, -paramClosingTag.length).trim()
-				currentParamName = undefined // Go back to parsing tool content or looking for next param
-				continue // Move to next character
-			} else {
-				// Partial param value is accumulating
-				continue // Move to next character
-			}
-		}
-
-		// --- State: Parsing a Tool Use (but not a specific parameter) ---
-		// no currentParamName
-		if (currentToolUse) {
-			const currentToolValue = accumulator.slice(currentToolUseStartIndex)
-			const toolUseClosingTag = `</${currentToolUse.name}>`
-
-			if (currentToolValue.endsWith(toolUseClosingTag)) {
-				// End of a tool use found
-				currentToolUse.partial = false
-				contentBlocks.push(currentToolUse)
-				currentToolUse = undefined // Go back to parsing text or looking for next tool
-				// Reset text start index in case text follows immediately
-				currentTextContentStartIndex = i + 1
-				continue // Move to next character
-			} else {
-				// Check if starting a new parameter within the current tool use
-				const possibleParamOpeningTags = toolParamNames.map((name) => `<${name}>`)
-				let foundParamStart = false
-				for (const paramOpeningTag of possibleParamOpeningTags) {
-					if (accumulator.endsWith(paramOpeningTag)) {
-						// Start of a new parameter found
-						currentParamName = paramOpeningTag.slice(1, -1) as ToolParamName
-						currentParamValueStartIndex = accumulator.length
-						foundParamStart = true
-						break
-					}
-				}
-				if (foundParamStart) {
-					continue // Move to next character
-				}
-
-				// Special case for write_to_file/new_rule content param allowing nested tags
-				// Check if a </content> tag appears, potentially indicating the end of the content param
-				// even if the main tool closing tag hasn't been seen yet.
-				const contentParamName: ToolParamName = "content"
-				if (
-					(currentToolUse.name === "write_to_file" || currentToolUse.name === "new_rule") &&
-					accumulator.endsWith(`</${contentParamName}>`)
-				) {
-					const toolContent = accumulator.slice(currentToolUseStartIndex)
-					const contentStartTag = `<${contentParamName}>`
-					const contentEndTag = `</${contentParamName}>`
-					const contentStartIndex = toolContent.indexOf(contentStartTag) + contentStartTag.length
-					// Use lastIndexOf to handle cases where </content> might appear within the content itself
-					const contentEndIndex = toolContent.lastIndexOf(contentEndTag)
-
-					// Ensure we found valid start/end tags and end is after start
-					if (
-						contentStartIndex !== -1 &&
-						contentEndIndex !== -1 &&
-						contentEndIndex > contentStartIndex - contentStartTag.length // Ensure end tag is after start tag begins
-					) {
-						// Check if this content param was already being parsed. If so, update it.
-						// If not, and we just found the closing tag, assign it.
-						// This handles cases where the </content> detection might fire before
-						// the <content> tag detection logic, or if the content is very short.
-						if (currentParamName === contentParamName) {
-							// Already parsing content, now we found the end tag
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							currentParamName = undefined // Finished with this param
-						} else if (currentParamName === undefined) {
-							// Not parsing a param, but found </content>. Assume it closes the content block.
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							// We stay in the "parsing tool use" state, looking for more params or the tool end tag.
-						}
-					}
-				}
-
-				// If none of the above, partial tool value is accumulating
-				continue // Move to next character
-			}
-		}
-
-		// --- State: Parsing Text (or looking for start of a tool use) ---
-		// no currentToolUse
-		let didStartToolUse = false
-		const possibleToolUseOpeningTags = toolUseNames.map((name) => `<${name}>`)
-		for (const toolUseOpeningTag of possibleToolUseOpeningTags) {
-			if (accumulator.endsWith(toolUseOpeningTag)) {
-				// Start of a new tool use found
-				const toolName = toolUseOpeningTag.slice(1, -1) as ToolUseName
-				currentToolUse = {
-					type: "tool_use",
-					name: toolName,
-					params: {},
-					partial: true,
-				}
-				currentToolUseStartIndex = accumulator.length
-
-				// This also indicates the end of the current text content block (if any)
-				if (currentTextContent) {
-					currentTextContent.partial = false
-					// Extract text content, removing the part that formed the tool opening tag
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					currentTextContent.content = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					// Only add if there's actual content
-					if (currentTextContent.content.length > 0) {
-						contentBlocks.push(currentTextContent)
-					}
-					currentTextContent = undefined
-				} else {
-					// Check if there was text before this tool use started
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					const potentialText = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					if (potentialText.length > 0) {
-						contentBlocks.push({
-							type: "text",
-							content: potentialText,
-							partial: false, // Ended because tool use started
-						})
-					}
-				}
-
-				didStartToolUse = true
-				break // Found tool start, stop checking for others
-			}
-		}
-
-		if (!didStartToolUse) {
-			// No tool use started, so it must be text content accumulating
-			// (or continuing after a closed tool use)
-			if (currentTextContent === undefined) {
-				// Start of a new text block
-				currentTextContentStartIndex = i - (accumulator.length - currentTextContentStartIndex - 1) // Adjust start index based on how much we've accumulated since the last block ended or the beginning
-				// If accumulator starts from 0, start index is i
-				if (contentBlocks.length === 0 && currentToolUse === undefined) {
-					currentTextContentStartIndex = accumulator.length - 1 // i
-				} else {
-					// Re-calculate based on the actual start of the current text segment
-					// Find the end of the last block
-					let lastBlockEndIndex = 0
-					if (contentBlocks.length > 0) {
-						const lastBlock = contentBlocks[contentBlocks.length - 1]
-						// Approximation: find where the accumulator matches the end of the message string representation of the last block. This is complex.
-						// Simpler: Assume text starts right after the last block ended implicitly at index i.
-						lastBlockEndIndex = i // Where the loop *was* when the last block finished processing
-						// Need a more robust way to track the end index of the *raw string* corresponding to the last block.
-						// Let's stick to the accumulator slice approach for simplicity in this version.
-						// The start index should be where the current *unmatched* text began.
-						let lastProcessedIndex = -1
-						if (contentBlocks.length > 0) {
-							// This requires knowing the raw string length of the previous block, which V1 doesn't explicitly track easily.
-							// We'll approximate based on the current accumulator and start index logic.
-							// The issue arises if a tool tag was just closed. accumulator contains everything up to i.
-							// lastBlockEndIndex should point to the character *after* the closing tag of the last block.
-						}
-						// Reset start index to the beginning of the *current* potential text block
-						currentTextContentStartIndex = accumulator.length - 1 // Start accumulating from the current character `i`
-					}
-
-					// If we just closed a tool, text starts *after* its closing tag
-					// The logic needs refinement here for accurate start index after a tool closure.
-					// Let's assume for now the start index logic inside the loop handles it via slicing.
-				}
-
-				currentTextContent = {
-					type: "text",
-					content: "", // Content will be filled by slicing accumulator
-					partial: true,
-				}
-			}
-			// Update text content based on the accumulator from its start index
-			currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trimStart() // Trim start to avoid leading space if text follows tool
-		}
-	} // End of loop
-
-	// --- Finalization after loop ---
-
-	// If a tool use was open at the end
-	if (currentToolUse) {
-		// If a parameter was open within that tool use
-		if (currentParamName) {
-			// The remaining accumulator content belongs to this partial parameter
-			currentToolUse.params[currentParamName] = accumulator.slice(currentParamValueStartIndex).trim()
-		}
-		// Add the potentially partial tool use block
-		contentBlocks.push(currentToolUse)
-	}
-	// If text content was being accumulated at the end
-	// Note: Only one of currentToolUse or currentTextContent can be defined here,
-	// as starting a tool use finalizes the preceding text block.
-	else if (currentTextContent) {
-		// Update content one last time
-		currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trim()
-		// Add the potentially partial text block only if it contains content
-		if (currentTextContent.content.length > 0) {
-			contentBlocks.push(currentTextContent)
-		}
-	}
-
-	return contentBlocks
-}
+// parseAssistantmessageV1 removed in https://github.com/cline/cline/pull/5425
 
 /**
  * @description **Version 2**

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

@@ -1,14 +1,13 @@
-import { describe, it, beforeEach, afterEach } from "mocha"
+import { HostProvider } from "@/hosts/host-provider"
+import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
+import * as diskModule from "@core/storage/disk"
 import { expect } from "chai"
+import { afterEach, beforeEach, describe, it } from "mocha"
+import * as path from "path"
 import * as sinon from "sinon"
 import * as vscode from "vscode"
-import * as path from "path"
+import type { FileMetadataEntry, TaskMetadata } from "./ContextTrackerTypes"
 import { FileContextTracker } from "./FileContextTracker"
-import * as diskModule from "@core/storage/disk"
-import type { TaskMetadata, FileMetadataEntry } from "./ContextTrackerTypes"
-import type { DiffViewProviderCreator, WebviewProviderCreator } from "@/hosts/host-provider"
-import { HostProvider } from "@/hosts/host-provider"
-import { vscodeHostBridgeClient } from "@/hosts/vscode/hostbridge/client/host-grpc-client"
 
 describe("FileContextTracker", () => {
 	let sandbox: sinon.SinonSandbox
@@ -54,13 +53,7 @@ describe("FileContextTracker", () => {
 		getTaskMetadataStub = sandbox.stub(diskModule, "getTaskMetadata").resolves(mockTaskMetadata)
 		saveTaskMetadataStub = sandbox.stub(diskModule, "saveTaskMetadata").resolves()
 
-		// Reset HostProvider before initializing to avoid "already initialized" errors
-		HostProvider.reset()
-		HostProvider.initialize(
-			((_) => {}) as WebviewProviderCreator,
-			(() => {}) as DiffViewProviderCreator,
-			vscodeHostBridgeClient,
-		)
+		setVscodeHostProviderMock()
 
 		// Create tracker instance
 		taskId = "test-task-id"

src/core/controller/account/accountLoginClicked.ts

@@ -1,8 +1,6 @@
 import { Controller } from "../index"
 import { AuthService } from "@/services/auth/AuthService"
-import { EmptyRequest, String } from "../../../shared/proto/common"
-
-const authService = AuthService.getInstance()
+import { EmptyRequest, String } from "@shared/proto/cline/common"
 
 /**
  * Handles the user clicking the login link in the UI.
@@ -13,5 +11,5 @@ const authService = AuthService.getInstance()
  * @returns The login URL as a string.
  */
 export async function accountLoginClicked(_controller: Controller, _: EmptyRequest): Promise<String> {
-	return await authService.createAuthRequest()
+	return await AuthService.getInstance().createAuthRequest()
 }

src/core/controller/account/accountLogoutClicked.ts

@@ -1,9 +1,8 @@
 import { AuthService } from "@/services/auth/AuthService"
-import { Empty } from "../../../shared/proto/common"
-import type { EmptyRequest } from "../../../shared/proto/common"
+import { Empty } from "@shared/proto/cline/common"
+import type { EmptyRequest } from "@shared/proto/cline/common"
 import type { Controller } from "../index"
 
-const authService = AuthService.getInstance()
 /**
  * Handles the account logout action
  * @param controller The controller instance
@@ -12,6 +11,6 @@ const authService = AuthService.getInstance()
  */
 export async function accountLogoutClicked(controller: Controller, _request: EmptyRequest): Promise<Empty> {
 	await controller.handleSignOut()
-	await authService.handleDeauth()
+	await AuthService.getInstance().handleDeauth()
 	return Empty.create({})
 }

src/core/controller/account/authStateChanged.ts

@@ -1,4 +1,4 @@
-import { AuthStateChangedRequest, AuthState } from "@shared/proto/account"
+import { AuthStateChangedRequest, AuthState } from "@shared/proto/cline/account"
 import type { Controller } from "../index"
 import { updateGlobalState } from "../../storage/state"
 

src/core/controller/account/getOrganizationCredits.ts

@@ -1,5 +1,5 @@
 import type { Controller } from "../index"
-import { GetOrganizationCreditsRequest, OrganizationCreditsData, OrganizationUsageTransaction } from "@shared/proto/account"
+import { GetOrganizationCreditsRequest, OrganizationCreditsData, OrganizationUsageTransaction } from "@shared/proto/cline/account"
 
 /**
  * Handles fetching all organization credits data (balance, usage, payments)
@@ -22,6 +22,11 @@ export async function getOrganizationCredits(
 			controller.accountService.fetchOrganizationUsageTransactionsRPC(request.organizationId),
 		])
 
+		// If balance call fails (returns undefined), throw an error
+		if (!balanceData) {
+			throw new Error("Failed to fetch organization credits data")
+		}
+
 		return OrganizationCreditsData.create({
 			balance: balanceData ? { currentBalance: balanceData.balance / 100 } : { currentBalance: 0 },
 			organizationId: balanceData?.organizationId || "",

src/core/controller/account/getUserCredits.ts

@@ -1,6 +1,6 @@
 import type { Controller } from "../index"
-import type { EmptyRequest } from "@shared/proto/common"
-import { UserCreditsData } from "@shared/proto/account"
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { UserCreditsData } from "@shared/proto/cline/account"
 
 /**
  * Handles fetching all user credits data (balance, usage, payments)
@@ -21,6 +21,11 @@ export async function getUserCredits(controller: Controller, request: EmptyReque
 			controller.accountService.fetchPaymentTransactionsRPC(),
 		])
 
+		// If either call fails (returns undefined), throw an error
+		if (balance === undefined) {
+			throw new Error("Failed to fetch user credits data")
+		}
+
 		return UserCreditsData.create({
 			balance: balance ? { currentBalance: balance.balance / 100 } : { currentBalance: 0 },
 			usageTransactions: usageTransactions,