v3.18.7 Release Notes

* changeset version bump

* Updating CHANGELOG.md format

* Update CHANGELOG.md for version 3.18.7

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions <github-actions@github.com>
Co-authored-by: pashpashpash <nik@cline.bot>

.changeset/gold-berries-give.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Refactor chat view into multiple modular files

.changeset/khaki-fishes-unite.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Include litellm_session_id as part of chat completion requests

.changeset/lovely-readers-design.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Add Claude Sonnet 4 and Opus 4 model in SAP AI Core provider.

.changeset/poor-years-grab.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix: Do not read auth variables from the user env when using Claude Code

.eslintrc.json

@@ -22,6 +22,7 @@
 		"react-hooks/exhaustive-deps": "off",
 		"eslint-rules/no-protobuf-object-literals": "error",
 		"eslint-rules/no-grpc-client-object-literals": "error",
+		"eslint-rules/no-direct-vscode-api": "warn",
 		"no-restricted-syntax": [
 			"error",
 			{

.vscode/launch.json

@@ -23,19 +23,20 @@
 			"request": "launch",
 			"runtimeExecutable": "${execPath}",
 			"args": [
+				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
-				"--sync",
-				"off",
+				"--sync=off",
 				"--disable-extensions",
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],
 			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
-			"preLaunchTask": "clean-sandbox",
+			"preLaunchTask": "clean-tmp-user",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
+				"TEMP_PROFILE": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
 			}
 		},

.vscode/tasks.json

@@ -233,10 +233,10 @@
 			"type": "shell"
 		},
 		{
-			"label": "clean-sandbox",
+			"label": "clean-tmp-user",
 			"type": "shell",
 			"dependsOn": ["watch"],
-			"command": "rm -rf .vscode-dev"
+			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -2,8 +2,10 @@
 .vscode/**
 .vscode-test/**
 out/**
+dist-standalone/**
 node_modules/**
 src/**
+standalone/**
 .gitignore
 .yarnrc
 esbuild.js
@@ -13,6 +15,7 @@ vsc-extension-quickstart.md
 **/*.map
 **/*.ts
 **/.vscode-test.*
+eslint-rules/**
 
 # Custom
 demo.gif
@@ -32,6 +35,7 @@ webview-ui/node_modules/**
 
 # Ignore docs
 docs/**
+old_docs/**
 
 # Fix issue where codicons don't get packaged (https://github.com/microsoft/vscode-extension-samples/issues/692)
 !node_modules/@vscode/codicons/dist/codicon.css

CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [3.18.7]
+
+-   Remove promotional "free" messaging for Grok 3 model in UI
+
+## [3.18.6]
+
+-   Update request header to include `"ai-client-type": "Cline"` to SAP Api Provider
+-   Add organization organization accounts
+
+## [3.18.5]
+
+-   Fix Plan/Act mode persistence across sessions and multi-workspace conflicts
+-   Improve provider switching performance by 18x (from 550ms to 30ms) with batched storage operations
+-   Improve SAP AI Core provider model organization and fix exception handling (Thanks @schardosin!)
+
+## [3.18.4]
+
+-   Add support for Gemini 2.5 Pro and Flash to SAP AI Core Provider
+-   Fix logging in with Cline account not getting past welcome screen
+
+## [3.18.3]
+
+-   Improve Cerebras Qwen model performance by removing thinking tokens from model input (Thanks @kevint-cerebras!)
+-   Improve Claude Code provider with better error handling and performance optimizations (Thanks @BarreiroT!)
+
+## [3.18.2]
+
+-   Fix issue where terminal output would not be captured if shell integration fails by falling back to capturing the terminal content.
+-   Add confirmation popup when deleting tasks
+-   Add support for Claude Sonnet 4 and Opus 4 model in SAP AI Core provider (Thanks @lizzzcai!)
+-   Add support for `litellm_session_id` to group requests in a single session (Thanks @jorgegarciarey!)
+-   Add "Thinking Budget" customization for Claude Code (Thanks @BarreiroT!)
+-   Fix issue where the extension would use the user's environment variables for authentication when using Claude Code (Thanks @BarreiroT!)
+
 ## [3.18.1]
 
 -   Add support for Claude 4 Sonnet in SAP AI Core provider (Thanks @GTxx!)

docs/docs.json

@@ -170,6 +170,10 @@
 					"running-models-locally/ollama"
 				]
 			},
+			{
+				"group": "Troubleshooting",
+				"pages": ["troubleshooting/terminal-quick-fixes", "troubleshooting/terminal-integration-guide"]
+			},
 			{
 				"group": "More Info",
 				"pages": ["more-info/telemetry"]

docs/features/at-mentions/terminal-mentions.mdx

@@ -58,3 +58,16 @@ When you use the terminal mention in your message, here's what happens behind th
 6. The AI can now "see" the complete terminal output with all formatting preserved
 
 This process happens automatically whenever you use the terminal mention, giving the AI access to your command results, error messages, and other terminal output without you having to copy it manually.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal mentions or terminal integration in general (such as "Shell Integration Unavailable" or commands not showing output), please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+Common issues include:
+
+-   Terminal mentions not capturing output
+-   "Shell Integration Unavailable" messages in Cline chat
+-   Commands executing but output not visible to Cline
+-   Terminal integration working inconsistently
+
+The troubleshooting guide provides platform-specific solutions and detailed configuration steps to resolve these issues.

docs/features/commands-and-shortcuts/terminal-integration.mdx

@@ -74,8 +74,25 @@ This approach ensures that all terminal output, including colors and formatting,
 
 -   **Select specific output when needed**: By default, the integration captures all terminal content, but you can also select specific lines before right-clicking to focus on just the relevant output.
 
--   **Combine with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
+-   **Combine terminal outputs with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
 
--   **Use for build and test output**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
+-   **Contextualize build & test outputs with the terminal**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
 
 Next time you're staring at a cryptic error message in your terminal, try using Cline's terminal integration instead of copying and pasting. You'll get more accurate help because Cline can see the complete terminal context with proper formatting.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal integration, such as "Shell Integration Unavailable" or commands not showing output, please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+The troubleshooting guide covers:
+
+-   Common terminal integration issues and quick fixes
+-   Platform-specific solutions for Windows, macOS, and Linux
+-   Shell-specific configurations for zsh, bash, PowerShell, and more
+-   Advanced debugging techniques
+-   Terminal settings optimization
+
+<Tip>
+	**Quick Fix**: Most terminal issues can be resolved by switching to bash in the Cline settings and increasing the shell
+	integration timeout to 10 seconds.
+</Tip>

docs/troubleshooting/terminal-integration-guide.mdx

@@ -0,0 +1,399 @@
+---
+title: "Terminal Integration Troubleshooting Guide"
+sidebarTitle: "Terminal Troubleshooting"
+description: "Complete guide to resolving terminal integration issues in Cline"
+---
+
+This guide helps you resolve terminal integration issues in Cline. Terminal integration is crucial for Cline to execute commands and read their output, enabling it to understand errors, test results, and command responses.
+
+<Tip>
+	If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings, under "Terminal Settings"
+
+    This resolves most terminal integration problems.
+
+</Tip>
+
+## Quick Diagnosis Flowchart
+
+Follow this flowchart to quickly identify your issue:
+
+```mermaid
+graph TD
+    A[Terminal Issue] --> B{Can Cline execute commands?}
+    B -->|No| C[Shell Integration Unavailable]
+    B -->|Yes| D{Can Cline see the output?}
+    D -->|No| E[Output Capture Failed]
+    D -->|Yes| F{Is the output corrupted?}
+    F -->|Yes| G[Character Filtering Issue]
+    F -->|No| H{Does the command hang?}
+    H -->|Yes| I[Long-Running Command Issue]
+    H -->|No| J[Check Terminal Settings]
+
+    C --> K[Try Solution 1]
+    E --> L[Try Solution 2]
+    G --> M[Try Solution 3]
+    I --> N[Try Solution 4]
+
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style K fill:#9f9,stroke:#333,stroke-width:2px
+    style L fill:#9f9,stroke:#333,stroke-width:2px
+    style M fill:#9f9,stroke:#333,stroke-width:2px
+    style N fill:#9f9,stroke:#333,stroke-width:2px
+```
+
+## Common Issues & Quick Solutions
+
+### 1. Shell Integration Unavailable
+
+**Symptoms:**
+
+-   Message: "Shell Integration Unavailable"
+-   Commands execute but Cline can't read output
+-   Terminal works fine manually but not with Cline
+
+**Quick Solutions:**
+
+#### macOS
+
+-   **Switch to bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Disable Oh-My-Zsh temporarily**:
+
+    1. If using zsh, enter `mv ~/.zshrc ~/.zshrc.backup` into the terminal
+    2. Restart VSCode
+
+-   **Set environment**:
+    1.a For Zsh users, use one of the following Zsh commands to edit your shell profile:
+
+          - `nano ~/.zshrc`
+          - `vim ~/.zshrc`
+          - `code ~/.zshrc`
+
+    1.b For Bash users
+
+          - nano ~/.bash_profile
+
+    2. Add the following to your shell config: `export TERM=xterm-256color`
+    3. Save your configuration
+
+#### Windows
+
+-   **Use PowerShell 7**
+
+    1. Install from Microsoft Store
+    2. Go to Cline Settings
+    3. Left-Click the **"Terminal Settings"** tab
+    4. Navigate to **"Default Terminal Profile"** and select **"PowerShell 7"** from the drop-down menu
+
+-   **Disable Windows ConPTY**
+
+    1. Navigate to your VSCode Settings
+    2. Enter "Integrated: Windows Enable Conpty" into the Settings searchbar
+    3. Uncheck the option
+
+-   **Try Command Prompt**
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"Command Prompt"** from the drop-down menu
+
+#### Linux
+
+-   **Use bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Check permissions**
+
+    1. Ensure VSCode has terminal access permissions
+
+-   **Disable custom prompts**
+    1. Comment out prompt customizations in `.bashrc`
+
+### 2. Command Output Not Visible
+
+**Symptoms:**
+
+-   Cline states in chat: "[Command is running but producing no output]"
+-   Commands complete but Cline doesn't see results
+-   Commands work sometimes but not consistently
+
+**Solutions:**
+
+-   **Increase Shell Integration Timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable Terminal Reuse**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+-   **Check for interfering extensions**
+    1. Disable other terminal-related VSCode extensions
+
+### 3. Character Filtering Issues
+
+**Symptoms:**
+
+-   Commas missing from output (JSON appears corrupted)
+-   Special characters stripped from terminal output
+-   Syntax errors that don't appear when running manually
+
+**Solution:**
+This is a known bug in output processing. Workarounds:
+
+-   Recommend AI to use file output instead
+    1. Tell Cline in chat or Cline rules, to use `command > output.txt` before reading the file/s
+
+<Tip>
+	This family of issues is only partially solved in the latest Cline versions, so if you still face this, create a GitHub issue
+	if it is a persistent problem.
+</Tip>
+
+### 4. Long-Running Commands & Progress Bars
+
+**Symptoms:**
+
+-   Docker builds never complete in Cline
+-   Progress bars consume thousands of tokens
+-   The Cline button "Proceed while running" doesn't work properly in chat
+
+<Tip>
+	This family of issues has been solved in latest Cline versions but if you still face any issues, then create a GitHub issue
+	for this.
+</Tip>
+
+## Terminal Settings Explained
+
+Access these in Cline by clicking the settings icon, and navigating to the "Terminal Settings" section:
+
+### Default Terminal Profile
+
+-   **What it does**: Selects which shell Cline uses for commands
+-   **When to change**: If experiencing shell integration issues with your default shell
+-   **Recommended**: - macOS: bash (if zsh has issues) - Windows: PowerShell 7 - Linux: bash
+
+### Shell Integration Timeout
+
+-   **What it does**: How long Cline waits for the terminal to be ready
+-   **Default**: 4 seconds
+-   **When to increase**:
+    -   Slow shell startup (heavy .zshrc/.bashrc)
+    -   WSL environments
+    -   SSH connections
+-   **Recommended**: - Start with 10 seconds if having issues
+
+### Enable Aggressive Terminal Reuse
+
+-   **What it does**: Reuses existing terminals even if not in the correct directory
+-   **When to disable**:
+    -   Commands execute in wrong directory
+    -   Virtual environment issues
+    -   Terminal state corruption
+-   **Trade-off**: - Disabling creates more terminals but ensures clean state
+
+### Terminal Output Line Limit
+
+-   **What it does**: Limits how many lines Cline reads from terminal output
+-   **Default**: 500 lines
+-   **When to adjust**:
+    -   Increase for verbose build outputs
+    -   Decrease if hitting token limits
+    -   Set to 100 for commands with progress bars
+
+## Platform-Specific Solutions
+
+### macOS Issues
+
+#### Oh-My-Zsh Conflicts
+
+Oh-My-Zsh often interferes with shell integration. Solutions:
+
+1. Create a minimal `.zshrc` for VSCode:
+    ```bash
+    # ~/.zshrc-vscode
+    export TERM=xterm-256color
+    export PAGER=cat
+    # Minimal PATH and environment setup
+    ```
+2. Configure VSCode to use it:
+    ```json
+    {
+    	"terminal.integrated.env.osx": {
+    		"ZDOTDIR": "~/.zshrc-vscode"
+    	}
+    }
+    ```
+
+#### macOS 15+ Issues
+
+Recent macOS versions have stricter terminal permissions:
+
+1. System Preferences → Privacy & Security → Developer Tools
+2. Add Visual Studio Code
+3. Restart VSCode completely
+
+### Windows Issues
+
+#### PowerShell Execution Policy
+
+If commands fail silently:
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+#### WSL Integration
+
+For WSL issues:
+
+1. Use WSL extension for VSCode
+2. Open folder in WSL: `code .` from WSL terminal
+3. Select "WSL Bash" as terminal profile in Cline
+
+#### Path Issues
+
+Windows path problems:
+
+1. Use forward slashes in Cline: `C:/Users/...`
+2. Quote paths with spaces: `"C:/Program Files/..."`
+3. Avoid `~` - use full paths
+
+### Linux/SSH/Container Issues
+
+#### SSH Connections
+
+For remote development:
+
+1. Install Cline on the remote machine, not locally
+2. Use SSH extension's integrated terminal
+3. Increase timeout to 15+ seconds
+
+#### Docker Containers
+
+When developing in containers:
+
+1. Install Cline in the container
+2. Use Dev Containers extension
+3. Ensure shell integration scripts are available
+
+## Shell-Specific Fixes
+
+### Zsh
+
+```bash
+# Add to ~/.zshrc
+export TERM=xterm-256color
+export PAGER=cat
+# Disable fancy prompts for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1="%n@%m %1~ %# "
+fi
+```
+
+### Bash
+
+```bash
+# Add to ~/.bashrc
+export TERM=xterm-256color
+export PAGER=cat
+# Simple prompt for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1='\u@\h:\w\$ '
+fi
+```
+
+### Fish
+
+```fish
+# Add to ~/.config/fish/config.fish
+set -x TERM xterm-256color
+set -x PAGER cat
+# Disable fancy features in VSCode
+if test "$TERM_PROGRAM" = "vscode"
+    function fish_prompt
+        echo (whoami)'@'(hostname)':'(pwd)'> '
+    end
+end
+```
+
+### PowerShell
+
+```powershell
+# Add to $PROFILE
+$env:PAGER = "cat"
+# Disable progress bars
+$ProgressPreference = 'SilentlyContinue'
+```
+
+## Advanced Troubleshooting
+
+### Debug Mode
+
+Enable terminal debugging to see what's happening:
+
+1. Open VSCode Command Palette (Cmd/Ctrl+Shift+P)
+2. Run: "Developer: Set Log Level..."
+3. Choose "Trace"
+4. Check Output panel → "Cline" for terminal logs
+
+### Manual Shell Integration Test
+
+Test if shell integration works at all:
+
+```bash
+# In VSCode terminal
+echo $TERM_PROGRAM  # Should show "vscode"
+echo $VSCODE_SHELL_INTEGRATION  # Should be "1"
+```
+
+## FAQ
+
+### Why does Cline create so many terminals?
+
+When shell integration fails, Cline can't reuse terminals safely (they might be running long processes). Enable shell integration or adjust the terminal reuse setting.
+
+### Can I use my custom shell (nushell, xonsh, etc.)?
+
+Cline officially supports bash, zsh, fish, and PowerShell. Custom shells may work but aren't guaranteed. Use bash as a fallback.
+
+### Why do some commands work but others don't?
+
+Commands that use interactive features (pagers, progress bars, curses) often fail. Set `PAGER=cat` and use non-interactive flags.
+
+### How do I know if shell integration is working?
+
+Working integration shows command output in Cline's chat. Failed integration shows "Shell Integration Unavailable" or "[Command is running but producing no output]".
+
+## Still Having Issues?
+
+If you've tried everything:
+
+1. **Collect Debug Info**:
+
+    ```bash
+    echo "Shell: $SHELL"
+    echo "Term: $TERM"
+    echo "VSCode: $TERM_PROGRAM"
+    which bash
+    bash --version
+    ```
+
+2. **Report the Issue**:
+    - Use `/reportbug` in Cline github issues
+    - Include your debug info
+    - Mention which solutions you tried
+
+<Tip>
+	Remember: Most terminal issues are resolved by switching to bash and increasing the timeout. Start there before trying complex
+	solutions.
+</Tip>

docs/troubleshooting/terminal-quick-fixes.mdx

@@ -0,0 +1,51 @@
+---
+title: "Terminal Quick Fixes"
+sidebarTitle: "Terminal Quick Fixes"
+description: "Quick solutions for common terminal issues"
+---
+
+**Here is a list of common fixes, starting with the most applicable:**
+
+-   **Switch to bash** (solves most instances)
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down
+
+-   **Increase timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable terminal reuse**
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+## Platform-Specific Fixes
+
+### macOS + Oh-My-Zsh
+
+```bash
+# Create minimal config for VSCode
+echo 'export TERM=xterm-256color' > ~/.zshrc-vscode
+echo 'export PAGER=cat' >> ~/.zshrc-vscode
+```
+
+### Windows PowerShell
+
+```powershell
+# Run as Administrator
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+### WSL
+
+-   Open folder from WSL: `code .`
+-   Select **"WSL Bash"** in Cline settings, under **"Terminal Settings"**
+-   Increase **"Shell integration timeout (seconds)"** to **15**
+
+## Full Guide
+
+For detailed troubleshooting, see the [Complete Terminal Troubleshooting Guide](/troubleshooting/terminal-integration-guide).

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

@@ -0,0 +1,123 @@
+const { RuleTester: DirectApiRuleTester } = require("eslint")
+const noDirectVscodeApiRule = require("../no-direct-vscode-api")
+
+const directApiRuleTester = new DirectApiRuleTester({
+	parser: require.resolve("@typescript-eslint/parser"),
+	parserOptions: {
+		ecmaVersion: 2020,
+		sourceType: "module",
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+})
+
+directApiRuleTester.run("no-direct-vscode-api", noDirectVscodeApiRule, {
+	valid: [
+		// Should allow vscode.postMessage in grpc-client-base.ts
+		{
+			code: `vscode.postMessage({ type: "grpc_request", data: {} })`,
+			filename: "grpc-client-base.ts",
+		},
+		{
+			code: `vscode.postMessage({ type: "grpc_request_cancel" })`,
+			filename: "/path/to/grpc-client-base.ts",
+		},
+		// Should allow in exception directories
+		{
+			code: `vscode.workspace.workspaceFolders`,
+			filename: "/src/hosts/vscode/host-bridge.ts",
+		},
+		{
+			code: `vscode.workspace.fs.stat(uri)`,
+			filename: "/standalone/runtime-files/helpers.ts",
+		},
+		// Should allow other vscode API calls
+		{
+			code: `vscode.window.showInformationMessage("Hello")`,
+			filename: "test.ts",
+		},
+		// Should allow postMessage calls on other objects
+		{
+			code: `window.postMessage({ type: "test" }, "*")`,
+			filename: "test.ts",
+		},
+		// Should allow variables named vscode but not calling postMessage
+		{
+			code: `const vscode = { other: "method" }; vscode.other()`,
+			filename: "test.ts",
+		},
+	],
+	invalid: [
+		// Should disallow vscode.postMessage in regular files
+		{
+			code: `vscode.postMessage({ type: "test", data: {} })`,
+			filename: "test.ts",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow vscode.postMessage in components
+		{
+			code: `vscode.postMessage({ type: "apiConfiguration", apiConfiguration })`,
+			filename: "ApiOptions.tsx",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// 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",
+				},
+			],
+		},
+		// Should disallow method calls for disallowed APIs
+		{
+			code: `const relativePath = vscode.workspace.asRelativePath(filePath);`,
+			filename: "path-utils.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+		// Should disallow nested property access
+		{
+			code: `const stats = await vscode.workspace.fs.stat(uri);`,
+			filename: "file-utils.ts",
+			errors: [
+				{
+					messageId: "useFsUtils",
+				},
+			],
+		},
+		// Should disallow getting a workspace folder
+		{
+			code: `const folder = vscode.workspace.getWorkspaceFolder(uri);`,
+			filename: "path-helper.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+	],
+})

eslint-rules/__tests__/no-vscode-postmessage.test.ts

@@ -1,74 +0,0 @@
-const { RuleTester: VscodeRuleTester } = require("eslint")
-const vscodePostmessageRule = require("../no-vscode-postmessage")
-
-const vscodeRuleTester = new VscodeRuleTester({
-	parser: require.resolve("@typescript-eslint/parser"),
-	parserOptions: {
-		ecmaVersion: 2020,
-		sourceType: "module",
-		ecmaFeatures: {
-			jsx: true,
-		},
-	},
-})
-
-vscodeRuleTester.run("no-vscode-postmessage", vscodePostmessageRule, {
-	valid: [
-		// Should allow vscode.postMessage in grpc-client-base.ts
-		{
-			code: `vscode.postMessage({ type: "grpc_request", data: {} })`,
-			filename: "grpc-client-base.ts",
-		},
-		{
-			code: `vscode.postMessage({ type: "grpc_request_cancel" })`,
-			filename: "/path/to/grpc-client-base.ts",
-		},
-		// Should allow other vscode API calls
-		{
-			code: `vscode.window.showInformationMessage("Hello")`,
-			filename: "test.ts",
-		},
-		// Should allow postMessage calls on other objects
-		{
-			code: `window.postMessage({ type: "test" }, "*")`,
-			filename: "test.ts",
-		},
-		// Should allow variables named vscode but not calling postMessage
-		{
-			code: `const vscode = { other: "method" }; vscode.other()`,
-			filename: "test.ts",
-		},
-	],
-	invalid: [
-		// Should ban vscode.postMessage in regular files
-		{
-			code: `vscode.postMessage({ type: "test", data: {} })`,
-			filename: "test.ts",
-			errors: [
-				{
-					messageId: "useGrpcClient",
-				},
-			],
-		},
-		// Should ban vscode.postMessage in components
-		{
-			code: `vscode.postMessage({ type: "apiConfiguration", apiConfiguration })`,
-			filename: "ApiOptions.tsx",
-			errors: [
-				{
-					messageId: "useGrpcClient",
-				},
-			],
-		},
-		// Should ban vscode.postMessage in test files
-		{
-			code: `vscode.postMessage({ type: "newTask", text: message.text })`,
-			filename: "test.test.ts",
-			errors: [
-				{
-					messageId: "useGrpcClient",
-				},
-			],
-		},
-	],
-})

eslint-rules/index.js

@@ -1,13 +1,13 @@
 // eslint-rules/index.js
 const noProtobufObjectLiterals = require("./no-protobuf-object-literals")
 const noGrpcClientObjectLiterals = require("./no-grpc-client-object-literals")
-const noVscodePostmessage = require("./no-vscode-postmessage")
+const noDirectVscodeApi = require("./no-direct-vscode-api")
 
 module.exports = {
 	rules: {
 		"no-protobuf-object-literals": noProtobufObjectLiterals,
 		"no-grpc-client-object-literals": noGrpcClientObjectLiterals,
-		"no-vscode-postmessage": noVscodePostmessage,
+		"no-direct-vscode-api": noDirectVscodeApi,
 	},
 	configs: {
 		recommended: {
@@ -15,7 +15,7 @@ module.exports = {
 			rules: {
 				"local/no-protobuf-object-literals": "error",
 				"local/no-grpc-client-object-literals": "error",
-				"local/no-vscode-postmessage": "error",
+				"local/no-direct-vscode-api": "warn",
 			},
 		},
 	},

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

@@ -0,0 +1,164 @@
+const { ESLintUtils } = require("@typescript-eslint/utils")
+const path = require("path")
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
+
+// Configuration of disallowed VSCode APIs and their recommended alternatives
+const disallowedApis = {
+	"vscode.postMessage": {
+		messageId: "useGrpcClient",
+	},
+	"vscode.workspace.fs.stat": {
+		messageId: "useFsUtils",
+	},
+	"vscode.workspace.workspaceFolders": {
+		messageId: "useHostBridge",
+	},
+	"vscode.workspace.asRelativePath": {
+		messageId: "usePathUtils",
+	},
+	"vscode.workspace.getWorkspaceFolder": {
+		messageId: "usePathUtils",
+	},
+}
+
+module.exports = createRule({
+	name: "no-direct-vscode-api",
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow direct VSCode API usage in favor of Cline's abstraction layers, except in src/hosts/vscode and standalone/runtime-files directories",
+			recommended: "error",
+		},
+		messages: {
+			useGrpcClient:
+				"Use gRPC service clients instead of vscode.postMessage().\n" +
+				"Example: AccountServiceClient.methodName(RequestType.create({...})) instead of vscode.postMessage({type: '...'}).\n" +
+				"Found: {{code}}",
+			useFsUtils:
+				"Use utilities in @/utils/fs instead of vscode.workspace.fs.stat.\n" +
+				"Example: import { isDirectory } from '@/utils/fs' or use the file system methods from the host bridge provider.\n" +
+				"Found: {{code}}",
+			useHostBridge:
+				"Use getHostBridgeProvider().workspaceClient.getWorkspacePaths({}) instead of vscode.workspace.workspaceFolders.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			usePathUtils:
+				"Use path utilities from @/utils/path instead of direct VSCode workspace path methods.\n" +
+				"This provides consistent path handling across different environments.\n" +
+				"Found: {{code}}",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+
+	create(context) {
+		// Check if current file is in an exception directory or is grpc-client-base.ts
+		const filename = context.filename
+		const isGrpcClientBase = path.basename(filename) === "grpc-client-base.ts"
+
+		// Skip checking files in src/hosts/vscode or standalone/runtime-files
+		const isExceptionDirectory = filename.includes("/src/hosts/vscode/") || filename.includes("/standalone/runtime-files/")
+
+		// Pattern for checking memberExpressions like vscode.workspace.fs.stat
+		function checkMemberExpression(node) {
+			// Skip if this file is in an exception directory or is grpc-client-base.ts
+			if (isGrpcClientBase || isExceptionDirectory) {
+				return
+			}
+
+			// For handling nested properties like vscode.workspace.fs.stat
+			function getFullPropertyPath(node) {
+				if (node.type !== "MemberExpression") {
+					return node.name || ""
+				}
+
+				const objectPart = getFullPropertyPath(node.object)
+				const propertyPart = node.property.name || ""
+
+				return objectPart ? `${objectPart}.${propertyPart}` : propertyPart
+			}
+
+			// Check if the expression matches one of our disallowed patterns
+			if (node.object && node.object.type === "Identifier" && node.object.name === "vscode") {
+				const fullPath = `vscode.${node.property.name}`
+				checkDisallowedApi(fullPath, node)
+			}
+			// Handle nested expressions like vscode.workspace.fs.stat
+			else if (node.object && node.object.type === "MemberExpression") {
+				const fullPath = getFullPropertyPath(node)
+
+				// Only proceed if it starts with vscode
+				if (fullPath.startsWith("vscode.")) {
+					checkDisallowedApi(fullPath, node)
+				}
+			}
+		}
+
+		// Check if an expression matches a disallowed API and report if it does
+		function checkDisallowedApi(expressionPath, node) {
+			// Check exact matches
+			if (disallowedApis[expressionPath]) {
+				reportViolation(expressionPath, node)
+				return
+			}
+
+			// Check prefix matches (for nested properties)
+			for (const disallowedApi in disallowedApis) {
+				// For direct property access like vscode.workspace.workspaceFolders
+				if (expressionPath === disallowedApi) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+
+				// For method calls like vscode.workspace.asRelativePath(...)
+				if (expressionPath.startsWith(`${disallowedApi}.`) || expressionPath.startsWith(`${disallowedApi}(`)) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+			}
+		}
+
+		// Report a violation with the appropriate message
+		function reportViolation(disallowedApi, node) {
+			const sourceCode = context.sourceCode
+			const config = disallowedApis[disallowedApi]
+
+			// For method calls, get the whole call expression
+			let reportNode = node
+			let parentNode = sourceCode.getAncestors(node).pop()
+			if (parentNode && parentNode.type === "CallExpression" && parentNode.callee === node) {
+				reportNode = parentNode
+			}
+
+			const callText = sourceCode.getText(reportNode).trim()
+
+			context.report({
+				node: reportNode,
+				messageId: config.messageId,
+				data: {
+					code: callText,
+				},
+			})
+		}
+
+		return {
+			// Detect basic member expressions (e.g., vscode.postMessage)
+			MemberExpression(node) {
+				checkMemberExpression(node)
+			},
+
+			// Detect property access through destructuring
+			VariableDeclarator(node) {
+				// Skip if this file is in an exception directory or is grpc-client-base.ts
+				if (isGrpcClientBase || isExceptionDirectory) {
+					return
+				}
+
+				// Destructuring pattern checks removed as developers don't use the API this way
+				// They always use direct imports: import * as vscode from "vscode" and direct access: vscode.thing.foo
+			},
+		}
+	},
+})

eslint-rules/no-vscode-postmessage.js

@@ -1,61 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils")
-const path = require("path")
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
-
-module.exports = createRule({
-	name: "no-vscode-postmessage",
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Ban vscode.postMessage() calls in favor of gRPC service clients, except in grpc-client-base.ts",
-			recommended: "error",
-		},
-		messages: {
-			useGrpcClient:
-				"Use gRPC service clients instead of vscode.postMessage().\n" +
-				"Example: AccountServiceClient.methodName(RequestType.create({...})) instead of vscode.postMessage({type: '...'}).\n" +
-				"Found: {{code}}",
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-
-	create(context) {
-		// Check if current file is grpc-client-base.ts (exception case)
-		const filename = context.filename
-		const isGrpcClientBase = path.basename(filename) === "grpc-client-base.ts"
-
-		return {
-			// Detect vscode.postMessage calls
-			"CallExpression[callee.type='MemberExpression']"(node) {
-				// Skip if this is grpc-client-base.ts
-				if (isGrpcClientBase) {
-					return
-				}
-
-				const callee = node.callee
-
-				// Check for vscode.postMessage pattern
-				if (
-					callee.object &&
-					callee.object.type === "Identifier" &&
-					callee.object.name === "vscode" &&
-					callee.property &&
-					callee.property.name === "postMessage"
-				) {
-					const sourceCode = context.sourceCode
-					const callText = sourceCode.getText(node).trim()
-
-					context.report({
-						node,
-						messageId: "useGrpcClient",
-						data: {
-							code: callText,
-						},
-					})
-				}
-			},
-		}
-	},
-})

evals/cli/src/commands/runDiffEval.ts

@@ -6,6 +6,7 @@ interface RunDiffEvalOptions {
 	modelIds: string
 	systemPromptName: string
 	validAttemptsPerCase: number
+	maxAttemptsPerCase?: number
 	parsingFunction: string
 	diffEditFunction: string
 	thinkingBudget: number
@@ -71,6 +72,10 @@ export async function runDiffEvalHandler(options: RunDiffEvalOptions) {
 		args.push("--verbose")
 	}
 
+	if (options.maxAttemptsPerCase) {
+		args.push("--max-attempts-per-case", String(options.maxAttemptsPerCase))
+	}
+
 	if (options.maxCases) {
 		args.push("--max-cases", String(options.maxCases))
 	}

evals/cli/src/index.ts

@@ -87,6 +87,7 @@ program
 	.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 	.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 	.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+	.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 	.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 	.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 	.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
@@ -102,6 +103,7 @@ program
 			const fullOptions = {
 				...options,
 				validAttemptsPerCase: parseInt(options.validAttemptsPerCase, 10),
+				maxAttemptsPerCase: options.maxAttemptsPerCase ? parseInt(options.maxAttemptsPerCase, 10) : undefined,
 				thinkingBudget: parseInt(options.thinkingBudget, 10),
 				maxCases: options.maxCases ? parseInt(options.maxCases, 10) : undefined,
 			}

evals/diff-edits/ClineWrapper.ts

@@ -30,6 +30,7 @@ const diffEditingFunctions: Record<string, ConstructNewFileContentFn> = {
 }
 
 import { TestInput, TestResult, ExtractedToolCall } from "./types"
+import { log } from "./helpers"
 export { TestInput, TestResult, ExtractedToolCall }
 
 interface StreamResult {
@@ -284,21 +285,21 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 		}
 
 		// check that we are editing the correct file path
-		console.log(`Expected file path: "${originalFilePath}"`);
-		console.log(`Actual file path used: "${diffToolPath}"`);
+		log(input.isVerbose, `Expected file path: "${originalFilePath}"`)
+		log(input.isVerbose, `Actual file path used: "${diffToolPath}"`)
 		if (diffToolPath !== originalFilePath) {
-			console.log(`❌ File path mismatch detected!`);
+			log(input.isVerbose, `❌ File path mismatch detected!`)
 			// Enhanced logging:
 			if (streamResult?.assistantMessage) {
-				console.log(`   Full model output (assistantMessage):`);
-				console.log(`   -----------------------------------------`);
-				console.log(`   ${streamResult.assistantMessage}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Full model output (assistantMessage):`)
+				log(input.isVerbose, `   -----------------------------------------`)
+				log(input.isVerbose, `   ${streamResult.assistantMessage}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			if (toolCall) {
-				console.log(`   Parsed tool call that caused mismatch:`);
-				console.log(`   ${JSON.stringify(toolCall, null, 2)}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Parsed tool call that caused mismatch:`)
+				log(input.isVerbose, `   ${JSON.stringify(toolCall, null, 2)}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			return {
 				success: false,
@@ -321,7 +322,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 			// If it's just a string, diffSuccess stays true and replacementData stays undefined
 		} catch (error: any) {
 			diffSuccess = false
-			console.log("ERROR:",error)
+			log(input.isVerbose, `ERROR: ${error}`)
 		}
 
 		return {

evals/diff-edits/TestRunner.ts

@@ -7,7 +7,7 @@ import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./d
 import { constructNewFileContent as constructNewFileContentV3 } from "../../src/core/assistant-message/diff"
 import { basicSystemPrompt } from "./prompts/basicSystemPrompt-06-06-25"
 import { claude4SystemPrompt } from "./prompts/claude4SystemPrompt-06-06-25"
-import { formatResponse } from "./helpers"
+import { formatResponse, log } from "./helpers"
 import { Anthropic } from "@anthropic-ai/sdk"
 import * as fs from "fs"
 import * as path from "path"
@@ -40,12 +40,6 @@ const encoding = get_encoding("cl100k_base");
 
 let openRouterModelDataGlobal: Record<string, EvalOpenRouterModelInfo> = {}; // Global to store fetched data
 
-function log(isVerbose: boolean, message: string) {
-	if (isVerbose) {
-		console.log(message)
-	}
-}
-
 const systemPromptGeneratorLookup: Record<string, ConstructSystemPromptFn> = {
 	basicSystemPrompt: basicSystemPrompt,
 	claude4SystemPrompt: claude4SystemPrompt,
@@ -641,6 +635,7 @@ class NodeTestRunner {
 			thinkingBudgetTokens: testConfig.thinking_tokens_budget,
 			originalDiffEditToolCallMessage: testConfig.replay ? testCase.original_diff_edit_tool_call_message : undefined,
 			diffApplyFile: testConfig.diff_apply_file,
+			isVerbose: isVerbose,
 		}
 
 		if (isVerbose) {
@@ -807,8 +802,8 @@ class NodeTestRunner {
 					log(isVerbose, `Warning: Failed to store result in database: ${error}`);
 				}
 				
-				// Safety check to prevent infinite loops - limit to 10 attempts per valid attempt requested
-				if (totalAttempts >= testConfig.number_of_runs * 10) {
+				// Safety check to prevent infinite loops - use configurable max attempts limit
+				if (totalAttempts >= testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts (${totalAttempts}) for test case ${testCase.test_id}. Only got ${validAttempts}/${testConfig.number_of_runs} valid attempts.`);
 					break;
 				}
@@ -927,6 +922,7 @@ async function main() {
 		.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 		.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 		.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+		.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 		.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 		.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 		.option("--diff-edit-function <name>", "The diff editing function to use", "diff-06-25-25")
@@ -957,6 +953,11 @@ async function main() {
 	}
 
 	const validAttemptsPerCase = parseInt(options.validAttemptsPerCase, 10);
+	
+	// Compute dynamic default for max attempts: 10x valid attempts if not specified
+	const maxAttemptsPerCase = options.maxAttemptsPerCase 
+		? parseInt(options.maxAttemptsPerCase, 10)
+		: validAttemptsPerCase * 10;
 
 	const runner = new NodeTestRunner(options.replay || !!options.replayRunId)
 
@@ -1062,6 +1063,7 @@ async function main() {
 					model_id: modelId,
 					system_prompt_name: options.systemPromptName,
 					number_of_runs: validAttemptsPerCase,
+					max_attempts_per_case: maxAttemptsPerCase,
 					parsing_function: options.parsingFunction,
 					diff_edit_function: options.diffEditFunction,
 					thinking_tokens_budget: parseInt(options.thinkingBudget, 10),
@@ -1129,7 +1131,7 @@ async function main() {
 
 			remainingTasks = remainingTasks.filter(task => {
 				const taskId = `${task.modelId}-${task.testCase.test_id}`;
-				if (taskStates[taskId].total >= validAttemptsPerCase * 10) {
+				if (taskStates[taskId].total >= task.testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts for ${task.testCase.test_id} with ${task.modelId}.`);
 					return false;
 				}

evals/diff-edits/diff-apply/diff-06-26-25.ts

@@ -492,6 +492,12 @@ async function constructNewFileContentV1(diffContent: string, originalContent: s
 		if (isReplaceBlockEnd(line)) {
 			// Finished one replace block
 
+			if (searchMatchIndex === -1) {
+				throw new Error(
+					`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`,
+				)
+			}
+
 			// Store this replacement
 			replacements.push({
 				start: searchMatchIndex,

evals/diff-edits/helpers.ts

@@ -23,3 +23,9 @@ export const formatResponse = {
 		return formatImagesIntoBlocks(images)
 	},
 }
+
+export function log(isVerbose: boolean, message: string) {
+	if (isVerbose) {
+		console.log(message)
+	}
+}

evals/diff-edits/types.ts

@@ -29,6 +29,7 @@ export interface TestConfig {
 	model_id: string
 	system_prompt_name: string
 	number_of_runs: number
+	max_attempts_per_case: number
 	parsing_function: string
 	diff_edit_function: string
 	thinking_tokens_budget: number
@@ -103,4 +104,5 @@ export interface TestInput {
 	thinkingBudgetTokens: number
 	originalDiffEditToolCallMessage?: string
 	diffApplyFile?: string
+	isVerbose: boolean
 }

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "claude-dev",
-	"version": "3.18.1",
+	"version": "3.18.7",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "claude-dev",
-			"version": "3.18.1",
+			"version": "3.18.7",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.37.0",

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.18.1",
+	"version": "3.18.7",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"

proto/account.proto

@@ -1,76 +1,129 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Service for account-related operations
 service AccountService {
-    // Handles the user clicking the login link in the UI.
-    // Generates a secure nonce for state validation, stores it in secrets,
-    // and opens the authentication URL in the external browser.
-    rpc accountLoginClicked(EmptyRequest) returns (String);
+  // Handles the user clicking the login link in the UI.
+  // Generates a secure nonce for state validation, stores it in secrets,
+  // and opens the authentication URL in the external browser.
+  rpc accountLoginClicked(EmptyRequest) returns (String);
     
-    // Handles the user clicking the logout button in the UI.
-    // Clears API keys and user state.
-    rpc accountLogoutClicked(EmptyRequest) returns (Empty);
+  // Handles the user clicking the logout button in the UI.
+  // Clears API keys and user state.
+  rpc accountLogoutClicked(EmptyRequest) returns (Empty);
 
-    // Subscribe to auth callback events (when authentication tokens are received)
-    rpc subscribeToAuthCallback(EmptyRequest) returns (stream String);
+  // Subscribe to auth status update events (when authentication state changes)
+  rpc subscribeToAuthStatusUpdate(EmptyRequest) 
+      returns (stream AuthState);
     
-    // Handles authentication state changes from the Firebase context.
-    // Updates the user info in global state and returns the updated value.
-    rpc authStateChanged(AuthStateChangedRequest) returns (AuthStateChanged);
+  // Handles authentication state changes from the Firebase context.
+  // Updates the user info in global state and returns the updated value.
+  rpc authStateChanged(AuthStateChangedRequest) 
+      returns (AuthState);
     
-    // Fetches all user credits data (balance, usage transactions, payment transactions)
-    rpc fetchUserCreditsData(EmptyRequest) returns (UserCreditsData);
+  // Fetches all user credits data
+  // (balance, usage transactions, payment transactions)
+  rpc getUserCredits(EmptyRequest) returns (UserCreditsData);
+
+  rpc getOrganizationCredits(GetOrganizationCreditsRequest) returns (OrganizationCreditsData);
+
+  // Fetches all user organizations data
+  // Returns a list of UserOrganization objects
+  rpc getUserOrganizations(EmptyRequest) returns (UserOrganizationsResponse);
+
+  rpc setUserOrganization(UserOrganizationUpdateRequest) returns (Empty);
 }
 
 message AuthStateChangedRequest {
-    Metadata metadata = 1;
-    UserInfo user = 2;
+  Metadata metadata = 1;
+  UserInfo user = 2;
 }
 
-message AuthStateChanged {
-    optional UserInfo user = 1;
+message AuthState {
+  optional UserInfo user = 1;
 }
 
+// User's information
 message UserInfo {
-    optional string display_name = 1;
-    optional string email = 2;
-    optional string photo_url = 3;
+  string uid = 1;
+  optional string display_name = 2;
+  optional string email = 3;
+  optional string photo_url = 4;
+}
+
+message UserOrganization {
+  bool active = 1;
+  string member_id = 2;
+  string name = 3;
+  string organization_id = 4;
+  repeated string roles = 5; // ["admin", "member", "owner"]
+}
+
+message UserOrganizationsResponse {
+  repeated UserOrganization organizations = 1;
+}
+
+message UserOrganizationUpdateRequest {
+  optional string organization_id = 1;
 }
 
-// Response containing all user credits data
 message UserCreditsData {
-    UserCreditsBalance balance = 1;
-    repeated UsageTransaction usage_transactions = 2;
-    repeated PaymentTransaction payment_transactions = 3;
+  UserCreditsBalance balance = 1;
+  repeated UsageTransaction usage_transactions = 2;
+  repeated PaymentTransaction payment_transactions = 3;
+}
+
+message GetOrganizationCreditsRequest {
+  string organization_id = 1;
+}
+
+message OrganizationCreditsData {
+  UserCreditsBalance balance = 1;
+  string organization_id = 2;
+  repeated OrganizationUsageTransaction usage_transactions = 3;
 }
 
-// User's current credit balance
 message UserCreditsBalance {
-    double current_balance = 1;
+  double current_balance = 1;
 }
 
-// Usage transaction record
 message UsageTransaction {
-    string spent_at = 1;
-    string creator_id = 2;
-    double credits = 3;
-    string model_provider = 4;
-    string model = 5;
-    int32 prompt_tokens = 6;
-    int32 completion_tokens = 7;
-    int32 total_tokens = 8;
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
 }
 
-// Payment transaction record
 message PaymentTransaction {
-    string paid_at = 1;
-    string creator_id = 2;
-    int32 amount_cents = 3;
-    double credits = 4;
+  string paid_at = 1;
+  string creator_id = 2;
+  int32 amount_cents = 3;
+  double credits = 4;
 }
+
+message OrganizationUsageTransaction {
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
+}

proto/browser.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service BrowserService {
   rpc getBrowserConnectionInfo(EmptyRequest) returns (BrowserConnectionInfo);
   rpc testBrowserConnection(StringRequest) returns (BrowserConnection);

proto/checkpoints.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service CheckpointsService {
   rpc checkpointDiff(Int64Request) returns (Empty);
   rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);

proto/file.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Service for file-related operations
 service FileService {
   // Copies text to clipboard

proto/host/env.proto

@@ -13,4 +13,7 @@ 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/uri.proto

@@ -1,36 +0,0 @@
-syntax = "proto3";
-
-package host;
-option java_package = "bot.cline.host.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// UriService provides methods for working with URIs in the IDE
-service UriService {
-  // Create a new file URI from a file path
-  rpc file(cline.StringRequest) returns (Uri);
-  
-  // Join a URI with additional path segments
-  rpc joinPath(JoinPathRequest) returns (Uri);
-  
-  // Parse a string URI into a Uri object
-  rpc parse(cline.StringRequest) returns (Uri);
-}
-
-// Uri represents a URI in the IDE
-message Uri {
-  string scheme = 1;
-  string authority = 2;
-  string path = 3;
-  string query = 4;
-  string fragment = 5;
-  string fs_path = 6;
-}
-
-// Request for joining path segments to a URI
-message JoinPathRequest {
-  cline.Metadata metadata = 1;
-  Uri base = 2;
-  repeated string path_segments = 3;
-}

proto/host/window.proto

@@ -10,6 +10,7 @@ import "common.proto";
 service WindowService {
   // Opens a text document in the editor and returns editor information.
   rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
+  rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
 }
 
 message ShowTextDocumentRequest {
@@ -30,3 +31,18 @@ message TextEditorInfo {
   optional int32 view_column = 2;
   bool is_active = 3;
 }
+
+message ShowOpenDialogueRequest {
+  cline.Metadata metadata = 1;
+  optional bool can_select_many = 2;
+  optional string open_label = 3;
+  optional ShowOpenDialogueFilterOption filters = 4;
+}
+
+message ShowOpenDialogueFilterOption {
+  repeated string files = 1;
+}
+
+message SelectedResources {
+  repeated string paths = 1;
+}

proto/mcp.proto

@@ -1,16 +1,15 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service McpService {
   rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
   rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
   rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
-  rpc downloadMcp(StringRequest) returns (Empty);
+  rpc downloadMcp(StringRequest) returns (McpDownloadResponse);
   rpc restartMcpServer(StringRequest) returns (McpServers);
   rpc deleteMcpServer(StringRequest) returns (McpServers);
   rpc toggleToolAutoApprove(ToggleToolAutoApproveRequest) returns (McpServers);
@@ -119,3 +118,15 @@ message McpMarketplaceItem {
 message McpMarketplaceCatalog {
   repeated McpMarketplaceItem items = 1;
 }
+
+message McpDownloadResponse {
+  string mcp_id = 1;
+  string github_url = 2;
+  string name = 3;
+  string author = 4;
+  string description = 5;
+  string readme_content = 6;
+  string llms_installation_content = 7;
+  bool requires_api_key = 8;
+  optional string error = 9;
+}

proto/models.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Service for model-related operations
 service ModelsService {
   // Fetches available models from Ollama
@@ -165,7 +164,7 @@ message ModelsApiConfiguration {
   // From ApiHandlerOptions (excluding onRetryAttempt function)
   optional string api_model_id = 1;
   optional string api_key = 2;
-  optional string cline_api_key = 3;
+  optional string cline_account_id = 3;
   optional string task_id = 4;
   optional string lite_llm_base_url = 5;
   optional string lite_llm_model_id = 6;

proto/slash.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // SlashService provides methods for managing slash
 service SlashService {
   // Sends button click message

proto/state.proto

@@ -1,10 +1,9 @@
 syntax = "proto3";
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service StateService {
   rpc getLatestState(EmptyRequest) returns (State);
   rpc updateTerminalConnectionTimeout(Int64Request) returns (Int64);
@@ -18,6 +17,7 @@ service StateService {
   rpc updateAutoApprovalSettings(AutoApprovalSettingsRequest) returns (Empty);
   rpc updateSettings(UpdateSettingsRequest) returns (Empty);
   rpc updateTelemetrySetting(TelemetrySettingRequest) returns (Empty);
+  rpc setWelcomeViewCompleted(BooleanRequest) returns (Empty);
 }
 
 message State {
@@ -125,7 +125,7 @@ message ApiConfiguration {
   optional string api_base_url = 4;
   
   // Provider-specific API keys
-  optional string cline_api_key = 5;
+  optional string cline_account_id = 5;
   optional string openrouter_api_key = 6;
   optional string anthropic_base_url = 7;
   optional string openai_api_key = 8;

proto/task.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service TaskService {
   // Cancels the currently running task
   rpc cancelTask(EmptyRequest) returns (Empty);

proto/ui.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Enum for webview provider types
 enum WebviewProviderType {
   SIDEBAR = 0;

proto/web.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service WebService {
   rpc checkIsImageUrl(StringRequest) returns (IsImageUrl);
   rpc fetchOpenGraphData(StringRequest) returns (OpenGraphData);

scripts/package-standalone.mjs

@@ -1,83 +1,100 @@
-import fs from "fs"
-import path from "path"
-import { glob } from "glob"
 import archiver from "archiver"
-import { cp } from "fs/promises"
 import { execSync } from "child_process"
-
+import fs from "fs"
+import { cp } from "fs/promises"
+import { glob } from "glob"
+import ignore from "ignore"
+import path from "path"
 const BUILD_DIR = "dist-standalone"
-const SOURCE_DIR = "standalone/runtime-files"
+const RUNTIME_DEPS_DIR = "standalone/runtime-files"
 
-await cp(SOURCE_DIR, BUILD_DIR, { recursive: true })
-
-// Run npm install in the distribution directory
-console.log("Running npm install in distribution directory...")
-const cwd = process.cwd()
-process.chdir(BUILD_DIR)
-try {
-	execSync("npm install", { stdio: "inherit" })
-	// Move the vscode directory into node_modules.
-	// It can't be installed using npm because it will create a symlink which is not portable.
-	fs.renameSync("vscode", path.join("node_modules", "vscode"))
-} catch (error) {
-	console.error("Error during setup:", error)
-	process.exit(1)
-} finally {
-	process.chdir(cwd)
+async function main() {
+	await installNodeDependencies()
+	await zipDistribution()
 }
 
-// Check for native .node modules.
-const nativeModules = await glob("**/*.node", { cwd: BUILD_DIR, nodir: true })
-if (nativeModules.length > 0) {
-	console.error("Native node modules cannot be included in the standalone distribution:\n", nativeModules.join("\n"))
-	process.exit(1)
+async function installNodeDependencies() {
+	await cpr(RUNTIME_DEPS_DIR, BUILD_DIR)
+
+	console.log("Running npm install in distribution directory...")
+	const cwd = process.cwd()
+	process.chdir(BUILD_DIR)
+
+	try {
+		execSync("npm install", { stdio: "inherit" })
+		// Move the vscode directory into node_modules.
+		// It can't be installed using npm because it will create a symlink which cannot be unzipped correctly on windows.
+		fs.renameSync("vscode", path.join("node_modules", "vscode"))
+	} catch (error) {
+		console.error("Error during setup:", error)
+		process.exit(1)
+	} finally {
+		process.chdir(cwd)
+	}
+
+	// Check for native .node modules.
+	const nativeModules = await glob("**/*.node", { cwd: BUILD_DIR, nodir: true })
+	if (nativeModules.length > 0) {
+		console.error("Native node modules cannot be included in the standalone distribution:\n", nativeModules.join("\n"))
+		process.exit(1)
+	}
 }
 
-// Zip the build directory (excluding any pre-existing output zip).
-const zipPath = path.join(BUILD_DIR, "standalone.zip")
-const output = fs.createWriteStream(zipPath)
-const archive = archiver("zip", { zlib: { level: 3 } })
+async function zipDistribution() {
+	// Zip the build directory (excluding any pre-existing output zip).
+	const zipPath = path.join(BUILD_DIR, "standalone.zip")
+	const output = fs.createWriteStream(zipPath)
+	const archive = archiver("zip", { zlib: { level: 3 } })
+	// Use the same ignore file that vscode uses when packaging the extension.
+	const vscodeignore = ignore().add(fs.readFileSync(".vscodeignore", "utf8"))
 
-output.on("close", () => {
-	console.log(`Created ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB)`)
-})
-archive.on("warning", (err) => {
-	console.warn(`Warning: ${err}`)
-})
-archive.on("error", (err) => {
-	throw err
-})
+	output.on("close", () => {
+		console.log(`Created ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB)`)
+	})
+	archive.on("warning", (err) => {
+		console.warn(`Warning: ${err}`)
+	})
+	archive.on("error", (err) => {
+		throw err
+	})
 
-archive.pipe(output)
-archive.glob("**/*", {
-	cwd: BUILD_DIR,
-	ignore: ["standalone.zip"],
-})
+	archive.pipe(output)
+	// Add all the files from the standalone build dir.
+	archive.glob("**/*", {
+		cwd: BUILD_DIR,
+		ignore: ["standalone.zip"],
+	})
 
-// Add the whole cline directory under "extension"
-archive.directory(process.cwd(), "extension", (entry) => {
-	// Skip certain directories.
-	const exclude = [
-		BUILD_DIR + "/",
-		"node_modules/", // node_modules nearly 1GB.
-		"webview-ui/node_modules/", // node_modules nearly 1GB.
-	]
-	// These node modules are used at runtime as assets, they need to be included.
-	const include = ["node_modules/@vscode/", "webview-ui/node_modules/katex"]
-	const name = entry.name
-
-	if (include.some((prefix) => name.startsWith(prefix))) {
+	// Add the whole cline directory under "extension"
+	archive.directory(process.cwd(), "extension", (entry) => {
+		if (entry.name.startsWith(".git")) {
+			return false
+		}
+		if (entry.name.endsWith(".DS_Store")) {
+			return false
+		}
+		if (entry.name === "dist" || entry.name.startsWith("dist" + path.sep)) {
+			// Don't include the vscode extension build dir.
+			return false
+		}
+		if (vscodeignore.ignores(entry.name)) {
+			// Exclude entries also ignored by the vscode packager.
+			return false
+		}
 		return entry
-	}
-	if (exclude.some((prefix) => name.startsWith(prefix))) {
-		return false
-	}
-	if (name.match(/(^|\/)\./)) {
-		// exclude dot directories
-		return false
-	}
-	return entry
-})
+	})
 
-console.log("Zipping package...")
-await archive.finalize()
+	console.log("Zipping package...")
+	await archive.finalize()
+}
+
+/* cp -r */
+async function cpr(source, dest) {
+	await cp(source, dest, {
+		recursive: true,
+		preserveTimestamps: true,
+		dereference: false, // preserve symlinks instead of following them
+	})
+}
+
+await main()

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

@@ -45,8 +45,10 @@ describe("OllamaHandler", () => {
 				this.skip()
 			}
 			this.timeout(5000)
+			// Ensure client is initialized
+			const client = (handler as any).ensureClient()
 			// Mock the Ollama client's chat method
-			const chatStub = sinon.stub(handler["client"], "chat").resolves({
+			const chatStub = sinon.stub(client, "chat").resolves({
 				[Symbol.asyncIterator]: async function* () {
 					yield {
 						message: { content: "Hello, world!" },
@@ -139,8 +141,9 @@ describe("OllamaHandler", () => {
 			// Restore real timers for this test
 			clock.restore()
 
-			// Mock the Ollama client's chat method to fail on first call and succeed on second
-			const chatStub = sinon.stub(handler["client"], "chat")
+			// Ensure client is initialized and mock the Ollama client's chat method to fail on first call and succeed on second
+			const client = (handler as any).ensureClient()
+			const chatStub = sinon.stub(client, "chat")
 
 			// First call throws an error
 			chatStub.onFirstCall().rejects(new Error("API Error"))

src/api/providers/anthropic.ts

@@ -7,18 +7,33 @@ import { ApiStream } from "../transform/stream"
 
 export class AnthropicHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: Anthropic
+	private client: Anthropic | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new Anthropic({
-			apiKey: this.options.apiKey,
-			baseURL: this.options.anthropicBaseUrl || undefined,
-		})
+	}
+
+	private ensureClient(): Anthropic {
+		if (!this.client) {
+			if (!this.options.apiKey) {
+				throw new Error("Anthropic API key is required")
+			}
+			try {
+				this.client = new Anthropic({
+					apiKey: this.options.apiKey,
+					baseURL: this.options.anthropicBaseUrl || undefined,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Anthropic client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+
 		const model = this.getModel()
 		let stream: AnthropicStream<Anthropic.RawMessageStreamEvent>
 		const modelId = model.id
@@ -44,7 +59,7 @@ export class AnthropicHandler implements ApiHandler {
 				)
 				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
 				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
-				stream = await this.client.messages.create(
+				stream = await client.messages.create(
 					{
 						model: modelId,
 						thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
@@ -118,7 +133,7 @@ export class AnthropicHandler implements ApiHandler {
 				break
 			}
 			default: {
-				stream = await this.client.messages.create({
+				stream = await client.messages.create({
 					model: modelId,
 					max_tokens: model.info.maxTokens || 8192,
 					temperature: 0,

src/api/providers/cerebras.ts

@@ -7,32 +7,52 @@ import { ApiStream } from "@api/transform/stream"
 
 export class CerebrasHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: Cerebras
+	private client: Cerebras | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
+	}
 
-		// Clean and validate the API key
-		const cleanApiKey = this.options.cerebrasApiKey?.trim()
+	private ensureClient(): Cerebras {
+		if (!this.client) {
+			// Clean and validate the API key
+			const cleanApiKey = this.options.cerebrasApiKey?.trim()
 
-		if (!cleanApiKey) {
-			throw new Error("Cerebras API key is required")
+			if (!cleanApiKey) {
+				throw new Error("Cerebras API key is required")
+			}
+
+			try {
+				this.client = new Cerebras({
+					apiKey: cleanApiKey,
+					timeout: 30000, // 30 second timeout
+				})
+			} catch (error) {
+				throw new Error(`Error creating Cerebras client: ${error.message}`)
+			}
 		}
-
-		this.client = new Cerebras({
-			apiKey: cleanApiKey,
-			timeout: 30000, // 30 second timeout
-		})
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+
 		// Convert Anthropic messages to Cerebras format
 		const cerebrasMessages: Array<{
 			role: "system" | "user" | "assistant"
 			content: string
 		}> = [{ role: "system", content: systemPrompt }]
 
+		// Helper function to strip thinking tags from content
+		const stripThinkingTags = (content: string): string => {
+			return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim()
+		}
+
+		// Check if this is a reasoning model that uses thinking tags
+		const modelId = this.getModel().id
+		const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
+
 		// Convert Anthropic messages to Cerebras format
 		for (const message of messages) {
 			if (message.role === "user") {
@@ -50,7 +70,7 @@ export class CerebrasHandler implements ApiHandler {
 					: message.content
 				cerebrasMessages.push({ role: "user", content })
 			} else if (message.role === "assistant") {
-				const content = Array.isArray(message.content)
+				let content = Array.isArray(message.content)
 					? message.content
 							.map((block) => {
 								if (block.type === "text") {
@@ -60,12 +80,19 @@ export class CerebrasHandler implements ApiHandler {
 							})
 							.join("\n")
 					: message.content || ""
+
+				// Strip thinking tags from assistant messages for reasoning models
+				// so the model doesn't see its own thinking in the conversation history
+				if (isReasoningModel) {
+					content = stripThinkingTags(content)
+				}
+
 				cerebrasMessages.push({ role: "assistant", content })
 			}
 		}
 
 		try {
-			const stream = await this.client.chat.completions.create({
+			const stream = await client.chat.completions.create({
 				model: this.getModel().id,
 				messages: cerebrasMessages,
 				temperature: 0,
@@ -74,8 +101,6 @@ export class CerebrasHandler implements ApiHandler {
 
 			// Handle streaming response
 			let reasoning: string | null = null // Track reasoning content for models that support thinking
-			const modelId = this.getModel().id
-			const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
 
 			for await (const chunk of stream as any) {
 				// Type assertion for the streaming chunk

src/api/providers/claude-code.ts

@@ -27,6 +27,7 @@ export class ClaudeCodeHandler implements ApiHandler {
 			messages: filteredMessages,
 			path: this.options.claudeCodePath,
 			modelId: this.getModel().id,
+			thinkingBudgetTokens: this.options.thinkingBudgetTokens,
 		})
 
 		// Usage is included with assistant messages,

src/api/providers/cline.ts

@@ -1,143 +1,234 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import OpenAI from "openai"
 import { ApiHandler } from "../"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
 import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
-import axios from "axios"
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios"
 import { OpenRouterErrorResponse } from "./types"
 import { withRetry } from "../retry"
+import { AuthService } from "@/services/auth/AuthService"
 
 export class ClineHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private clineAccountService = ClineAccountService.getInstance()
+	private _authService: AuthService
+	// TODO: replace this with a global API Host
+	private readonly _baseUrl = "https://api.cline.bot"
+	// private readonly _baseUrl = "https://core-api.staging.int.cline.bot"
+	// private readonly _baseUrl = "http://localhost:7777"
 	lastGenerationId?: string
+	private counter = 0
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.cline.bot/v1",
-			apiKey: this.options.clineApiKey || "",
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot", // Optional, for including your app on cline.bot rankings.
-				"X-Title": "Cline", // Optional. Shows in rankings on cline.bot.
-				"X-Task-ID": this.options.taskId || "", // Include the task ID in the request headers
-			},
-		})
+		this._authService = AuthService.getInstance()
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const clineAccountAuthToken = await this._authService.getAuthToken()
+
 		this.lastGenerationId = undefined
 
-		const stream = await createOpenRouterStream(
-			this.client,
-			systemPrompt,
-			messages,
-			this.getModel(),
-			this.options.reasoningEffort,
-			this.options.thinkingBudgetTokens,
-			this.options.openRouterProviderSorting,
+		const requestConfig: AxiosRequestConfig = {
+			headers: {
+				"HTTP-Referer": "https://cline.bot", // Optional, for including your app on cline.bot rankings.
+				"X-Title": "Cline", // Optional. Shows in rankings on cline.bot.
+				"X-Task-ID": this.options.taskId || "", // Include the task ID in the request headers
+				Authorization: `Bearer ${clineAccountAuthToken}`,
+			},
+			timeout: 15_000, // Set a timeout for requests to avoid hanging
+		}
+
+		const me = await this.clineAccountService.fetchMe()
+		console.log(
+			"SwitchAuthToken: Active Organization",
+			me?.organizations.filter((org) => org.active)[0]?.name || "No active organization",
 		)
 
 		let didOutputUsage: boolean = false
 
-		for await (const chunk of stream) {
-			// 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}`)
+		const url = `${this._baseUrl}/api/v1/chat/completions`
+		try {
+			const response = await axios.post(
+				url,
+				{
+					model: this.getModel().id,
+					messages: [
+						{
+							role: "system",
+							content: systemPrompt,
+						},
+						...messages,
+					],
+					stream: false,
+					// reasoning_effort: this.options.reasoningEffort || "low",
+					// thinking_budget_tokens: this.options.thinkingBudgetTokens || 0,
+					// open_router_provider_sorting: this.options.openRouterProviderSorting || "default",
+				},
+				requestConfig,
+			)
+
+			if (!response.data || !response.data.data) {
+				throw new Error(`Request to ${url} failed with status ${response.status}`)
 			}
 
-			if (!this.lastGenerationId && chunk.id) {
-				this.lastGenerationId = chunk.id
+			if (!response.data.data.choices || response.data.data.choices.length === 0) {
+				throw new Error(`No choices returned from Cline API: ${JSON.stringify(response.data)}`)
 			}
 
-			// 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}`)
-				} else {
-					throw new Error("Cline Mid-Stream Error: Stream terminated with error status but no error details provided")
+			for (const choice of response.data.data.choices) {
+				if (choice.finish_reason === "error") {
+					const error = choice.error || { code: "Unknown", message: "No error details provided" }
+					console.error(`Cline API Error: ${error.code} - ${error.message}`)
+					throw new Error(`Cline API Error: ${error.code} - ${error.message}`)
 				}
-			}
-
-			const delta = choice?.delta
-			if (delta?.content) {
-				yield {
-					type: "text",
-					text: delta.content,
+				if (choice.delta && choice.delta.content) {
+					yield {
+						type: "text",
+						text: choice.delta.content,
+					}
 				}
-			}
-
-			// Reasoning tokens are returned separately from the content
-			if ("reasoning" in delta && delta.reasoning) {
-				yield {
-					type: "reasoning",
-					// @ts-ignore-next-line
-					reasoning: delta.reasoning,
+				if (choice.delta && choice.delta.reasoning) {
+					yield {
+						type: "reasoning",
+						reasoning: choice.delta.reasoning,
+					}
 				}
-			}
-
-			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 (choice.message && choice.message.content) {
+					yield {
+						type: "text",
+						text: choice.message.content,
+					}
 				}
-
-				if (modelId.includes("gemini")) {
+				if (choice.usage) {
+					const totalCost = choice.usage.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,
-					}
-				} 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
+						cacheReadTokens: choice.usage.cached_tokens || 0,
+						inputTokens: choice.usage.prompt_tokens || 0,
+						outputTokens: choice.usage.completion_tokens || 0,
 						totalCost,
 					}
 				}
+			}
+
+			if (response.data.data.usage) {
 				didOutputUsage = true
+				yield {
+					type: "usage",
+					cacheWriteTokens: 0,
+					cacheReadTokens: response.data.data.usage.prompt_tokens_details?.cached_tokens || 0,
+					inputTokens: response.data.data.usage.prompt_tokens || 0,
+					outputTokens: response.data.data.usage.completion_tokens || 0,
+					totalCost: response.data.data.usage.cost || 0,
+				}
 			}
-		}
 
-		// Fallback to generation endpoint if usage chunk not returned
-		if (!didOutputUsage) {
-			const apiStreamUsage = await this.getApiStreamUsage()
-			if (apiStreamUsage) {
-				yield apiStreamUsage
+			// for await (const chunk of stream) {
+			// 	// 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}`)
+			// 	}
+			// 	if (!this.lastGenerationId && chunk.id) {
+			// 		this.lastGenerationId = chunk.id
+			// 	}
+
+			// 	// 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}`)
+			// 		} else {
+			// 			throw new Error("Cline Mid-Stream Error: Stream terminated with error status but no error details provided")
+			// 		}
+			// 	}
+
+			// 	const delta = choice?.delta
+			// 	if (delta?.content) {
+			// 		yield {
+			// 			type: "text",
+			// 			text: delta.content,
+			// 		}
+			// 	}
+
+			// 	// Reasoning tokens are returned separately from the content
+			// 	if ("reasoning" in delta && delta.reasoning) {
+			// 		yield {
+			// 			type: "reasoning",
+			// 			// @ts-ignore-next-line
+			// 			reasoning: delta.reasoning,
+			// 		}
+			// 	}
+
+			// 	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,
+			// 			}
+			// 		}
+			// 		didOutputUsage = true
+			// 	}
+			// }
+
+			// Fallback to generation endpoint if usage chunk not returned
+			if (!didOutputUsage) {
+				console.warn("Cline API did not return usage chunk, fetching from generation endpoint")
+				// const apiStreamUsage = await this.getApiStreamUsage()
+				// if (apiStreamUsage) {
+				// 	yield apiStreamUsage
+				// }
 			}
+		} catch (error) {
+			console.error("Cline API Error:", error)
 		}
 	}
 
 	async getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined> {
 		if (this.lastGenerationId) {
 			try {
-				const response = await axios.get(`https://api.cline.bot/v1/generation?id=${this.lastGenerationId}`, {
+				// TODO: replace this with firebase auth
+				// TODO: use global API Host
+
+				const response = await axios.get(`${this.clineAccountService.baseUrl}/generation?id=${this.lastGenerationId}`, {
 					headers: {
-						Authorization: `Bearer ${this.options.clineApiKey}`,
+						Authorization: `Bearer ${this.options.clineAccountId}`,
 					},
 					timeout: 15_000, // this request hangs sometimes
 				})
@@ -175,9 +266,6 @@ export class ClineHandler implements ApiHandler {
 
 	getModel(): { id: string; info: ModelInfo } {
 		let modelId = this.options.openRouterModelId
-		if (modelId === "x-ai/grok-3") {
-			modelId = "x-ai/grok-3-beta"
-		}
 		const modelInfo = this.options.openRouterModelInfo
 		if (modelId && modelInfo) {
 			return { id: modelId, info: modelInfo }

src/api/providers/deepseek.ts

@@ -10,14 +10,27 @@ import { convertToR1Format } from "../transform/r1-format"
 
 export class DeepSeekHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.deepseek.com/v1",
-			apiKey: this.options.deepSeekApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.deepSeekApiKey) {
+				throw new Error("DeepSeek API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.deepseek.com/v1",
+					apiKey: this.options.deepSeekApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating DeepSeek client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
@@ -54,6 +67,7 @@ export class DeepSeekHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const isDeepseekReasoner = model.id.includes("deepseek-reasoner")
@@ -67,7 +81,7 @@ export class DeepSeekHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/doubao.ts

@@ -8,13 +8,26 @@ import { withRetry } from "../retry"
 
 export class DoubaoHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://ark.cn-beijing.volces.com/api/v3/",
-			apiKey: this.options.doubaoApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.doubaoApiKey) {
+				throw new Error("Doubao API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://ark.cn-beijing.volces.com/api/v3/",
+					apiKey: this.options.doubaoApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Doubao client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	getModel(): { id: DoubaoModelId; info: ModelInfo } {
@@ -31,12 +44,13 @@ export class DoubaoHandler implements ApiHandler {
 
 	@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 this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/fireworks.ts

@@ -15,18 +15,32 @@ import { ApiStream } from "../transform/stream"
 
 export class FireworksHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.fireworks.ai/inference/v1",
-			apiKey: this.options.fireworksApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.fireworksApiKey) {
+				throw new Error("Fireworks API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.fireworks.ai/inference/v1",
+					apiKey: this.options.fireworksApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Fireworks client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.options.fireworksModelId ?? ""
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -34,7 +48,7 @@ export class FireworksHandler implements ApiHandler {
 			...convertToOpenAiMessages(messages),
 		]
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			...(this.options.fireworksModelMaxCompletionTokens
 				? { max_completion_tokens: this.options.fireworksModelMaxCompletionTokens }

src/api/providers/gemini.ts

@@ -38,30 +38,45 @@ interface GeminiHandlerOptions extends ApiHandlerOptions {
  */
 export class GeminiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: GoogleGenAI
+	private client: GoogleGenAI | undefined
 
 	constructor(options: GeminiHandlerOptions) {
 		// Store the options
 		this.options = options
+	}
 
-		if (options.isVertex) {
-			// Initialize with Vertex AI configuration
-			const project = this.options.vertexProjectId ?? "not-provided"
-			const location = this.options.vertexRegion ?? "not-provided"
+	private ensureClient(): GoogleGenAI {
+		if (!this.client) {
+			const options = this.options as GeminiHandlerOptions
 
-			this.client = new GoogleGenAI({
-				vertexai: true,
-				project,
-				location,
-			})
-		} else {
-			// Initialize with standard API key
-			if (!options.geminiApiKey) {
-				throw new Error("API key is required for Google Gemini when not using Vertex AI")
+			if (options.isVertex) {
+				// Initialize with Vertex AI configuration
+				const project = this.options.vertexProjectId ?? "not-provided"
+				const location = this.options.vertexRegion ?? "not-provided"
+
+				try {
+					this.client = new GoogleGenAI({
+						vertexai: true,
+						project,
+						location,
+					})
+				} catch (error) {
+					throw new Error(`Error creating Gemini Vertex AI client: ${error.message}`)
+				}
+			} else {
+				// Initialize with standard API key
+				if (!options.geminiApiKey) {
+					throw new Error("API key is required for Google Gemini when not using Vertex AI")
+				}
+
+				try {
+					this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
+				} catch (error) {
+					throw new Error(`Error creating Gemini client: ${error.message}`)
+				}
 			}
-
-			this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
 		}
+		return this.client
 	}
 
 	/**
@@ -80,6 +95,7 @@ export class GeminiHandler implements ApiHandler {
 		maxDelay: 15000,
 	})
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const { id: modelId, info } = this.getModel()
 		const contents = messages.map(convertAnthropicMessageToGemini)
 
@@ -117,7 +133,7 @@ export class GeminiHandler implements ApiHandler {
 		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined
 
 		try {
-			const result = await this.client.models.generateContentStream({
+			const result = await client.models.generateContentStream({
 				model: modelId,
 				contents: contents,
 				config: {
@@ -351,6 +367,7 @@ export class GeminiHandler implements ApiHandler {
 	 */
 	async countTokens(content: Array<any>): Promise<number> {
 		try {
+			const client = this.ensureClient()
 			const { id: model } = this.getModel()
 
 			// Convert content to Gemini format
@@ -362,7 +379,7 @@ export class GeminiHandler implements ApiHandler {
 			})
 
 			// Use Gemini's token counting API
-			const response = await this.client.models.countTokens({
+			const response = await client.models.countTokens({
 				model,
 				contents: [{ parts: geminiContent }],
 			})

src/api/providers/litellm.ts

@@ -8,21 +8,35 @@ import { withRetry } from "../retry"
 
 export class LiteLlmHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: this.options.liteLlmBaseUrl || "http://localhost:4000",
-			apiKey: this.options.liteLlmApiKey || "noop",
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.liteLlmApiKey) {
+				throw new Error("LiteLLM API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: this.options.liteLlmBaseUrl || "http://localhost:4000",
+					apiKey: this.options.liteLlmApiKey || "noop",
+				})
+			} catch (error) {
+				throw new Error(`Error creating LiteLLM client: ${error.message}`)
+			}
+		}
+		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
+		const client = this.ensureClient()
 		const modelId = this.options.liteLlmModelId || liteLlmDefaultModelId
 		try {
-			const response = await fetch(`${this.client.baseURL}/spend/calculate`, {
+			const response = await fetch(`${client.baseURL}/spend/calculate`, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -54,6 +68,7 @@ export class LiteLlmHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const formattedMessages = convertToOpenAiMessages(messages)
 		const systemMessage: OpenAI.Chat.ChatCompletionSystemMessageParam = {
 			role: "system",
@@ -101,7 +116,7 @@ export class LiteLlmHandler implements ApiHandler {
 			return message
 		})
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: this.options.liteLlmModelId || liteLlmDefaultModelId,
 			messages: [enhancedSystemMessage, ...enhancedMessages],
 			temperature,

src/api/providers/lmstudio.ts

@@ -8,25 +8,36 @@ import { withRetry } from "../retry"
 
 export class LmStudioHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: (this.options.lmStudioBaseUrl || "http://localhost:1234") + "/v1",
-			apiKey: "noop",
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			try {
+				this.client = new OpenAI({
+					baseURL: (this.options.lmStudioBaseUrl || "http://localhost:1234") + "/v1",
+					apiKey: "noop",
+				})
+			} catch (error) {
+				throw new Error(`Error creating LM Studio client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry({ retryAllErrors: true })
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },
 			...convertToOpenAiMessages(messages),
 		]
 
 		try {
-			const stream = await this.client.chat.completions.create({
+			const stream = await client.chat.completions.create({
 				model: this.getModel().id,
 				messages: openAiMessages,
 				stream: true,

src/api/providers/mistral.ts

@@ -8,18 +8,32 @@ import { ApiStream } from "../transform/stream"
 
 export class MistralHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: Mistral
+	private client: Mistral | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new Mistral({
-			apiKey: this.options.mistralApiKey,
-		})
+	}
+
+	private ensureClient(): Mistral {
+		if (!this.client) {
+			if (!this.options.mistralApiKey) {
+				throw new Error("Mistral API key is required")
+			}
+			try {
+				this.client = new Mistral({
+					apiKey: this.options.mistralApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Mistral client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const stream = await this.client.chat
+		const client = this.ensureClient()
+		const stream = await client.chat
 			.stream({
 				model: this.getModel().id,
 				// max_completion_tokens: this.getModel().info.maxTokens,

src/api/providers/nebius.ts

@@ -8,24 +8,37 @@ import { convertToR1Format } from "../transform/r1-format"
 import { nebiusDefaultModelId, nebiusModels, type ModelInfo, type ApiHandlerOptions, type NebiusModelId } from "../../shared/api"
 
 export class NebiusHandler implements ApiHandler {
-	private client: OpenAI
+	private client: OpenAI | undefined
 
-	constructor(private readonly options: ApiHandlerOptions) {
-		this.client = new OpenAI({
-			baseURL: "https://api.studio.nebius.ai/v1",
-			apiKey: this.options.nebiusApiKey,
-		})
+	constructor(private readonly options: ApiHandlerOptions) {}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.nebiusApiKey) {
+				throw new Error("Nebius API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.studio.nebius.ai/v1",
+					apiKey: this.options.nebiusApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Nebius client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = model.id.includes("DeepSeek-R1")
 			? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 			: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)]
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			messages: openAiMessages,
 			temperature: 0,

src/api/providers/ollama.ts

@@ -8,15 +8,26 @@ import { withRetry } from "../retry"
 
 export class OllamaHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: Ollama
+	private client: Ollama | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new Ollama({ host: this.options.ollamaBaseUrl || "http://localhost:11434" })
+	}
+
+	private ensureClient(): Ollama {
+		if (!this.client) {
+			try {
+				this.client = new Ollama({ host: this.options.ollamaBaseUrl || "http://localhost:11434" })
+			} catch (error) {
+				throw new Error(`Error creating Ollama client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry({ retryAllErrors: true })
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const ollamaMessages: Message[] = [{ role: "system", content: systemPrompt }, ...convertToOllamaMessages(messages)]
 
 		try {
@@ -27,7 +38,7 @@ export class OllamaHandler implements ApiHandler {
 			})
 
 			// Create the actual API request promise
-			const apiPromise = this.client.chat({
+			const apiPromise = client.chat({
 				model: this.getModel().id,
 				messages: ollamaMessages,
 				stream: true,

src/api/providers/openai-native.ts

@@ -10,13 +10,26 @@ import type { ChatCompletionReasoningEffort } from "openai/resources/chat/comple
 
 export class OpenAiNativeHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			apiKey: this.options.openAiNativeApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openAiNativeApiKey) {
+				throw new Error("OpenAI API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					apiKey: this.options.openAiNativeApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating OpenAI client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
@@ -38,6 +51,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		switch (model.id) {
@@ -45,7 +59,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 			case "o1-preview":
 			case "o1-mini": {
 				// o1 doesn't support streaming, non-1 temp, or system prompt
-				const response = await this.client.chat.completions.create({
+				const response = await client.chat.completions.create({
 					model: model.id,
 					messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 				})
@@ -61,7 +75,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 			case "o4-mini":
 			case "o3":
 			case "o3-mini": {
-				const stream = await this.client.chat.completions.create({
+				const stream = await client.chat.completions.create({
 					model: model.id,
 					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 					stream: true,
@@ -85,7 +99,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 				break
 			}
 			default: {
-				const stream = await this.client.chat.completions.create({
+				const stream = await client.chat.completions.create({
 					model: model.id,
 					// max_completion_tokens: this.getModel().info.maxTokens,
 					temperature: 0,

src/api/providers/openai.ts

@@ -10,35 +10,49 @@ import type { ChatCompletionReasoningEffort } from "openai/resources/chat/comple
 
 export class OpenAiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		// Azure API shape slightly differs from the core API shape: https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai
-		// Use azureApiVersion to determine if this is an Azure endpoint, since the URL may not always contain 'azure.com'
-		if (
-			this.options.azureApiVersion ||
-			((this.options.openAiBaseUrl?.toLowerCase().includes("azure.com") ||
-				this.options.openAiBaseUrl?.toLowerCase().includes("azure.us")) &&
-				!this.options.openAiModelId?.toLowerCase().includes("deepseek"))
-		) {
-			this.client = new AzureOpenAI({
-				baseURL: this.options.openAiBaseUrl,
-				apiKey: this.options.openAiApiKey,
-				apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion,
-				defaultHeaders: this.options.openAiHeaders,
-			})
-		} else {
-			this.client = new OpenAI({
-				baseURL: this.options.openAiBaseUrl,
-				apiKey: this.options.openAiApiKey,
-				defaultHeaders: this.options.openAiHeaders,
-			})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openAiApiKey) {
+				throw new Error("OpenAI API key is required")
+			}
+			try {
+				// Azure API shape slightly differs from the core API shape: https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai
+				// Use azureApiVersion to determine if this is an Azure endpoint, since the URL may not always contain 'azure.com'
+				if (
+					this.options.azureApiVersion ||
+					((this.options.openAiBaseUrl?.toLowerCase().includes("azure.com") ||
+						this.options.openAiBaseUrl?.toLowerCase().includes("azure.us")) &&
+						!this.options.openAiModelId?.toLowerCase().includes("deepseek"))
+				) {
+					this.client = new AzureOpenAI({
+						baseURL: this.options.openAiBaseUrl,
+						apiKey: this.options.openAiApiKey,
+						apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion,
+						defaultHeaders: this.options.openAiHeaders,
+					})
+				} else {
+					this.client = new OpenAI({
+						baseURL: this.options.openAiBaseUrl,
+						apiKey: this.options.openAiApiKey,
+						defaultHeaders: this.options.openAiHeaders,
+					})
+				}
+			} catch (error: any) {
+				throw new Error(`Error creating OpenAI client: ${error.message}`)
+			}
 		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.options.openAiModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
 		const isR1FormatRequired = this.options.openAiModelInfo?.isR1FormatRequired ?? false
@@ -68,7 +82,7 @@ export class OpenAiHandler implements ApiHandler {
 			reasoningEffort = (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium"
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			messages: openAiMessages,
 			temperature,

src/api/providers/openrouter.ts

@@ -11,27 +11,41 @@ import { OpenRouterErrorResponse } from "./types"
 
 export class OpenRouterHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 	lastGenerationId?: string
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://openrouter.ai/api/v1",
-			apiKey: this.options.openRouterApiKey,
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot", // Optional, for including your app on openrouter.ai rankings.
-				"X-Title": "Cline", // Optional. Shows in rankings on openrouter.ai.
-			},
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openRouterApiKey) {
+				throw new Error("OpenRouter API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://openrouter.ai/api/v1",
+					apiKey: this.options.openRouterApiKey,
+					defaultHeaders: {
+						"HTTP-Referer": "https://cline.bot", // Optional, for including your app on openrouter.ai rankings.
+						"X-Title": "Cline", // Optional. Shows in rankings on openrouter.ai.
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating OpenRouter client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		this.lastGenerationId = undefined
 
 		const stream = await createOpenRouterStream(
-			this.client,
+			client,
 			systemPrompt,
 			messages,
 			this.getModel(),
@@ -190,9 +204,6 @@ export class OpenRouterHandler implements ApiHandler {
 
 	getModel(): { id: string; info: ModelInfo } {
 		let modelId = this.options.openRouterModelId
-		if (modelId === "x-ai/grok-3") {
-			modelId = "x-ai/grok-3-beta"
-		}
 		const modelInfo = this.options.openRouterModelInfo
 		if (modelId && modelInfo) {
 			return { id: modelId, info: modelInfo }

src/api/providers/qwen.ts

@@ -18,17 +18,30 @@ import { withRetry } from "../retry"
 
 export class QwenHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL:
-				this.options.qwenApiLine === "china"
-					? "https://dashscope.aliyuncs.com/compatible-mode/v1"
-					: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
-			apiKey: this.options.qwenApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.qwenApiKey) {
+				throw new Error("Alibaba API key is required")
+			}
+			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",
+					apiKey: this.options.qwenApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Alibaba client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	getModel(): { id: MainlandQwenModelId | InternationalQwenModelId; info: ModelInfo } {
@@ -51,6 +64,7 @@ export class QwenHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 		const isDeepseekReasoner = model.id.includes("deepseek-r1")
 		const isReasoningModelFamily = model.id.includes("qwen3") || ["qwen-plus-latest", "qwen-turbo-latest"].includes(model.id)
@@ -76,7 +90,7 @@ export class QwenHandler implements ApiHandler {
 			temperature = undefined
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/requesty.ts

@@ -19,22 +19,36 @@ interface RequestyUsage extends OpenAI.CompletionUsage {
 
 export class RequestyHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://router.requesty.ai/v1",
-			apiKey: this.options.requestyApiKey,
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot",
-				"X-Title": "Cline",
-			},
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.requestyApiKey) {
+				throw new Error("Requesty API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://router.requesty.ai/v1",
+					apiKey: this.options.requestyApiKey,
+					defaultHeaders: {
+						"HTTP-Referer": "https://cline.bot",
+						"X-Title": "Cline",
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Requesty client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -57,7 +71,7 @@ export class RequestyHandler implements ApiHandler {
 				: {}
 
 		// @ts-ignore-next-line
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_tokens: model.info.maxTokens || undefined,
 			messages: openAiMessages,

src/api/providers/sambanova.ts

@@ -9,18 +9,32 @@ import { convertToR1Format } from "@api/transform/r1-format"
 
 export class SambanovaHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.sambanova.ai/v1",
-			apiKey: this.options.sambanovaApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.sambanovaApiKey) {
+				throw new Error("SambaNova API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.sambanova.ai/v1",
+					apiKey: this.options.sambanovaApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating SambaNova client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -34,7 +48,7 @@ export class SambanovaHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: this.getModel().id,
 			messages: openAiMessages,
 			temperature: 0,

src/api/providers/sapaicore.ts

@@ -60,6 +60,7 @@ export class SapAiCoreHandler implements ApiHandler {
 			Authorization: `Bearer ${token}`,
 			"AI-Resource-Group": this.options.sapAiResourceGroup || "default",
 			"Content-Type": "application/json",
+			"AI-Client-Type": "Cline",
 		}
 
 		const url = `${this.options.sapAiCoreBaseUrl}/v2/lm/deployments?$top=10000&$skip=0`
@@ -116,6 +117,7 @@ export class SapAiCoreHandler implements ApiHandler {
 			Authorization: `Bearer ${token}`,
 			"AI-Resource-Group": this.options.sapAiResourceGroup || "default",
 			"Content-Type": "application/json",
+			"AI-Client-Type": "Cline",
 		}
 
 		const model = this.getModel()
@@ -133,6 +135,8 @@ export class SapAiCoreHandler implements ApiHandler {
 
 		const openAIModels = ["gpt-4o", "gpt-4", "gpt-4o-mini", "o1", "gpt-4.1", "gpt-4.1-nano", "o3-mini", "o3", "o4-mini"]
 
+		const geminiModels = ["gemini-2.5-flash", "gemini-2.5-pro"]
+
 		let url: string
 		let payload: any
 		if (anthropicModels.includes(model.id)) {
@@ -187,6 +191,9 @@ export class SapAiCoreHandler implements ApiHandler {
 				delete payload.stream
 				delete payload.stream_options
 			}
+		} else if (geminiModels.includes(model.id)) {
+			url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/models/${model.id}:streamGenerateContent`
+			payload = this.convertToGeminiFormat(systemPrompt, messages)
 		} else {
 			throw new Error(`Unsupported model: ${model.id}`)
 		}
@@ -233,6 +240,8 @@ export class SapAiCoreHandler implements ApiHandler {
 				model.id === "anthropic--claude-3.7-sonnet"
 			) {
 				yield* this.streamCompletionSonnet37(response.data, model)
+			} else if (geminiModels.includes(model.id)) {
+				yield* this.streamCompletionGemini(response.data, model)
 			} else {
 				yield* this.streamCompletion(response.data, model)
 			}
@@ -276,7 +285,6 @@ export class SapAiCoreHandler implements ApiHandler {
 						const jsonData = line.slice(6)
 						try {
 							const data = JSON.parse(jsonData)
-							console.log("Received data:", data)
 							if (data.type === "message_start") {
 								usage.input_tokens = data.message.usage.input_tokens
 								yield {
@@ -339,7 +347,6 @@ export class SapAiCoreHandler implements ApiHandler {
 						try {
 							// Parse the incoming JSON data from the stream
 							const data = JSON.parse(toStrictJson(jsonData))
-							console.log("Received data:", data)
 
 							// Handle metadata (token usage)
 							if (data.metadata?.usage) {
@@ -415,7 +422,6 @@ export class SapAiCoreHandler implements ApiHandler {
 						const jsonData = line.slice(6)
 						try {
 							const data = JSON.parse(jsonData)
-							console.log("Received GPT data:", data)
 
 							if (data.choices && data.choices.length > 0) {
 								const choice = data.choices[0]
@@ -439,7 +445,7 @@ export class SapAiCoreHandler implements ApiHandler {
 								}
 							}
 
-							if (data.choices && data.choices[0].finish_reason === "stop") {
+							if (data.choices?.[0]?.finish_reason === "stop") {
 								// Final usage yield, if not already provided
 								if (!data.usage) {
 									yield {
@@ -461,6 +467,88 @@ export class SapAiCoreHandler implements ApiHandler {
 		}
 	}
 
+	private async *streamCompletionGemini(
+		stream: any,
+		model: { id: SapAiCoreModelId; info: ModelInfo },
+	): AsyncGenerator<any, void, unknown> {
+		let promptTokens = 0
+		let outputTokens = 0
+		let cacheReadTokens = 0
+		let thoughtsTokenCount = 0
+
+		try {
+			for await (const chunk of stream) {
+				const lines = chunk.toString().split("\n").filter(Boolean)
+				for (const line of lines) {
+					if (line.startsWith("data: ")) {
+						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"
+									}
+								}
+							}
+
+							if (thoughts.trim() !== "") {
+								yield {
+									type: "reasoning",
+									reasoning: thoughts.trim(),
+								}
+							}
+
+							if (data.text) {
+								yield {
+									type: "text",
+									text: data.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
+
+								yield {
+									type: "usage",
+									inputTokens: promptTokens - cacheReadTokens,
+									outputTokens,
+									thoughtsTokenCount,
+									cacheReadTokens,
+								}
+							}
+						} catch (error) {
+							console.error("Failed to parse Gemini JSON data:", error)
+						}
+					}
+				}
+			}
+		} catch (error) {
+			console.error("Error streaming Gemini completion:", error)
+			throw error
+		}
+	}
+
 	createUserReadableRequest(
 		userContent: Array<
 			Anthropic.TextBlockParam | Anthropic.ImageBlockParam | Anthropic.ToolUseBlockParam | Anthropic.ToolResultBlockParam
@@ -495,6 +583,50 @@ export class SapAiCoreHandler implements ApiHandler {
 		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[] = []

src/api/providers/together.ts

@@ -9,18 +9,32 @@ import { convertToR1Format } from "@api/transform/r1-format"
 
 export class TogetherHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.together.xyz/v1",
-			apiKey: this.options.togetherApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.togetherApiKey) {
+				throw new Error("Together API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.together.xyz/v1",
+					apiKey: this.options.togetherApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Together client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.options.togetherModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
 
@@ -33,7 +47,7 @@ export class TogetherHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			messages: openAiMessages,
 			temperature: 0,

src/api/providers/vertex.ts

@@ -7,25 +7,49 @@ import { ApiStream } from "@api/transform/stream"
 import { GeminiHandler } from "./gemini"
 
 export class VertexHandler implements ApiHandler {
-	private geminiHandler: GeminiHandler
-	private clientAnthropic: AnthropicVertex
+	private geminiHandler: GeminiHandler | undefined
+	private clientAnthropic: AnthropicVertex | undefined
 	private options: ApiHandlerOptions
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
+	}
 
-		// Create a GeminiHandler with isVertex flag for Gemini models
-		this.geminiHandler = new GeminiHandler({
-			...options,
-			isVertex: true,
-		})
+	private ensureGeminiHandler(): GeminiHandler {
+		if (!this.geminiHandler) {
+			try {
+				// Create a GeminiHandler with isVertex flag for Gemini models
+				this.geminiHandler = new GeminiHandler({
+					...this.options,
+					isVertex: true,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Vertex AI Gemini handler: ${error.message}`)
+			}
+		}
+		return this.geminiHandler
+	}
 
-		// Initialize Anthropic client for Claude models
-		this.clientAnthropic = new AnthropicVertex({
-			projectId: this.options.vertexProjectId,
-			// https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude#regions
-			region: this.options.vertexRegion,
-		})
+	private ensureAnthropicClient(): AnthropicVertex {
+		if (!this.clientAnthropic) {
+			if (!this.options.vertexProjectId) {
+				throw new Error("Vertex AI project ID is required")
+			}
+			if (!this.options.vertexRegion) {
+				throw new Error("Vertex AI region is required")
+			}
+			try {
+				// Initialize Anthropic client for Claude models
+				this.clientAnthropic = new AnthropicVertex({
+					projectId: this.options.vertexProjectId,
+					// https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude#regions
+					region: this.options.vertexRegion,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Vertex AI Anthropic client: ${error.message}`)
+			}
+		}
+		return this.clientAnthropic
 	}
 
 	@withRetry()
@@ -35,10 +59,13 @@ export class VertexHandler implements ApiHandler {
 
 		// For Gemini models, use the GeminiHandler
 		if (!modelId.includes("claude")) {
-			yield* this.geminiHandler.createMessage(systemPrompt, messages)
+			const geminiHandler = this.ensureGeminiHandler()
+			yield* geminiHandler.createMessage(systemPrompt, messages)
 			return
 		}
 
+		const clientAnthropic = this.ensureAnthropicClient()
+
 		// Claude implementation
 		let budget_tokens = this.options.thinkingBudgetTokens || 0
 		const reasoningOn =
@@ -63,7 +90,7 @@ export class VertexHandler implements ApiHandler {
 				)
 				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
 				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
-				stream = await this.clientAnthropic.beta.messages.create(
+				stream = await clientAnthropic.beta.messages.create(
 					{
 						model: modelId,
 						max_tokens: model.info.maxTokens || 8192,
@@ -125,7 +152,7 @@ export class VertexHandler implements ApiHandler {
 				break
 			}
 			default: {
-				stream = await this.clientAnthropic.beta.messages.create({
+				stream = await clientAnthropic.beta.messages.create({
 					model: modelId,
 					max_tokens: model.info.maxTokens || 8192,
 					temperature: 0,

src/api/providers/xai.ts

@@ -9,18 +9,32 @@ import { withRetry } from "../retry"
 
 export class XAIHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: OpenAI
+	private client: OpenAI | undefined
 
 	constructor(options: ApiHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.x.ai/v1",
-			apiKey: this.options.xaiApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.xaiApiKey) {
+				throw new Error("xAI API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.x.ai/v1",
+					apiKey: this.options.xaiApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating xAI client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.getModel().id
 		// ensure reasoning effort is either "low" or "high" for grok-3-mini
 		let reasoningEffort: ChatCompletionReasoningEffort | undefined
@@ -30,7 +44,7 @@ export class XAIHandler implements ApiHandler {
 				reasoningEffort = undefined
 			}
 		}
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			max_completion_tokens: this.getModel().info.maxTokens,
 			temperature: 0,

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

@@ -156,6 +156,45 @@ replaced
 			expected: "line2\nreplaced\nline4",
 			isFinal: true,
 		},
+		{
+			name: "malformed diff - missing separator",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
++++++++ REPLACE
+replaced`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - trailing space on separator",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
+======= 
+replaced
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - double replace markers",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
++++++++ REPLACE
+first replacement
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - malformed separator with dashes",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
+------- =======
+replaced
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
 	]
 	//.filter(({name}) => name === "multiple ordered replacements")
 	//.filter(({name}) => name === "delete then replace")

src/core/assistant-message/diff.ts

@@ -380,6 +380,10 @@ async function constructNewFileContentV1(diffContent: string, originalContent: s
 		if (isReplaceBlockEnd(line)) {
 			// Finished one replace block
 
+			if (searchMatchIndex === -1) {
+				throw new Error(`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`)
+			}
+
 			// Store this replacement
 			replacements.push({
 				start: searchMatchIndex,

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

@@ -36,17 +36,6 @@ export class FileContextTracker {
 		this.taskId = taskId
 	}
 
-	/**
-	 * Gets the current working directory or returns undefined if it cannot be determined
-	 */
-	private async getCwd(): Promise<string | undefined> {
-		const cwd = await getCwd(undefined)
-		if (!cwd) {
-			console.info("No workspace folder available - cannot determine current working directory")
-		}
-		return cwd
-	}
-
 	/**
 	 * File watchers are set up for each file that is tracked in the task metadata.
 	 */
@@ -56,8 +45,9 @@ export class FileContextTracker {
 			return
 		}
 
-		const cwd = await this.getCwd()
+		const cwd = await getCwd()
 		if (!cwd) {
+			console.info("No workspace folder available - cannot determine current working directory")
 			return
 		}
 
@@ -87,8 +77,9 @@ export class FileContextTracker {
 	 */
 	async trackFileContext(filePath: string, operation: "read_tool" | "user_edited" | "cline_edited" | "file_mentioned") {
 		try {
-			const cwd = await this.getCwd()
+			const cwd = await getCwd()
 			if (!cwd) {
+				console.info("No workspace folder available - cannot determine current working directory")
 				return
 			}
 
@@ -244,7 +235,9 @@ export class FileContextTracker {
 	async storePendingFileContextWarning(files: string[]): Promise<void> {
 		try {
 			const key = `pendingFileContextWarning_${this.taskId}`
-			await updateWorkspaceState(this.context, key, files)
+			// NOTE: Using 'as any' because dynamic keys like pendingFileContextWarning_${taskId}
+			// are legitimate workspace state keys but don't fit the strict LocalStateKey type system
+			await updateWorkspaceState(this.context, key as any, files)
 		} catch (error) {
 			console.error("Error storing pending file context warning:", error)
 		}
@@ -256,7 +249,7 @@ export class FileContextTracker {
 	async retrievePendingFileContextWarning(): Promise<string[] | undefined> {
 		try {
 			const key = `pendingFileContextWarning_${this.taskId}`
-			const files = (await getWorkspaceState(this.context, key)) as string[]
+			const files = (await getWorkspaceState(this.context, key as any)) as string[]
 			return files
 		} catch (error) {
 			console.error("Error retrieving pending file context warning:", error)
@@ -271,7 +264,7 @@ export class FileContextTracker {
 		try {
 			const files = await this.retrievePendingFileContextWarning()
 			if (files) {
-				await updateWorkspaceState(this.context, `pendingFileContextWarning_${this.taskId}`, undefined)
+				await updateWorkspaceState(this.context, `pendingFileContextWarning_${this.taskId}` as any, undefined)
 				return files
 			}
 		} catch (error) {
@@ -302,7 +295,7 @@ export class FileContextTracker {
 
 			if (orphanedPendingContextTasks.length > 0) {
 				for (const key of orphanedPendingContextTasks) {
-					await updateWorkspaceState(context, key, undefined)
+					await updateWorkspaceState(context, key as any, undefined)
 				}
 			}
 

src/core/controller/account/accountLoginClicked.ts

@@ -1,8 +1,9 @@
-import * as vscode from "vscode"
-import crypto from "crypto"
 import { Controller } from "../index"
-import { storeSecret } from "../../storage/state"
+import { AuthService } from "@/services/auth/AuthService"
 import { EmptyRequest, String } from "../../../shared/proto/common"
+import { openExternal } from "@utils/env"
+
+const authService = AuthService.getInstance()
 
 /**
  * Handles the user clicking the login link in the UI.
@@ -13,21 +14,5 @@ import { EmptyRequest, String } from "../../../shared/proto/common"
  * @returns The login URL as a string.
  */
 export async function accountLoginClicked(controller: Controller, _: EmptyRequest): Promise<String> {
-	// Generate nonce for state validation
-	const nonce = crypto.randomBytes(32).toString("hex")
-	await storeSecret(controller.context, "authNonce", nonce)
-
-	// Open browser for authentication with state param
-	console.log("Login button clicked in account page")
-	console.log("Opening auth page with state param")
-
-	const uriScheme = vscode.env.uriScheme
-
-	const authUrl = vscode.Uri.parse(
-		`https://app.cline.bot/auth?state=${encodeURIComponent(nonce)}&callback_url=${encodeURIComponent(`${uriScheme || "vscode"}://saoudrizwan.claude-dev/auth`)}`,
-	)
-	await vscode.env.openExternal(authUrl)
-	return String.create({
-		value: authUrl.toString(),
-	})
+	return await authService.createAuthRequest()
 }

src/core/controller/account/accountLogoutClicked.ts

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

src/core/controller/account/authStateChanged.ts

@@ -1,4 +1,4 @@
-import { AuthStateChangedRequest, AuthStateChanged } from "@shared/proto/account"
+import { AuthStateChangedRequest, AuthState } from "@shared/proto/account"
 import type { Controller } from "../index"
 import { updateGlobalState } from "../../storage/state"
 
@@ -9,13 +9,13 @@ import { updateGlobalState } from "../../storage/state"
  * @param request The auth state change request
  * @returns The updated user info
  */
-export async function authStateChanged(controller: Controller, request: AuthStateChangedRequest): Promise<AuthStateChanged> {
+export async function authStateChanged(controller: Controller, request: AuthStateChangedRequest): Promise<AuthState> {
 	try {
 		// Store the user info directly in global state
 		await updateGlobalState(controller.context, "userInfo", request.user)
 
 		// Return the same user info
-		return AuthStateChanged.create({ user: request.user })
+		return AuthState.create({ user: request.user })
 	} catch (error) {
 		console.error(`Failed to update auth state: ${error}`)
 		throw error

src/core/controller/account/getOrganizationCredits.ts

@@ -0,0 +1,50 @@
+import type { Controller } from "../index"
+import { GetOrganizationCreditsRequest, OrganizationCreditsData, OrganizationUsageTransaction } from "@shared/proto/account"
+
+/**
+ * Handles fetching all organization credits data (balance, usage, payments)
+ * @param controller The controller instance
+ * @param request Organization credits request
+ * @returns Organization credits data response
+ */
+export async function getOrganizationCredits(
+	controller: Controller,
+	request: GetOrganizationCreditsRequest,
+): Promise<OrganizationCreditsData> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Call the individual RPC variants in parallel
+		const [balanceData, usageTransactions] = await Promise.all([
+			controller.accountService.fetchOrganizationCreditsRPC(request.organizationId),
+			controller.accountService.fetchOrganizationUsageTransactionsRPC(request.organizationId),
+		])
+
+		return OrganizationCreditsData.create({
+			balance: balanceData ? { currentBalance: balanceData.balance / 100 } : { currentBalance: 0 },
+			organizationId: balanceData?.organizationId || "",
+			usageTransactions:
+				usageTransactions?.map((tx) =>
+					OrganizationUsageTransaction.create({
+						aiInferenceProviderName: tx.aiInferenceProviderName,
+						aiModelName: tx.aiModelName,
+						aiModelTypeName: tx.aiModelTypeName,
+						completionTokens: tx.completionTokens,
+						costUsd: tx.costUsd,
+						createdAt: tx.createdAt,
+						creditsUsed: tx.creditsUsed,
+						generationId: tx.generationId,
+						organizationId: tx.organizationId,
+						promptTokens: tx.promptTokens,
+						totalTokens: tx.totalTokens,
+						userId: tx.userId,
+					}),
+				) || [],
+		})
+	} catch (error) {
+		console.error(`Failed to fetch organization credits data: ${error}`)
+		throw error
+	}
+}

src/core/controller/account/getUserCredits.ts

@@ -8,7 +8,7 @@ import { UserCreditsData } from "@shared/proto/account"
  * @param request Empty request
  * @returns User credits data response
  */
-export async function fetchUserCreditsData(controller: Controller, request: EmptyRequest): Promise<UserCreditsData> {
+export async function getUserCredits(controller: Controller, request: EmptyRequest): Promise<UserCreditsData> {
 	try {
 		if (!controller.accountService) {
 			throw new Error("Account service not available")
@@ -21,11 +21,10 @@ export async function fetchUserCreditsData(controller: Controller, request: Empt
 			controller.accountService.fetchPaymentTransactionsRPC(),
 		])
 
-		// Since generated types match exactly, no conversion needed!
 		return UserCreditsData.create({
-			balance: balance ? { currentBalance: balance.currentBalance } : { currentBalance: 0 },
-			usageTransactions: usageTransactions || [],
-			paymentTransactions: paymentTransactions || [],
+			balance: balance ? { currentBalance: balance.balance / 100 } : { currentBalance: 0 },
+			usageTransactions: usageTransactions,
+			paymentTransactions: paymentTransactions,
 		})
 	} catch (error) {
 		console.error(`Failed to fetch user credits data: ${error}`)

src/core/controller/account/getUserOrganizations.ts

@@ -0,0 +1,35 @@
+import type { Controller } from "../index"
+import type { EmptyRequest } from "@shared/proto/common"
+import { UserOrganization, UserOrganizationsResponse } from "@shared/proto/account"
+
+/**
+ * Handles fetching all user credits data (balance, usage, payments)
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns User credits data response
+ */
+export async function getUserOrganizations(controller: Controller, request: EmptyRequest): Promise<UserOrganizationsResponse> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Fetch user organizations from the account service
+		const organizations = await controller.accountService.fetchUserOrganizationsRPC()
+
+		return UserOrganizationsResponse.create({
+			organizations:
+				organizations?.map((org) =>
+					UserOrganization.create({
+						active: org.active,
+						memberId: org.memberId,
+						name: org.name,
+						organizationId: org.organizationId,
+						roles: org.roles ? [...org.roles] : [],
+					}),
+				) || [],
+		})
+	} catch (error) {
+		throw error
+	}
+}

src/core/controller/account/setUserOrganization.ts

@@ -0,0 +1,24 @@
+import type { Controller } from "../index"
+import { Empty } from "@shared/proto/common"
+import { UserOrganizationUpdateRequest } from "@shared/proto/account"
+
+/**
+ * Handles setting the user's active organization
+ * @param controller The controller instance
+ * @param request UserOrganization to set as active
+ * @returns Empty response
+ */
+export async function setUserOrganization(controller: Controller, request: UserOrganizationUpdateRequest): Promise<Empty> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		// Switch to the specified organization using the account service
+		await controller.accountService.switchAccount(request.organizationId)
+
+		return Empty.create({})
+	} catch (error) {
+		throw error
+	}
+}

src/core/controller/account/subscribeToAuthCallback.ts

@@ -1,59 +0,0 @@
-import { Controller } from "../index"
-import { EmptyRequest } from "../../../shared/proto/common"
-import { String as ProtoString } from "../../../shared/proto/common"
-import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
-
-// Keep track of active authCallback subscriptions
-const activeAuthCallbackSubscriptions = new Set<StreamingResponseHandler>()
-
-/**
- * Subscribe to authCallback events
- * @param controller The controller instance
- * @param request The empty request
- * @param responseStream The streaming response handler
- * @param requestId The ID of the request (passed by the gRPC handler)
- */
-export async function subscribeToAuthCallback(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
-	requestId?: string,
-): Promise<void> {
-	// Add this subscription to the active subscriptions
-	activeAuthCallbackSubscriptions.add(responseStream)
-
-	// Register cleanup when the connection is closed
-	const cleanup = () => {
-		activeAuthCallbackSubscriptions.delete(responseStream)
-	}
-
-	// Register the cleanup function with the request registry if we have a requestId
-	if (requestId) {
-		getRequestRegistry().registerRequest(requestId, cleanup, { type: "authCallback_subscription" }, responseStream)
-	}
-}
-
-/**
- * Send an authCallback event to all active subscribers
- * @param customToken The custom token for authentication
- */
-export async function sendAuthCallbackEvent(customToken: string): Promise<void> {
-	// Send the event to all active subscribers
-	const promises = Array.from(activeAuthCallbackSubscriptions).map(async (responseStream) => {
-		try {
-			const event: ProtoString = {
-				value: customToken,
-			}
-			await responseStream(
-				event,
-				false, // Not the last message
-			)
-		} catch (error) {
-			console.error("Error sending authCallback event:", error)
-			// Remove the subscription if there was an error
-			activeAuthCallbackSubscriptions.delete(responseStream)
-		}
-	})
-
-	await Promise.all(promises)
-}

src/core/controller/account/subscribeToAuthStatusUpdate.ts

@@ -0,0 +1,5 @@
+import { AuthService } from "../../../services/auth/AuthService"
+
+const authService = AuthService.getInstance()
+export const subscribeToAuthStatusUpdate = authService.subscribeToAuthStatusUpdate.bind(authService)
+export const sendAuthStatusUpdateEvent = authService.sendAuthStatusUpdate.bind(authService)

src/core/controller/file/createRuleFile.ts

@@ -6,8 +6,8 @@ import { createRuleFile as createRuleFileImpl } from "@core/context/instructions
 import * as vscode from "vscode"
 import * as path from "path"
 import { handleFileServiceRequest } from "./index"
-import { cwd } from "@core/task"
 import { refreshWorkflowToggles } from "@/core/context/instructions/user-instructions/workflows"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 /**
  * Creates a rule file in either global or workspace rules directory
@@ -32,6 +32,7 @@ export const createRuleFile: FileMethodHandler = async (controller: Controller,
 		throw new Error("Missing or invalid parameters")
 	}
 
+	const cwd = await getCwd(getDesktopDir())
 	const { filePath, fileExists } = await createRuleFileImpl(request.isGlobal, request.filename, cwd, request.type)
 
 	if (!filePath) {

src/core/controller/file/getRelativePaths.ts

@@ -1,10 +1,10 @@
-import { Controller } from ".."
-import { RelativePathsRequest, RelativePaths } from "@shared/proto/file"
-import { FileMethodHandler } from "./index"
-import * as vscode from "vscode"
+import { asRelativePath } from "@/utils/path"
+import { RelativePaths, RelativePathsRequest } from "@shared/proto/file"
 import * as path from "path"
-import { StringRequest } from "@shared/proto/common"
-import { getHostBridgeProvider } from "@hosts/host-providers"
+import { URI } from "vscode-uri"
+import { Controller } from ".."
+import { FileMethodHandler } from "./index"
+import { isDirectory } from "@/utils/fs"
 
 /**
  * Converts a list of URIs to workspace-relative paths
@@ -13,47 +13,32 @@ import { getHostBridgeProvider } from "@hosts/host-providers"
  * @returns Response with resolved relative paths
  */
 export const getRelativePaths: FileMethodHandler = async (
-	controller: Controller,
+	_controller: Controller,
 	request: RelativePathsRequest,
 ): Promise<RelativePaths> => {
-	const resolvedPaths = await Promise.all(
-		request.uris.map(async (uriString) => {
-			try {
-				// Use the host URI service client instead of directly using vscode.Uri.parse
-				const parseResponse = await getHostBridgeProvider().uriServiceClient.parse(
-					StringRequest.create({
-						value: uriString,
-					}),
-				)
-				const fileUri = vscode.Uri.parse(`${parseResponse.scheme}://${parseResponse.authority}${parseResponse.path}`)
-				console.log("[DEBUG] UriServiceClient.parse:", fileUri)
-				const relativePathToGet = vscode.workspace.asRelativePath(fileUri, false)
-
-				// If the path is still absolute, it's outside the workspace
-				if (path.isAbsolute(relativePathToGet)) {
-					console.warn(`Dropped file ${relativePathToGet} is outside the workspace. Sending original path.`)
-					return fileUri.fsPath.replace(/\\/g, "/")
-				} else {
-					let finalPath = "/" + relativePathToGet.replace(/\\/g, "/")
-					try {
-						const stat = await vscode.workspace.fs.stat(fileUri)
-						if (stat.type === vscode.FileType.Directory) {
-							finalPath += "/"
-						}
-					} catch (statError) {
-						console.error(`Error stating file ${fileUri.fsPath}:`, statError)
-					}
-					return finalPath
-				}
-			} catch (error) {
-				console.error(`Error calculating relative path for ${uriString}:`, error)
-				return null
-			}
-		}),
-	)
-
-	// Filter out any null values from errors
-	const validPaths = resolvedPaths.filter((path): path is string => path !== null)
-
-	return RelativePaths.create({ paths: validPaths })
+	const result = []
+	for (const uriString of request.uris) {
+		try {
+			result.push(await getRelativePath(uriString))
+		} catch (error) {
+			console.error(`Error calculating relative path for ${uriString}:`, error)
+		}
+	}
+	return RelativePaths.create({ paths: result })
+}
+
+async function getRelativePath(uriString: string): Promise<string> {
+	const filePath = URI.parse(uriString, true).fsPath
+	const relativePath = await asRelativePath(filePath)
+
+	// If the path is still absolute, it's outside the workspace
+	if (path.isAbsolute(relativePath)) {
+		throw new Error(`Dropped file ${relativePath} is outside the workspace.`)
+	}
+
+	let result = "/" + relativePath.replace(/\\/g, "/")
+	if (await isDirectory(filePath)) {
+		result += "/"
+	}
+	return result
 }

src/core/controller/file/refreshRules.ts

@@ -4,7 +4,7 @@ import type { Controller } from "../index"
 import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
 import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
 import { refreshWorkflowToggles } from "@core/context/instructions/user-instructions/workflows"
-import { cwd } from "@core/task"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 /**
  * Refreshes all rule toggles (Cline, External, and Workflows)
@@ -14,6 +14,7 @@ import { cwd } from "@core/task"
  */
 export async function refreshRules(controller: Controller, _request: EmptyRequest): Promise<RefreshedRules> {
 	try {
+		const cwd = await getCwd(getDesktopDir())
 		const { globalToggles, localToggles } = await refreshClineRulesToggles(controller.context, cwd)
 		const { cursorLocalToggles, windsurfLocalToggles } = await refreshExternalRulesToggles(controller.context, cwd)
 		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(controller.context, cwd)

src/core/controller/index.ts

@@ -1,5 +1,5 @@
 import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
-import { getCwd } from "@/utils/path"
+import { getCwd, getDesktopDir } from "@/utils/path"
 import { Anthropic } from "@anthropic-ai/sdk"
 import { buildApiHandler } from "@api/index"
 import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
@@ -30,18 +30,17 @@ import { ensureMcpServersDirectoryExists, ensureSettingsDirectoryExists, GlobalF
 import {
 	getAllExtensionState,
 	getGlobalState,
-	getSecret,
 	getWorkspaceState,
 	storeSecret,
 	updateGlobalState,
 	updateWorkspaceState,
 } from "../storage/state"
 import { Task } from "../task"
-import { sendAuthCallbackEvent } from "./account/subscribeToAuthCallback"
 import { handleGrpcRequest, handleGrpcRequestCancel } from "./grpc-handler"
-import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
 import { sendStateUpdate } from "./state/subscribeToState"
 import { sendAddToInputEvent } from "./ui/subscribeToAddToInput"
+import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
+import { AuthService } from "@/services/auth/AuthService"
 
 /*
 https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -54,11 +53,11 @@ export class Controller {
 	private postMessage: (message: ExtensionMessage) => Thenable<boolean> | undefined
 
 	private disposables: vscode.Disposable[] = []
-	private mode: "plan" | "act" = "plan" // In-memory plan/act mode state
 	task?: Task
 	workspaceTracker: WorkspaceTracker
 	mcpHub: McpHub
 	accountService: ClineAccountService
+	authService: AuthService
 	latestAnnouncementId = "june-25-2025_16:11:00" // update to some unique identifier when we add a new announcement
 
 	constructor(
@@ -78,13 +77,9 @@ export class Controller {
 			(msg) => this.postMessageToWebview(msg),
 			this.context.extension?.packageJSON?.version ?? "1.0.0",
 		)
-		this.accountService = new ClineAccountService(
-			(msg) => this.postMessageToWebview(msg),
-			async () => {
-				const { apiConfiguration } = await this.getStateToPostToWebview()
-				return apiConfiguration?.clineApiKey
-			},
-		)
+		this.accountService = ClineAccountService.getInstance()
+		this.authService = AuthService.getInstance(context)
+		this.authService.restoreAuthToken()
 
 		// Clean up legacy checkpoints
 		cleanupLegacyCheckpoints(this.context.globalStorageUri.fsPath, this.outputChannel).catch((error) => {
@@ -92,6 +87,10 @@ export class Controller {
 		})
 	}
 
+	private async getCurrentMode(): Promise<"plan" | "act"> {
+		return ((await getGlobalState(this.context, "mode")) as "plan" | "act" | undefined) || "act"
+	}
+
 	/*
 	VSCode extensions use the disposable pattern to clean up resources when the sidebar/editor tab is closed by the user or system. This applies to event listening, commands, interacting with the UI, etc.
 	- https://vscode-docs.readthedocs.io/en/stable/extensions/patterns-and-principles/
@@ -114,9 +113,10 @@ export class Controller {
 	// Auth methods
 	async handleSignOut() {
 		try {
-			await storeSecret(this.context, "clineApiKey", undefined)
+			// TODO: update to clineAccountId and then move clineApiKey to a clear function.
+			await storeSecret(this.context, "clineAccountId", undefined)
 			await updateGlobalState(this.context, "userInfo", undefined)
-			await updateWorkspaceState(this.context, "apiProvider", "openrouter")
+			await updateGlobalState(this.context, "apiProvider", "openrouter")
 			await this.postStateToWebview()
 			vscode.window.showInformationMessage("Successfully logged out of Cline")
 		} catch (error) {
@@ -144,10 +144,13 @@ export class Controller {
 			taskHistory,
 		} = await getAllExtensionState(this.context)
 
-		// Reconstruct ChatSettings with in-memory mode and stored preferences
+		// Get current mode using helper function
+		const currentMode = await this.getCurrentMode()
+
+		// Reconstruct ChatSettings with mode from global state and stored preferences
 		const chatSettings: ChatSettings = {
 			...storedChatSettings, // Spread stored preferences (preferredLanguage, openAIReasoningEffort)
-			mode: this.mode, // Use in-memory mode (override any stored mode)
+			mode: currentMode, // Use mode from global state
 		}
 
 		const NEW_USER_TASK_COUNT_THRESHOLD = 10
@@ -182,6 +185,7 @@ export class Controller {
 			terminalOutputLineLimit ?? 500,
 			defaultTerminalProfile ?? "default",
 			enableCheckpointsSetting ?? true,
+			await getCwd(getDesktopDir()),
 			task,
 			images,
 			files,
@@ -241,8 +245,8 @@ export class Controller {
 	async togglePlanActModeWithChatSettings(chatSettings: ChatSettings, chatContent?: ChatContent): Promise<boolean> {
 		const didSwitchToActMode = chatSettings.mode === "act"
 
-		// Store mode in-memory only
-		this.mode = chatSettings.mode
+		// Store mode to global state
+		await updateGlobalState(this.context, "mode", chatSettings.mode)
 
 		// Capture mode switch telemetry | Capture regardless of if we know the taskId
 		telemetryService.captureModeSwitch(this.task?.taskId ?? "0", chatSettings.mode)
@@ -258,11 +262,6 @@ export class Controller {
 			previousModeReasoningEffort: newReasoningEffort,
 			previousModeAwsBedrockCustomSelected: newAwsBedrockCustomSelected,
 			previousModeAwsBedrockCustomModelBaseId: newAwsBedrockCustomModelBaseId,
-			previousModeSapAiCoreClientId: newSapAiCoreClientId,
-			previousModeSapAiCoreClientSecret: newSapAiCoreClientSecret,
-			previousModeSapAiCoreBaseUrl: newSapAiCoreBaseUrl,
-			previousModeSapAiCoreTokenUrl: newSapAiCoreTokenUrl,
-			previousModeSapAiCoreResourceGroup: newSapAiResourceGroup,
 			previousModeSapAiCoreModelId: newSapAiCoreModelId,
 			planActSeparateModelsSetting,
 		} = await getAllExtensionState(this.context)
@@ -271,9 +270,9 @@ export class Controller {
 
 		if (shouldSwitchModel) {
 			// Save the last model used in this mode
-			await updateWorkspaceState(this.context, "previousModeApiProvider", apiConfiguration.apiProvider)
-			await updateWorkspaceState(this.context, "previousModeThinkingBudgetTokens", apiConfiguration.thinkingBudgetTokens)
-			await updateWorkspaceState(this.context, "previousModeReasoningEffort", apiConfiguration.reasoningEffort)
+			await updateGlobalState(this.context, "previousModeApiProvider", apiConfiguration.apiProvider)
+			await updateGlobalState(this.context, "previousModeThinkingBudgetTokens", apiConfiguration.thinkingBudgetTokens)
+			await updateGlobalState(this.context, "previousModeReasoningEffort", apiConfiguration.reasoningEffort)
 			switch (apiConfiguration.apiProvider) {
 				case "anthropic":
 				case "vertex":
@@ -283,16 +282,16 @@ export class Controller {
 				case "qwen":
 				case "deepseek":
 				case "xai":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
 					break
 				case "bedrock":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateWorkspaceState(
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(
 						this.context,
 						"previousModeAwsBedrockCustomSelected",
 						apiConfiguration.awsBedrockCustomSelected,
 					)
-					await updateWorkspaceState(
+					await updateGlobalState(
 						this.context,
 						"previousModeAwsBedrockCustomModelBaseId",
 						apiConfiguration.awsBedrockCustomModelBaseId,
@@ -300,51 +299,38 @@ export class Controller {
 					break
 				case "openrouter":
 				case "cline":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.openRouterModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.openRouterModelInfo)
 					break
 				case "vscode-lm":
 					// Important we don't set modelId to this, as it's an object not string (webview expects model id to be a string)
-					await updateWorkspaceState(
+					await updateGlobalState(
 						this.context,
 						"previousModeVsCodeLmModelSelector",
 						apiConfiguration.vsCodeLmModelSelector,
 					)
 					break
 				case "openai":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.openAiModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.openAiModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openAiModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.openAiModelInfo)
 					break
 				case "ollama":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.ollamaModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.ollamaModelId)
 					break
 				case "lmstudio":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.lmStudioModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.lmStudioModelId)
 					break
 				case "litellm":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.liteLlmModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.liteLlmModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.liteLlmModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.liteLlmModelInfo)
 					break
 				case "requesty":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.requestyModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.requestyModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.requestyModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.requestyModelInfo)
 					break
 				case "sapaicore":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreClientId", apiConfiguration.sapAiCoreClientId)
-					await updateWorkspaceState(
-						this.context,
-						"previousModeSapAiCoreClientSecret",
-						apiConfiguration.sapAiCoreClientSecret,
-					)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreBaseUrl", apiConfiguration.sapAiCoreBaseUrl)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreTokenUrl", apiConfiguration.sapAiCoreTokenUrl)
-					await updateWorkspaceState(
-						this.context,
-						"previousModeSapAiCoreResourceGroup",
-						apiConfiguration.sapAiResourceGroup,
-					)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreModelId", apiConfiguration.sapAiCoreModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(this.context, "previousModeSapAiCoreModelId", apiConfiguration.sapAiCoreModelId)
 					break
 			}
 
@@ -356,9 +342,9 @@ export class Controller {
 				newReasoningEffort ||
 				newVsCodeLmModelSelector
 			) {
-				await updateWorkspaceState(this.context, "apiProvider", newApiProvider)
-				await updateWorkspaceState(this.context, "thinkingBudgetTokens", newThinkingBudgetTokens)
-				await updateWorkspaceState(this.context, "reasoningEffort", newReasoningEffort)
+				await updateGlobalState(this.context, "apiProvider", newApiProvider)
+				await updateGlobalState(this.context, "thinkingBudgetTokens", newThinkingBudgetTokens)
+				await updateGlobalState(this.context, "reasoningEffort", newReasoningEffort)
 				switch (newApiProvider) {
 					case "anthropic":
 					case "vertex":
@@ -368,41 +354,42 @@ export class Controller {
 					case "qwen":
 					case "deepseek":
 					case "xai":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
 						break
 					case "bedrock":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
-						await updateWorkspaceState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
-						await updateWorkspaceState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
+						await updateGlobalState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
 						break
 					case "openrouter":
 					case "cline":
-						await updateWorkspaceState(this.context, "openRouterModelId", newModelId)
-						await updateWorkspaceState(this.context, "openRouterModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "openRouterModelId", newModelId)
+						await updateGlobalState(this.context, "openRouterModelInfo", newModelInfo)
 						break
 					case "vscode-lm":
-						await updateWorkspaceState(this.context, "vsCodeLmModelSelector", newVsCodeLmModelSelector)
+						await updateGlobalState(this.context, "vsCodeLmModelSelector", newVsCodeLmModelSelector)
 						break
 					case "openai":
-						await updateWorkspaceState(this.context, "openAiModelId", newModelId)
-						await updateWorkspaceState(this.context, "openAiModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "openAiModelId", newModelId)
+						await updateGlobalState(this.context, "openAiModelInfo", newModelInfo)
 						break
 					case "ollama":
-						await updateWorkspaceState(this.context, "ollamaModelId", newModelId)
+						await updateGlobalState(this.context, "ollamaModelId", newModelId)
 						break
 					case "lmstudio":
-						await updateWorkspaceState(this.context, "lmStudioModelId", newModelId)
+						await updateGlobalState(this.context, "lmStudioModelId", newModelId)
 						break
 					case "litellm":
-						await updateWorkspaceState(this.context, "liteLlmModelId", newModelId)
-						await updateWorkspaceState(this.context, "liteLlmModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "liteLlmModelId", newModelId)
+						await updateGlobalState(this.context, "liteLlmModelInfo", newModelInfo)
 						break
 					case "requesty":
-						await updateWorkspaceState(this.context, "requestyModelId", newModelId)
-						await updateWorkspaceState(this.context, "requestyModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "requestyModelId", newModelId)
+						await updateGlobalState(this.context, "requestyModelInfo", newModelInfo)
 						break
 					case "sapaicore":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "sapAiCoreModelId", newSapAiCoreModelId)
 						break
 				}
 
@@ -413,9 +400,9 @@ export class Controller {
 			}
 		}
 
-		// Save only non-mode properties to workspace storage
+		// Save only non-mode properties to global storage
 		const { mode, ...persistentChatSettings }: { mode: string } & StoredChatSettings = chatSettings
-		await updateWorkspaceState(this.context, "chatSettings", persistentChatSettings)
+		await updateGlobalState(this.context, "chatSettings", persistentChatSettings)
 		await this.postStateToWebview()
 
 		if (this.task) {
@@ -470,33 +457,29 @@ export class Controller {
 	}
 
 	// Auth
-
 	public async validateAuthState(state: string | null): Promise<boolean> {
-		const storedNonce = await getSecret(this.context, "authNonce")
+		const storedNonce = this.authService.authNonce
 		if (!state || state !== storedNonce) {
 			return false
 		}
-		await storeSecret(this.context, "authNonce", undefined) // Clear after use
+		this.authService.resetAuthNonce() // Clear the nonce after validation
 		return true
 	}
 
-	async handleAuthCallback(customToken: string, apiKey: string) {
+	async handleAuthCallback(customToken: string, provider: string | null = null) {
 		try {
-			// Store API key for API calls
-			await storeSecret(this.context, "clineApiKey", apiKey)
-
-			// Send custom token to webview for Firebase auth
-			await sendAuthCallbackEvent(customToken)
+			await this.authService.handleAuthCallback(customToken, provider ? provider : "google")
 
 			const clineProvider: ApiProvider = "cline"
-			await updateWorkspaceState(this.context, "apiProvider", clineProvider)
+			await updateGlobalState(this.context, "apiProvider", clineProvider)
+
+			// Mark welcome view as completed since user has successfully logged in
+			await updateGlobalState(this.context, "welcomeViewCompleted", true)
 
-			// Update API configuration with the new provider and API key
 			const { apiConfiguration } = await getAllExtensionState(this.context)
 			const updatedConfig = {
 				...apiConfiguration,
 				apiProvider: clineProvider,
-				clineApiKey: apiKey,
 			}
 
 			if (this.task) {
@@ -504,7 +487,6 @@ export class Controller {
 			}
 
 			await this.postStateToWebview()
-			// vscode.window.showInformationMessage("Successfully logged in to Cline")
 		} catch (error) {
 			console.error("Failed to handle auth callback:", error)
 			vscode.window.showErrorMessage("Failed to log in to Cline")
@@ -514,7 +496,6 @@ export class Controller {
 	}
 
 	// MCP Marketplace
-
 	private async fetchMcpMarketplaceFromApi(silent: boolean = false): Promise<McpMarketplaceCatalog | undefined> {
 		try {
 			const response = await axios.get("https://api.cline.bot/v1/mcp/marketplace", {
@@ -648,7 +629,7 @@ export class Controller {
 		}
 
 		const openrouter: ApiProvider = "openrouter"
-		await updateWorkspaceState(this.context, "apiProvider", openrouter)
+		await updateGlobalState(this.context, "apiProvider", openrouter)
 		await storeSecret(this.context, "openRouterApiKey", apiKey)
 		await this.postStateToWebview()
 		if (this.task) {
@@ -848,14 +829,18 @@ export class Controller {
 			terminalReuseEnabled,
 			defaultTerminalProfile,
 			isNewUser,
+			welcomeViewCompleted,
 			mcpResponsesCollapsed,
 			terminalOutputLineLimit,
 		} = await getAllExtensionState(this.context)
 
-		// Reconstruct ChatSettings with in-memory mode and stored preferences
+		// Get current mode using helper function
+		const currentMode = await this.getCurrentMode()
+
+		// Reconstruct ChatSettings with mode from global state and stored preferences
 		const chatSettings: ChatSettings = {
 			...storedChatSettings, // Spread stored preferences (preferredLanguage, openAIReasoningEffort)
-			mode: this.mode, // Use in-memory mode (override any stored mode)
+			mode: currentMode, // Use mode from global state
 		}
 
 		const localClineRulesToggles =
@@ -902,6 +887,7 @@ export class Controller {
 			terminalReuseEnabled,
 			defaultTerminalProfile,
 			isNewUser,
+			welcomeViewCompleted: welcomeViewCompleted as boolean, // Can be undefined but is set to either true or false by the migration that runs on extension launch in extension.ts
 			mcpResponsesCollapsed,
 			terminalOutputLineLimit,
 		}
@@ -1081,6 +1067,4 @@ Commit message:`
 			vscode.window.showErrorMessage(`Failed to generate commit message: ${errorMessage}`)
 		}
 	}
-
-	// dev
 }

src/core/controller/mcp/downloadMcp.ts

@@ -1,6 +1,7 @@
 import { Controller } from ".."
-import { Empty, StringRequest } from "../../../shared/proto/common"
-import { McpServer, McpDownloadResponse } from "@shared/mcp"
+import { StringRequest } from "../../../shared/proto/common"
+import { McpDownloadResponse } from "../../../shared/proto/mcp"
+import { McpServer } from "@shared/mcp"
 import axios from "axios"
 import * as vscode from "vscode"
 import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
@@ -9,9 +10,9 @@ import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
  * Download an MCP server from the marketplace
  * @param controller The controller instance
  * @param request The request containing the MCP ID
- * @returns Empty response
+ * @returns MCP download response with details or error
  */
-export async function downloadMcp(controller: Controller, request: StringRequest): Promise<Empty> {
+export async function downloadMcp(controller: Controller, request: StringRequest): Promise<McpDownloadResponse> {
 	try {
 		// Check if mcpId is provided
 		if (!request.value) {
@@ -54,12 +55,6 @@ export async function downloadMcp(controller: Controller, request: StringRequest
 			throw new Error("Missing README content in MCP download response")
 		}
 
-		// Send details to webview
-		await controller.postMessageToWebview({
-			type: "mcpDownloadDetails",
-			mcpDownloadDetails: mcpDetails,
-		})
-
 		// Create task with context from README and added guidelines for MCP server installation
 		const task = `Set up the MCP server from ${mcpDetails.githubUrl} while adhering to these MCP server installation rules:
 - Start by loading the MCP documentation.
@@ -80,8 +75,17 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 		await controller.initTask(task)
 		await sendChatButtonClickedEvent(controller.id)
 
-		// Return an empty response - the client only cares if the call succeeded
-		return Empty.create()
+		// Return the download details directly
+		return McpDownloadResponse.create({
+			mcpId: mcpDetails.mcpId,
+			githubUrl: mcpDetails.githubUrl,
+			name: mcpDetails.name,
+			author: mcpDetails.author,
+			description: mcpDetails.description,
+			readmeContent: mcpDetails.readmeContent,
+			llmsInstallationContent: mcpDetails.llmsInstallationContent,
+			requiresApiKey: mcpDetails.requiresApiKey,
+		})
 	} catch (error) {
 		console.error("Failed to download MCP:", error)
 		let errorMessage = "Failed to download MCP"
@@ -100,13 +104,17 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 			errorMessage = error.message
 		}
 
-		// Show error in both notification and marketplace UI
-		vscode.window.showErrorMessage(errorMessage)
-		await controller.postMessageToWebview({
-			type: "mcpDownloadDetails",
+		// Return error in the response instead of throwing
+		return McpDownloadResponse.create({
+			mcpId: "",
+			githubUrl: "",
+			name: "",
+			author: "",
+			description: "",
+			readmeContent: "",
+			llmsInstallationContent: "",
+			requiresApiKey: false,
 			error: errorMessage,
 		})
-
-		throw error
 	}
 }

src/core/controller/models/refreshOpenRouterModels.ts

@@ -122,11 +122,6 @@ export async function refreshOpenRouterModels(
 						break
 				}
 
-				// add new model id
-				if (rawModel.id === "x-ai/grok-3-beta") {
-					models["x-ai/grok-3"] = modelInfo
-				}
-
 				models[rawModel.id] = modelInfo
 			}
 		} else {

src/core/controller/state/setWelcomeViewCompleted.ts

@@ -0,0 +1,25 @@
+import type { BooleanRequest } from "../../../shared/proto/common"
+import { Empty } from "../../../shared/proto/common"
+import type { Controller } from "../index"
+import { updateGlobalState } from "../../storage/state"
+
+/**
+ * Sets the welcomeViewCompleted flag to the specified boolean value
+ * @param controller The controller instance
+ * @param request The boolean request containing the value to set
+ * @returns Empty response
+ */
+export async function setWelcomeViewCompleted(controller: Controller, request: BooleanRequest): Promise<Empty> {
+	try {
+		// Update the global state to set welcomeViewCompleted to the requested value
+		await updateGlobalState(controller.context, "welcomeViewCompleted", request.value)
+
+		await controller.postStateToWebview()
+
+		console.log(`Welcome view completed set to: ${request.value}`)
+		return Empty.create({})
+	} catch (error) {
+		console.error("Failed to set welcome view completed:", error)
+		throw error
+	}
+}

src/core/controller/state/updateSettings.ts

@@ -58,7 +58,16 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 		// Update chat settings
 		if (request.chatSettings) {
 			const chatSettings = convertProtoChatSettingsToChatSettings(request.chatSettings)
-			await controller.context.workspaceState.update("chatSettings", chatSettings)
+
+			// Store mode to global state
+			if (chatSettings.mode !== undefined) {
+				await controller.context.globalState.update("mode", chatSettings.mode)
+			}
+
+			// Store chat settings (excluding mode) to global state
+			const { mode, ...globalChatSettings } = chatSettings
+			await controller.context.globalState.update("chatSettings", globalChatSettings)
+
 			if (controller.task) {
 				controller.task.chatSettings = chatSettings
 			}

src/core/controller/task/deleteTasksWithIds.ts

@@ -1,5 +1,6 @@
 import path from "path"
 import fs from "fs/promises"
+import vscode from "vscode"
 import { Controller } from ".."
 import { Empty, StringArrayRequest, BooleanRequest } from "../../../shared/proto/common"
 import { TaskMethodHandler } from "./index"
@@ -20,6 +21,18 @@ export const deleteTasksWithIds: TaskMethodHandler = async (
 		throw new Error("Missing task IDs")
 	}
 
+	const taskCount = request.value.length
+	const message =
+		taskCount === 1
+			? "Are you sure you want to delete this task? This action cannot be undone."
+			: `Are you sure you want to delete these ${taskCount} tasks? This action cannot be undone.`
+
+	const userChoice = await vscode.window.showWarningMessage(message, { modal: true }, "Delete")
+
+	if (userChoice === undefined) {
+		return Empty.create()
+	}
+
 	for (const id of request.value) {
 		await deleteTaskWithId(controller, id)
 	}

src/core/controller/task/newTask.ts

@@ -1,7 +1,6 @@
 import { Controller } from ".."
 import { Empty } from "../../../shared/proto/common"
 import { NewTaskRequest } from "../../../shared/proto/task"
-import { handleFileServiceRequest } from "../file"
 
 /**
  * Creates a new task with the given text and optional images

src/core/controller/ui/initializeWebview.ts

@@ -1,7 +1,7 @@
 import type { Controller } from "../index"
 import { EmptyRequest, Empty } from "@shared/proto/common"
 import { handleModelsServiceRequest } from "../models"
-import { getAllExtensionState, getGlobalState, updateWorkspaceState } from "../../storage/state"
+import { getAllExtensionState, getGlobalState, updateGlobalState } from "../../storage/state"
 import { sendOpenRouterModelsEvent } from "../models/subscribeToOpenRouterModels"
 import { sendMcpMarketplaceCatalogEvent } from "../mcp/subscribeToMcpMarketplaceCatalog"
 import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
@@ -32,7 +32,7 @@ export async function initializeWebview(controller: Controller, request: EmptyRe
 				// Update model info in state (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const { apiConfiguration } = await getAllExtensionState(controller.context)
 				if (apiConfiguration.openRouterModelId && response.models[apiConfiguration.openRouterModelId]) {
-					await updateWorkspaceState(
+					await updateGlobalState(
 						controller.context,
 						"openRouterModelInfo",
 						response.models[apiConfiguration.openRouterModelId],

src/core/controller/web/openInBrowser.ts

@@ -1,6 +1,6 @@
-import * as vscode from "vscode"
 import { Controller } from ".."
 import { Empty, StringRequest } from "../../../shared/proto/common"
+import { openExternal } from "@utils/env"
 
 /**
  * Opens a URL in the user's default browser
@@ -11,7 +11,7 @@ import { Empty, StringRequest } from "../../../shared/proto/common"
 export async function openInBrowser(controller: Controller, request: StringRequest): Promise<Empty> {
 	try {
 		if (request.value) {
-			await vscode.env.openExternal(vscode.Uri.parse(request.value))
+			await openExternal(request.value)
 		}
 		return Empty.create()
 	} catch (error) {

src/core/mentions/index.ts

@@ -12,6 +12,7 @@ import { getCommitInfo } from "@utils/git"
 import { getWorkingState } from "@utils/git"
 import { FileContextTracker } from "../context/context-tracking/FileContextTracker"
 import { getCwd } from "@/utils/path"
+import { openExternal } from "@utils/env"
 
 export async function openMention(mention?: string): Promise<void> {
 	if (!mention) {
@@ -36,7 +37,7 @@ export async function openMention(mention?: string): Promise<void> {
 	} else if (mention === "terminal") {
 		vscode.commands.executeCommand("workbench.action.terminal.focus")
 	} else if (mention.startsWith("http")) {
-		vscode.env.openExternal(vscode.Uri.parse(mention))
+		await openExternal(mention)
 	}
 }
 

src/core/storage/state-keys.ts

@@ -1,6 +1,6 @@
 export type SecretKey =
 	| "apiKey"
-	| "clineApiKey"
+	| "clineAccountId"
 	| "openRouterApiKey"
 	| "awsAccessKey"
 	| "awsSecretKey"
@@ -71,19 +71,16 @@ export type GlobalStateKey =
 	| "terminalReuseEnabled"
 	| "defaultTerminalProfile"
 	| "isNewUser"
+	| "welcomeViewCompleted"
 	| "terminalOutputLineLimit"
 	| "mcpRichDisplayEnabled"
 	| "sapAiCoreTokenUrl"
 	| "sapAiCoreBaseUrl"
 	| "sapAiResourceGroup"
-	| "sapAiCoreClientId"
-	| "sapAiCoreClientSecret"
-	| "sapAiCoreModelId"
 	| "claudeCodePath"
-
-export type LocalStateKey =
-	| "localClineRulesToggles"
+	// Settings around plan/act and ephemeral model configuration
 	| "chatSettings"
+	| "mode"
 	// Current active model configuration (per workspace)
 	| "apiProvider"
 	| "apiModelId"
@@ -104,6 +101,7 @@ export type LocalStateKey =
 	| "requestyModelInfo"
 	| "togetherModelId"
 	| "fireworksModelId"
+	| "sapAiCoreModelId"
 	// Previous mode saved configurations (per workspace)
 	| "previousModeApiProvider"
 	| "previousModeModelId"
@@ -113,9 +111,6 @@ export type LocalStateKey =
 	| "previousModeReasoningEffort"
 	| "previousModeAwsBedrockCustomSelected"
 	| "previousModeAwsBedrockCustomModelBaseId"
-	| "previousModeSapAiCoreClientId"
-	| "previousModeSapAiCoreClientSecret"
-	| "previousModeSapAiCoreBaseUrl"
-	| "previousModeSapAiCoreTokenUrl"
-	| "previousModeSapAiCoreResourceGroup"
 	| "previousModeSapAiCoreModelId"
+
+export type LocalStateKey = "localClineRulesToggles" | "localCursorRulesToggles" | "localWindsurfRulesToggles" | "workflowToggles"

src/core/storage/state-migrations.ts

@@ -2,11 +2,11 @@ import * as vscode from "vscode"
 import { ensureRulesDirectoryExists } from "./disk"
 import fs from "fs/promises"
 import path from "path"
-import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceState } from "./state"
+import { updateGlobalState, getAllExtensionState, getGlobalState } from "./state"
 import { GlobalStateKey } from "./state-keys"
 
-export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.ExtensionContext) {
-	// Keys that were migrated from global storage to workspace storage
+export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionContext) {
+	// Keys to migrate from workspace storage back to global storage
 	const keysToMigrate = [
 		// Core settings
 		"apiProvider",
@@ -31,6 +31,7 @@ export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.Ext
 		"requestyModelInfo",
 		"togetherModelId",
 		"fireworksModelId",
+		"sapAiCoreModelId",
 
 		// Previous mode settings
 		"previousModeApiProvider",
@@ -41,17 +42,24 @@ export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.Ext
 		"previousModeReasoningEffort",
 		"previousModeAwsBedrockCustomSelected",
 		"previousModeAwsBedrockCustomModelBaseId",
+		"previousModeSapAiCoreModelId",
 	]
 
 	for (const key of keysToMigrate) {
-		const globalValue = await getGlobalState(context, key as GlobalStateKey)
-		if (globalValue !== undefined) {
-			const workspaceValue = await getWorkspaceState(context, key)
-			if (workspaceValue === undefined) {
-				await updateWorkspaceState(context, key, globalValue)
-			}
-			// Delete from global storage regardless of whether we copied it
-			await updateGlobalState(context, key as GlobalStateKey, undefined)
+		// Use raw workspace state since these keys shouldn't be in workspace storage
+		const workspaceValue = await context.workspaceState.get(key)
+		const globalValue = await context.globalState.get(key)
+
+		if (workspaceValue !== undefined && globalValue === undefined) {
+			console.log(`[Storage Migration] migrating key: ${key} to global storage. Current value: ${workspaceValue}`)
+
+			// Move to global storage
+			await updateGlobalState(context, key as GlobalStateKey, workspaceValue)
+			// Remove from workspace storage
+			await context.workspaceState.update(key, undefined)
+			const newWorkspaceValue = await context.workspaceState.get(key)
+
+			console.log(`[Storage Migration] migrated key: ${key} to global storage. Current value: ${newWorkspaceValue}`)
 		}
 	}
 }
@@ -126,22 +134,89 @@ export async function migrateCustomInstructionsToGlobalRules(context: vscode.Ext
 
 export async function migrateModeFromWorkspaceStorageToControllerState(context: vscode.ExtensionContext) {
 	try {
-		// Get current chatSettings from workspace storage
-		const chatSettings = (await getWorkspaceState(context, "chatSettings")) as any
+		// Check legacy workspace storage (use raw methods since chatSettings is now global)
+		const workspaceChatSettings = (await context.workspaceState.get("chatSettings")) as any
 
-		if (chatSettings && typeof chatSettings === "object" && "mode" in chatSettings) {
-			console.log("Cleaning up mode from workspace storage...")
+		if (workspaceChatSettings && typeof workspaceChatSettings === "object" && "mode" in workspaceChatSettings) {
+			console.log("Cleaning up mode from legacy workspace storage...")
 
 			// Remove mode property from chatSettings
-			const { mode, ...cleanedChatSettings } = chatSettings
+			const { mode, ...cleanedChatSettings } = workspaceChatSettings
 
-			// Save cleaned chatSettings back to workspace storage
-			await updateWorkspaceState(context, "chatSettings", cleanedChatSettings)
+			// Save cleaned chatSettings back to workspace storage (will be migrated later)
+			await context.workspaceState.update("chatSettings", cleanedChatSettings)
 
-			console.log("Successfully removed mode from workspace storage chatSettings")
+			console.log("Successfully removed mode from legacy workspace storage chatSettings")
+		}
+
+		// Also check global storage for any mode cleanup needed
+		const globalChatSettings = (await context.globalState.get("chatSettings")) as any
+
+		if (globalChatSettings && typeof globalChatSettings === "object" && "mode" in globalChatSettings) {
+			console.log("Cleaning up mode from global storage...")
+
+			// Remove mode property from chatSettings
+			const { mode, ...cleanedChatSettings } = globalChatSettings
+
+			// Save cleaned chatSettings back to global storage
+			await updateGlobalState(context, "chatSettings", cleanedChatSettings)
+
+			console.log("Successfully removed mode from global storage chatSettings")
 		}
 	} catch (error) {
-		console.error("Failed to cleanup mode from workspace storage:", error)
+		console.error("Failed to cleanup mode from storage:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
+export async function migrateWelcomeViewCompleted(context: vscode.ExtensionContext) {
+	try {
+		// Check if welcomeViewCompleted is already set
+		const welcomeViewCompleted = await getGlobalState(context, "welcomeViewCompleted")
+
+		if (welcomeViewCompleted === undefined) {
+			console.log("Migrating welcomeViewCompleted setting...")
+
+			// Get all extension state to check for existing API keys
+			const extensionState = await getAllExtensionState(context)
+			const config = extensionState.apiConfiguration
+
+			// This is the original logic used for checking is the welcome view should be shown
+			// It was located in the ExtensionStateContextProvider
+			const hasKey = config
+				? [
+						config.apiKey,
+						config.openRouterApiKey,
+						config.awsRegion,
+						config.vertexProjectId,
+						config.openAiApiKey,
+						config.ollamaModelId,
+						config.lmStudioModelId,
+						config.liteLlmApiKey,
+						config.geminiApiKey,
+						config.openAiNativeApiKey,
+						config.deepSeekApiKey,
+						config.requestyApiKey,
+						config.togetherApiKey,
+						config.qwenApiKey,
+						config.doubaoApiKey,
+						config.mistralApiKey,
+						config.vsCodeLmModelSelector,
+						config.clineAccountId,
+						config.asksageApiKey,
+						config.xaiApiKey,
+						config.sambanovaApiKey,
+						config.sapAiCoreClientId,
+					].some((key) => key !== undefined)
+				: false
+
+			// Set welcomeViewCompleted based on whether user has keys
+			await updateGlobalState(context, "welcomeViewCompleted", hasKey)
+
+			console.log(`Migration: Set welcomeViewCompleted to ${hasKey} based on existing API keys`)
+		}
+	} catch (error) {
+		console.error("Failed to migrate welcomeViewCompleted:", error)
 		// Continue execution - migration failure shouldn't break extension startup
 	}
 }

src/core/storage/state.ts

@@ -2,7 +2,7 @@ import * as vscode from "vscode"
 import { DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
 import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
-import { GlobalStateKey, SecretKey } from "./state-keys"
+import { GlobalStateKey, LocalStateKey, SecretKey } from "./state-keys"
 import { ApiConfiguration, ApiProvider, BedrockModelId, ModelInfo } from "@shared/api"
 import { HistoryItem } from "@shared/HistoryItem"
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
@@ -18,19 +18,66 @@ import { migrateEnableCheckpointsSetting, migrateMcpMarketplaceEnableSetting } f
 	https://www.eliostruyf.com/devhack-code-extension-storage-options/
 	*/
 
-// global
+const isTemporaryProfile = process.env.TEMP_PROFILE === "true"
 
+// In-memory storage for temporary profiles
+const inMemoryGlobalState = new Map<string, any>()
+const inMemoryWorkspaceState = new Map<string, any>()
+const inMemorySecrets = new Map<string, string>()
+
+// global
 export async function updateGlobalState(context: vscode.ExtensionContext, key: GlobalStateKey, value: any) {
+	if (isTemporaryProfile) {
+		inMemoryGlobalState.set(key, value)
+		return
+	}
 	await context.globalState.update(key, value)
 }
 
 export async function getGlobalState(context: vscode.ExtensionContext, key: GlobalStateKey) {
+	if (isTemporaryProfile) {
+		return inMemoryGlobalState.get(key)
+	}
 	return await context.globalState.get(key)
 }
 
-// secrets
+// Batched operations for performance optimization
+export async function updateGlobalStateBatch(context: vscode.ExtensionContext, updates: Record<string, any>) {
+	if (isTemporaryProfile) {
+		Object.entries(updates).forEach(([key, value]) => {
+			inMemoryGlobalState.set(key, value)
+		})
+		return
+	}
+	// Use Promise.all to batch the updates
+	await Promise.all(Object.entries(updates).map(([key, value]) => context.globalState.update(key as GlobalStateKey, value)))
+}
 
+export async function updateSecretsBatch(context: vscode.ExtensionContext, updates: Record<string, string | undefined>) {
+	if (isTemporaryProfile) {
+		Object.entries(updates).forEach(([key, value]) => {
+			if (value) {
+				inMemorySecrets.set(key, value)
+			} else {
+				inMemorySecrets.delete(key)
+			}
+		})
+		return
+	}
+	// Use Promise.all to batch the secret updates
+	await Promise.all(Object.entries(updates).map(([key, value]) => storeSecret(context, key as SecretKey, value)))
+}
+
+// secrets
 export async function storeSecret(context: vscode.ExtensionContext, key: SecretKey, value?: string) {
+	if (isTemporaryProfile) {
+		if (value) {
+			inMemorySecrets.set(key, value)
+		} else {
+			inMemorySecrets.delete(key)
+		}
+		return
+	}
 	if (value) {
 		await context.secrets.store(key, value)
 	} else {
@@ -39,25 +86,36 @@ export async function storeSecret(context: vscode.ExtensionContext, key: SecretK
 }
 
 export async function getSecret(context: vscode.ExtensionContext, key: SecretKey) {
+	if (isTemporaryProfile) {
+		return inMemorySecrets.get(key)
+	}
 	return await context.secrets.get(key)
 }
 
 // workspace
-
-export async function updateWorkspaceState(context: vscode.ExtensionContext, key: string, value: any) {
+export async function updateWorkspaceState(context: vscode.ExtensionContext, key: LocalStateKey, value: any) {
+	if (isTemporaryProfile) {
+		inMemoryWorkspaceState.set(key, value)
+		return
+	}
 	await context.workspaceState.update(key, value)
 }
 
-export async function getWorkspaceState(context: vscode.ExtensionContext, key: string) {
+export async function getWorkspaceState(context: vscode.ExtensionContext, key: LocalStateKey) {
+	if (isTemporaryProfile) {
+		return inMemoryWorkspaceState.get(key)
+	}
 	return await context.workspaceState.get(key)
 }
 
 export async function getAllExtensionState(context: vscode.ExtensionContext) {
+	const firstBatchStart = performance.now()
 	const [
 		isNewUser,
+		welcomeViewCompleted,
 		apiKey,
 		openRouterApiKey,
-		clineApiKey,
+		clineAccountId,
 		awsAccessKey,
 		awsSecretKey,
 		awsSessionToken,
@@ -124,13 +182,13 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		sapAiCoreBaseUrl,
 		sapAiCoreTokenUrl,
 		sapAiResourceGroup,
-		sapAiCoreModelId,
 		claudeCodePath,
 	] = await Promise.all([
 		getGlobalState(context, "isNewUser") as Promise<boolean | undefined>,
+		getGlobalState(context, "welcomeViewCompleted") as Promise<boolean | undefined>,
 		getSecret(context, "apiKey") as Promise<string | undefined>,
 		getSecret(context, "openRouterApiKey") as Promise<string | undefined>,
-		getSecret(context, "clineApiKey") as Promise<string | undefined>,
+		getSecret(context, "clineAccountId") as Promise<string | undefined>,
 		getSecret(context, "awsAccessKey") as Promise<string | undefined>,
 		getSecret(context, "awsSecretKey") as Promise<string | undefined>,
 		getSecret(context, "awsSessionToken") as Promise<string | undefined>,
@@ -197,14 +255,15 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getGlobalState(context, "sapAiCoreBaseUrl") as Promise<string | undefined>,
 		getGlobalState(context, "sapAiCoreTokenUrl") as Promise<string | undefined>,
 		getGlobalState(context, "sapAiResourceGroup") as Promise<string | undefined>,
-		getGlobalState(context, "sapAiCoreModelId") as Promise<string | undefined>,
 		getGlobalState(context, "claudeCodePath") as Promise<string | undefined>,
 	])
 
 	const localClineRulesToggles = (await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles
 
+	const secondBatchStart = performance.now()
 	const [
 		chatSettings,
+		currentMode,
 		storedApiProvider,
 		apiModelId,
 		thinkingBudgetTokens,
@@ -232,49 +291,43 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeReasoningEffort,
 		previousModeAwsBedrockCustomSelected,
 		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreClientId,
-		previousModeSapAiCoreClientSecret,
-		previousModeSapAiCoreBaseUrl,
-		previousModeSapAiCoreTokenUrl,
-		previousModeSapAiCoreResourceGroup,
 		previousModeSapAiCoreModelId,
+		sapAiCoreModelId,
 	] = await Promise.all([
-		getWorkspaceState(context, "chatSettings") as Promise<StoredChatSettings | undefined>,
-		getWorkspaceState(context, "apiProvider") as Promise<ApiProvider | undefined>,
-		getWorkspaceState(context, "apiModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "thinkingBudgetTokens") as Promise<number | undefined>,
-		getWorkspaceState(context, "reasoningEffort") as Promise<string | undefined>,
-		getWorkspaceState(context, "vsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
-		getWorkspaceState(context, "awsBedrockCustomSelected") as Promise<boolean | undefined>,
-		getWorkspaceState(context, "awsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
-		getWorkspaceState(context, "openRouterModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "openRouterModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "openAiModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "openAiModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "ollamaModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "lmStudioModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "liteLlmModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "liteLlmModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "requestyModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "requestyModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "togetherModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "fireworksModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeApiProvider") as Promise<ApiProvider | undefined>,
-		getWorkspaceState(context, "previousModeModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "previousModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
-		getWorkspaceState(context, "previousModeThinkingBudgetTokens") as Promise<number | undefined>,
-		getWorkspaceState(context, "previousModeReasoningEffort") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
-		getWorkspaceState(context, "previousModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreClientId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreClientSecret") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreBaseUrl") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreTokenUrl") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreResourceGroup") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "chatSettings") as Promise<StoredChatSettings | undefined>,
+		getGlobalState(context, "mode") as Promise<"plan" | "act" | undefined>,
+		getGlobalState(context, "apiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "apiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "thinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "reasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "vsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "awsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "awsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "openRouterModelId") as Promise<string | undefined>,
+		getGlobalState(context, "openRouterModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "openAiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "openAiModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "ollamaModelId") as Promise<string | undefined>,
+		getGlobalState(context, "lmStudioModelId") as Promise<string | undefined>,
+		getGlobalState(context, "liteLlmModelId") as Promise<string | undefined>,
+		getGlobalState(context, "liteLlmModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "requestyModelId") as Promise<string | undefined>,
+		getGlobalState(context, "requestyModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "togetherModelId") as Promise<string | undefined>,
+		getGlobalState(context, "fireworksModelId") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeApiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "previousModeModelId") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "previousModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "previousModeThinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "previousModeReasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "previousModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "sapAiCoreModelId") as Promise<string | undefined>,
 	])
 
+	const processingStart = performance.now()
 	let apiProvider: ApiProvider
 	if (storedApiProvider) {
 		apiProvider = storedApiProvider
@@ -317,7 +370,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			apiModelId,
 			apiKey,
 			openRouterApiKey,
-			clineApiKey,
+			clineAccountId,
 			claudeCodePath,
 			awsAccessKey,
 			awsSecretKey,
@@ -388,6 +441,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			sapAiCoreModelId,
 		},
 		isNewUser: isNewUser ?? true,
+		welcomeViewCompleted,
 		lastShownAnnouncementId,
 		taskHistory,
 		autoApprovalSettings: autoApprovalSettings || DEFAULT_AUTO_APPROVAL_SETTINGS, // default value can be 0 or empty string
@@ -396,7 +450,8 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		browserSettings: { ...DEFAULT_BROWSER_SETTINGS, ...browserSettings }, // this will ensure that older versions of browserSettings (e.g. before remoteBrowserEnabled was added) are merged with the default values (false for remoteBrowserEnabled)
 		chatSettings: {
 			...DEFAULT_CHAT_SETTINGS, // Apply defaults first
-			...(chatSettings || {}), // Spread fetched chatSettings, which includes preferredLanguage, and openAIReasoningEffort
+			...(chatSettings || {}), // Spread fetched global chatSettings, which includes preferredLanguage, and openAIReasoningEffort
+			mode: currentMode || "act", // Merge mode from global state
 		},
 		userInfo,
 		previousModeApiProvider,
@@ -407,11 +462,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeReasoningEffort,
 		previousModeAwsBedrockCustomSelected,
 		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreClientId,
-		previousModeSapAiCoreClientSecret,
-		previousModeSapAiCoreBaseUrl,
-		previousModeSapAiCoreTokenUrl,
-		previousModeSapAiCoreResourceGroup,
 		previousModeSapAiCoreModelId,
 		mcpMarketplaceEnabled: mcpMarketplaceEnabled,
 		mcpRichDisplayEnabled: mcpRichDisplayEnabled ?? true,
@@ -485,7 +535,7 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		xaiApiKey,
 		thinkingBudgetTokens,
 		reasoningEffort,
-		clineApiKey,
+		clineAccountId,
 		sambanovaApiKey,
 		cerebrasApiKey,
 		nebiusApiKey,
@@ -502,86 +552,93 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		sapAiCoreModelId,
 		claudeCodePath,
 	} = apiConfiguration
-	// Workspace state updates
-	await updateWorkspaceState(context, "apiProvider", apiProvider)
-	await updateWorkspaceState(context, "apiModelId", apiModelId)
-	await updateWorkspaceState(context, "thinkingBudgetTokens", thinkingBudgetTokens)
-	await updateWorkspaceState(context, "reasoningEffort", reasoningEffort)
-	await updateWorkspaceState(context, "vsCodeLmModelSelector", vsCodeLmModelSelector)
-	await updateWorkspaceState(context, "awsBedrockCustomSelected", awsBedrockCustomSelected)
-	await updateWorkspaceState(context, "awsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
-	await updateWorkspaceState(context, "openRouterModelId", openRouterModelId)
-	await updateWorkspaceState(context, "openRouterModelInfo", openRouterModelInfo)
-	await updateWorkspaceState(context, "openAiModelId", openAiModelId)
-	await updateWorkspaceState(context, "openAiModelInfo", openAiModelInfo)
-	await updateWorkspaceState(context, "ollamaModelId", ollamaModelId)
-	await updateWorkspaceState(context, "lmStudioModelId", lmStudioModelId)
-	await updateWorkspaceState(context, "liteLlmModelId", liteLlmModelId)
-	await updateWorkspaceState(context, "liteLlmModelInfo", liteLlmModelInfo)
-	await updateWorkspaceState(context, "requestyModelId", requestyModelId)
-	await updateWorkspaceState(context, "requestyModelInfo", requestyModelInfo)
-	await updateWorkspaceState(context, "togetherModelId", togetherModelId)
-	await updateWorkspaceState(context, "fireworksModelId", fireworksModelId)
 
-	// Global state updates
-	await updateGlobalState(context, "awsRegion", awsRegion)
-	await updateGlobalState(context, "awsUseCrossRegionInference", awsUseCrossRegionInference)
-	await updateGlobalState(context, "awsBedrockUsePromptCache", awsBedrockUsePromptCache)
-	await updateGlobalState(context, "awsBedrockEndpoint", awsBedrockEndpoint)
-	await updateGlobalState(context, "awsProfile", awsProfile)
-	await updateGlobalState(context, "awsUseProfile", awsUseProfile)
-	await updateGlobalState(context, "vertexProjectId", vertexProjectId)
-	await updateGlobalState(context, "vertexRegion", vertexRegion)
-	await updateGlobalState(context, "openAiBaseUrl", openAiBaseUrl)
-	await updateGlobalState(context, "openAiHeaders", openAiHeaders || {})
-	await updateGlobalState(context, "ollamaBaseUrl", ollamaBaseUrl)
-	await updateGlobalState(context, "ollamaApiOptionsCtxNum", ollamaApiOptionsCtxNum)
-	await updateGlobalState(context, "lmStudioBaseUrl", lmStudioBaseUrl)
-	await updateGlobalState(context, "anthropicBaseUrl", anthropicBaseUrl)
-	await updateGlobalState(context, "geminiBaseUrl", geminiBaseUrl)
-	await updateGlobalState(context, "azureApiVersion", azureApiVersion)
-	await updateGlobalState(context, "openRouterProviderSorting", openRouterProviderSorting)
-	await updateGlobalState(context, "liteLlmBaseUrl", liteLlmBaseUrl)
-	await updateGlobalState(context, "liteLlmUsePromptCache", liteLlmUsePromptCache)
-	await updateGlobalState(context, "qwenApiLine", qwenApiLine)
-	await updateGlobalState(context, "asksageApiUrl", asksageApiUrl)
-	await updateGlobalState(context, "favoritedModelIds", favoritedModelIds)
-	await updateGlobalState(context, "requestTimeoutMs", apiConfiguration.requestTimeoutMs)
-	await updateGlobalState(context, "fireworksModelMaxCompletionTokens", fireworksModelMaxCompletionTokens)
-	await updateGlobalState(context, "fireworksModelMaxTokens", fireworksModelMaxTokens)
-	await updateGlobalState(context, "favoritedModelIds", favoritedModelIds)
-	await updateGlobalState(context, "requestTimeoutMs", apiConfiguration.requestTimeoutMs)
-	await updateGlobalState(context, "sapAiCoreBaseUrl", sapAiCoreBaseUrl)
-	await updateGlobalState(context, "sapAiCoreTokenUrl", sapAiCoreTokenUrl)
-	await updateGlobalState(context, "sapAiResourceGroup", sapAiResourceGroup)
-	await updateGlobalState(context, "sapAiCoreModelId", sapAiCoreModelId)
-	await updateGlobalState(context, "claudeCodePath", claudeCodePath)
+	// OPTIMIZED: Batch all global state updates into 2 operations instead of 47
+	const batchedGlobalUpdates = {
+		// Ephemeral model config updates (20 keys)
+		apiProvider,
+		apiModelId,
+		thinkingBudgetTokens,
+		reasoningEffort,
+		vsCodeLmModelSelector,
+		awsBedrockCustomSelected,
+		awsBedrockCustomModelBaseId,
+		openRouterModelId,
+		openRouterModelInfo,
+		openAiModelId,
+		openAiModelInfo,
+		ollamaModelId,
+		lmStudioModelId,
+		liteLlmModelId,
+		liteLlmModelInfo,
+		requestyModelId,
+		requestyModelInfo,
+		togetherModelId,
+		fireworksModelId,
+		sapAiCoreModelId,
 
-	// Secret updates
-	await storeSecret(context, "apiKey", apiKey)
-	await storeSecret(context, "openRouterApiKey", openRouterApiKey)
-	await storeSecret(context, "clineApiKey", clineApiKey)
-	await storeSecret(context, "awsAccessKey", awsAccessKey)
-	await storeSecret(context, "awsSecretKey", awsSecretKey)
-	await storeSecret(context, "awsSessionToken", awsSessionToken)
-	await storeSecret(context, "openAiApiKey", openAiApiKey)
-	await storeSecret(context, "geminiApiKey", geminiApiKey)
-	await storeSecret(context, "openAiNativeApiKey", openAiNativeApiKey)
-	await storeSecret(context, "deepSeekApiKey", deepSeekApiKey)
-	await storeSecret(context, "requestyApiKey", requestyApiKey)
-	await storeSecret(context, "togetherApiKey", togetherApiKey)
-	await storeSecret(context, "qwenApiKey", qwenApiKey)
-	await storeSecret(context, "doubaoApiKey", doubaoApiKey)
-	await storeSecret(context, "mistralApiKey", mistralApiKey)
-	await storeSecret(context, "liteLlmApiKey", liteLlmApiKey)
-	await storeSecret(context, "fireworksApiKey", fireworksApiKey)
-	await storeSecret(context, "asksageApiKey", asksageApiKey)
-	await storeSecret(context, "xaiApiKey", xaiApiKey)
-	await storeSecret(context, "sambanovaApiKey", sambanovaApiKey)
-	await storeSecret(context, "cerebrasApiKey", cerebrasApiKey)
-	await storeSecret(context, "nebiusApiKey", nebiusApiKey)
-	await storeSecret(context, "sapAiCoreClientId", sapAiCoreClientId)
-	await storeSecret(context, "sapAiCoreClientSecret", sapAiCoreClientSecret)
+		// Global state updates (27 keys)
+		awsRegion,
+		awsUseCrossRegionInference,
+		awsBedrockUsePromptCache,
+		awsBedrockEndpoint,
+		awsProfile,
+		awsUseProfile,
+		vertexProjectId,
+		vertexRegion,
+		openAiBaseUrl,
+		openAiHeaders: openAiHeaders || {},
+		ollamaBaseUrl,
+		ollamaApiOptionsCtxNum,
+		lmStudioBaseUrl,
+		anthropicBaseUrl,
+		geminiBaseUrl,
+		azureApiVersion,
+		openRouterProviderSorting,
+		liteLlmBaseUrl,
+		liteLlmUsePromptCache,
+		qwenApiLine,
+		asksageApiUrl,
+		favoritedModelIds,
+		requestTimeoutMs: apiConfiguration.requestTimeoutMs,
+		fireworksModelMaxCompletionTokens,
+		fireworksModelMaxTokens,
+		sapAiCoreBaseUrl,
+		sapAiCoreTokenUrl,
+		sapAiResourceGroup,
+		claudeCodePath,
+	}
+
+	// OPTIMIZED: Batch all secret updates into 1 operation instead of 23
+	const batchedSecretUpdates = {
+		apiKey,
+		openRouterApiKey,
+		clineAccountId,
+		awsAccessKey,
+		awsSecretKey,
+		awsSessionToken,
+		openAiApiKey,
+		geminiApiKey,
+		openAiNativeApiKey,
+		deepSeekApiKey,
+		requestyApiKey,
+		togetherApiKey,
+		qwenApiKey,
+		doubaoApiKey,
+		mistralApiKey,
+		liteLlmApiKey,
+		fireworksApiKey,
+		asksageApiKey,
+		xaiApiKey,
+		sambanovaApiKey,
+		cerebrasApiKey,
+		nebiusApiKey,
+		sapAiCoreClientId,
+		sapAiCoreClientSecret,
+	}
+
+	// Execute batched operations in parallel for maximum performance
+	await Promise.all([updateGlobalStateBatch(context, batchedGlobalUpdates), updateSecretsBatch(context, batchedSecretUpdates)])
 }
 
 export async function resetWorkspaceState(context: vscode.ExtensionContext) {
@@ -610,7 +667,7 @@ export async function resetGlobalState(context: vscode.ExtensionContext) {
 		"qwenApiKey",
 		"doubaoApiKey",
 		"mistralApiKey",
-		"clineApiKey",
+		"clineAccountId",
 		"liteLlmApiKey",
 		"fireworksApiKey",
 		"asksageApiKey",

src/core/task/ToolExecutor.ts

@@ -49,7 +49,7 @@ import { ContextManager } from "../context/context-management/ContextManager"
 import { loadMcpDocumentation } from "../prompts/loadMcpDocumentation"
 import { formatResponse } from "../prompts/responses"
 import { ensureTaskDirectoryExists } from "../storage/disk"
-import { getWorkspaceState } from "../storage/state"
+import { getGlobalState, getWorkspaceState } from "../storage/state"
 import { TaskState } from "./TaskState"
 import { MessageStateHandler } from "./message-state"
 import { AutoApprove } from "./tools/autoApprove"
@@ -63,7 +63,10 @@ export class ToolExecutor {
 		return this.autoApprover.shouldAutoApproveTool(toolName)
 	}
 
-	private shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): boolean {
+	private async shouldAutoApproveToolWithPath(
+		blockname: ToolUseName,
+		autoApproveActionpath: string | undefined,
+	): Promise<boolean> {
 		return this.autoApprover.shouldAutoApproveToolWithPath(blockname, autoApproveActionpath)
 	}
 
@@ -573,7 +576,7 @@ export class ToolExecutor {
 						// update gui message
 						const partialMessage = JSON.stringify(sharedMessageProps)
 
-						if (this.shouldAutoApproveToolWithPath(block.name, relPath)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, relPath)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool") // in case the user changes auto-approval settings mid stream
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -645,7 +648,7 @@ export class ToolExecutor {
 							// 	)
 							// : undefined,
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, relPath)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, relPath)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -782,7 +785,7 @@ export class ToolExecutor {
 							content: undefined,
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -813,7 +816,7 @@ export class ToolExecutor {
 							content: absolutePath,
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false) // need to be sending partialValue bool, since undefined has its own purpose in that the message is treated neither as a partial or completion of a partial, but as a single complete message
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -864,7 +867,7 @@ export class ToolExecutor {
 							content: "",
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -896,7 +899,7 @@ export class ToolExecutor {
 							content: result,
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -939,7 +942,7 @@ export class ToolExecutor {
 							content: "",
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -968,7 +971,7 @@ export class ToolExecutor {
 							content: result,
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -1015,7 +1018,7 @@ export class ToolExecutor {
 							content: "",
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -1052,7 +1055,7 @@ export class ToolExecutor {
 							content: results,
 							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -1914,7 +1917,7 @@ export class ToolExecutor {
 						const clineVersion =
 							vscode.extensions.getExtension("saoudrizwan.claude-dev")?.packageJSON.version || "Unknown"
 						const systemInfo = `VSCode: ${vscode.version}, Node.js: ${process.version}, Architecture: ${os.arch()}`
-						const providerAndModel = `${(await getWorkspaceState(this.context, "apiProvider")) as string} / ${this.api.getModel().id}`
+						const providerAndModel = `${await getGlobalState(this.context, "apiProvider")} / ${this.api.getModel().id}`
 
 						// Ask user for confirmation
 						const bugReportData = JSON.stringify({

src/core/task/index.ts

@@ -26,11 +26,11 @@ import { getApiMetrics } from "@shared/getApiMetrics"
 import { HistoryItem } from "@shared/HistoryItem"
 import { DEFAULT_LANGUAGE_SETTINGS, getLanguageKey, LanguageDisplay } from "@shared/Languages"
 import { ClineAskResponse, ClineCheckpointRestore } from "@shared/WebviewMessage"
-import { arePathsEqual } from "@utils/path"
+import { getGitRemoteUrls } from "@utils/git"
+import { arePathsEqual, getDesktopDir } from "@utils/path"
 import cloneDeep from "clone-deep"
 import { execa } from "execa"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
-import os from "os"
 import pTimeout from "p-timeout"
 import pWaitFor from "p-wait-for"
 import * as path from "path"
@@ -69,7 +69,7 @@ import {
 	getSavedClineMessages,
 	GlobalFileNames,
 } from "@core/storage/disk"
-import { getWorkspaceState } from "@core/storage/state"
+import { getGlobalState } from "@core/storage/state"
 import { processFilesIntoText } from "@integrations/misc/extract-text"
 import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
 import { McpHub } from "@services/mcp/McpHub"
@@ -85,9 +85,6 @@ import { formatErrorWithStatusCode, updateApiReqMsg } from "./utils"
 
 export const USE_EXPERIMENTAL_CLAUDE4_FEATURES = false
 
-export const cwd =
-	vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop") // may or may not exist but fs checking existence would immediately ask for permission which would be bad UX, need to come up with a better solution
-
 export type ToolResponse = string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam>
 type UserContent = Array<Anthropic.ContentBlockParam>
 
@@ -95,6 +92,7 @@ export class Task {
 	// Core task variables
 	readonly taskId: string
 	private taskIsFavorited?: boolean
+	private cwd: string
 
 	taskState: TaskState
 
@@ -151,6 +149,7 @@ export class Task {
 		terminalOutputLineLimit: number,
 		defaultTerminalProfile: string,
 		enableCheckpointsSetting: boolean,
+		cwd: string,
 		task?: string,
 		images?: string[],
 		files?: string[],
@@ -180,6 +179,7 @@ export class Task {
 		this.browserSettings = browserSettings
 		this.chatSettings = chatSettings
 		this.enableCheckpoints = enableCheckpointsSetting
+		this.cwd = cwd
 
 		// Set up MCP notification callback for real-time notifications
 		this.mcpHub.setNotificationCallback(async (serverName: string, level: string, message: string) => {
@@ -1096,7 +1096,7 @@ export class Task {
 		const [taskResumptionMessage, userResponseMessage] = formatResponse.taskResumption(
 			this.chatSettings?.mode === "plan" ? "plan" : "act",
 			agoText,
-			cwd,
+			this.cwd,
 			wasRecent,
 			responseText,
 			hasPendingFileContextWarnings,
@@ -1327,7 +1327,7 @@ export class Task {
 			// Create a child process
 			const childProcess = execa(command, {
 				shell: true,
-				cwd,
+				cwd: this.cwd,
 				reject: false,
 				all: true, // Merge stdout and stderr
 			})
@@ -1404,7 +1404,7 @@ export class Task {
 		}
 		Logger.info("Executing command in VS code terminal: " + command)
 
-		const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd)
+		const terminalInfo = await this.terminalManager.getOrCreateTerminal(this.cwd)
 		terminalInfo.terminal.show() // weird visual bug when creating new terminals (even manually) where there's an empty space at the top.
 		const process = this.terminalManager.runCommand(terminalInfo, command)
 
@@ -1580,7 +1580,7 @@ export class Task {
 		const supportsBrowserUse = modelSupportsBrowserUse && !disableBrowserTool // only enable browser use if the model supports it and the user hasn't disabled it
 
 		const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
-		let systemPrompt = await SYSTEM_PROMPT(cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isNextGenModel)
+		let systemPrompt = await SYSTEM_PROMPT(this.cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isNextGenModel)
 
 		await this.migratePreferredLanguageToolSetting()
 		const preferredLanguage = getLanguageKey(this.chatSettings.preferredLanguage as LanguageDisplay)
@@ -1589,18 +1589,18 @@ export class Task {
 				? `# Preferred Language\n\nSpeak in ${preferredLanguage}.`
 				: ""
 
-		const { globalToggles, localToggles } = await refreshClineRulesToggles(this.getContext(), cwd)
-		const { windsurfLocalToggles, cursorLocalToggles } = await refreshExternalRulesToggles(this.getContext(), cwd)
+		const { globalToggles, localToggles } = await refreshClineRulesToggles(this.getContext(), this.cwd)
+		const { windsurfLocalToggles, cursorLocalToggles } = await refreshExternalRulesToggles(this.getContext(), this.cwd)
 
 		const globalClineRulesFilePath = await ensureRulesDirectoryExists()
 		const globalClineRulesFileInstructions = await getGlobalClineRules(globalClineRulesFilePath, globalToggles)
 
-		const localClineRulesFileInstructions = await getLocalClineRules(cwd, localToggles)
+		const localClineRulesFileInstructions = await getLocalClineRules(this.cwd, localToggles)
 		const [localCursorRulesFileInstructions, localCursorRulesDirInstructions] = await getLocalCursorRules(
-			cwd,
+			this.cwd,
 			cursorLocalToggles,
 		)
-		const localWindsurfRulesFileInstructions = await getLocalWindsurfRules(cwd, windsurfLocalToggles)
+		const localWindsurfRulesFileInstructions = await getLocalWindsurfRules(this.cwd, windsurfLocalToggles)
 
 		const clineIgnoreContent = this.clineIgnoreController.clineIgnoreContent
 		let clineIgnoreInstructions: string | undefined
@@ -1872,7 +1872,7 @@ export class Task {
 		}
 
 		// Used to know what models were used in the task if user wants to export metadata for error reporting purposes
-		const currentProviderId = (await getWorkspaceState(this.getContext(), "apiProvider")) as string
+		const currentProviderId = (await getGlobalState(this.getContext(), "apiProvider")) as string
 		if (currentProviderId && this.api.getModel().id) {
 			try {
 				await this.modelContextTracker.recordModelUsage(currentProviderId, this.api.getModel().id, this.chatSettings.mode)
@@ -2124,6 +2124,13 @@ export class Task {
 					this.api.getModel().id,
 					"assistant",
 					true,
+					{
+						tokensIn: inputTokens,
+						tokensOut: outputTokens,
+						cacheWriteTokens,
+						cacheReadTokens,
+						totalCost,
+					},
 				)
 
 				// signals to provider that it can retrieve the saved messages from disk, as abortTask can not be awaited on in nature
@@ -2297,6 +2304,13 @@ export class Task {
 					this.api.getModel().id,
 					"assistant",
 					true,
+					{
+						tokensIn: inputTokens,
+						tokensOut: outputTokens,
+						cacheWriteTokens,
+						cacheReadTokens,
+						totalCost,
+					},
 				)
 
 				await this.messageStateHandler.addToApiConversationHistory({
@@ -2356,7 +2370,7 @@ export class Task {
 		// Track if we need to check clinerulesFile
 		let needsClinerulesFileCheck = false
 
-		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(this.getContext(), cwd)
+		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(this.getContext(), this.cwd)
 
 		const processUserContent = async () => {
 			// This is a temporary solution to dynamically load context mentions from tool results. It checks for the presence of tags that indicate that the tool was rejected and feedback was provided (see formatToolDeniedFeedback, attemptCompletion, executeCommand, and consecutiveMistakeCount >= 3) or "<answer>" (see askFollowupQuestion), we place all user generated content in these tags so they can effectively be used as markers for when we should parse mentions). However if we allow multiple tools responses in the future, we will need to parse mentions specifically within the user content tags.
@@ -2374,7 +2388,7 @@ export class Task {
 						) {
 							const parsedText = await parseMentions(
 								block.text,
-								cwd,
+								this.cwd,
 								this.urlContentFetcher,
 								this.fileContextTracker,
 							)
@@ -2410,7 +2424,7 @@ export class Task {
 		// After processing content, check clinerulesData if needed
 		let clinerulesError = false
 		if (needsClinerulesFileCheck) {
-			clinerulesError = await ensureLocalClineDirExists(cwd, GlobalFileNames.clineRules)
+			clinerulesError = await ensureLocalClineDirExists(this.cwd, GlobalFileNames.clineRules)
 		}
 
 		// Return all results
@@ -2425,7 +2439,7 @@ export class Task {
 		const visibleFilePaths = vscode.window.visibleTextEditors
 			?.map((editor) => editor.document?.uri?.fsPath)
 			.filter(Boolean)
-			.map((absolutePath) => path.relative(cwd, absolutePath))
+			.map((absolutePath) => path.relative(this.cwd, absolutePath))
 
 		// Filter paths through clineIgnoreController
 		const allowedVisibleFiles = this.clineIgnoreController
@@ -2444,7 +2458,7 @@ export class Task {
 			.flatMap((group) => group.tabs)
 			.map((tab) => (tab.input as vscode.TabInputText)?.uri?.fsPath)
 			.filter(Boolean)
-			.map((absolutePath) => path.relative(cwd, absolutePath))
+			.map((absolutePath) => path.relative(this.cwd, absolutePath))
 
 		// Filter paths through clineIgnoreController
 		const allowedOpenTabs = this.clineIgnoreController
@@ -2570,16 +2584,22 @@ export class Task {
 		details += `\n\n# Current Time\n${formatter.format(now)} (${timeZone}, UTC${timeZoneOffsetStr})`
 
 		if (includeFileDetails) {
-			details += `\n\n# Current Working Directory (${cwd.toPosix()}) Files\n`
-			const isDesktop = arePathsEqual(cwd, path.join(os.homedir(), "Desktop"))
+			details += `\n\n# Current Working Directory (${this.cwd.toPosix()}) Files\n`
+			const isDesktop = arePathsEqual(this.cwd, getDesktopDir())
 			if (isDesktop) {
 				// don't want to immediately access desktop since it would show permission popup
 				details += "(Desktop files not shown automatically. Use list_files to explore if needed.)"
 			} else {
-				const [files, didHitLimit] = await listFiles(cwd, true, 200)
-				const result = formatResponse.formatFilesList(cwd, files, didHitLimit, this.clineIgnoreController)
+				const [files, didHitLimit] = await listFiles(this.cwd, true, 200)
+				const result = formatResponse.formatFilesList(this.cwd, files, didHitLimit, this.clineIgnoreController)
 				details += result
 			}
+
+			// Add git remote URLs section
+			const gitRemotes = await getGitRemoteUrls(this.cwd)
+			if (gitRemotes.length > 0) {
+				details += `\n\n# Git Remote URLs\n${gitRemotes.join("\n")}`
+			}
 		}
 
 		// Add context window usage information

src/core/task/message-state.ts

@@ -12,7 +12,7 @@ import CheckpointTracker from "@integrations/checkpoints/CheckpointTracker"
 import { HistoryItem } from "@/shared/HistoryItem"
 import Anthropic from "@anthropic-ai/sdk"
 import { TaskState } from "./TaskState"
-import { getCwd } from "@/utils/path"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 interface MessageStateHandlerParams {
 	context: vscode.ExtensionContext
@@ -83,7 +83,7 @@ export class MessageStateHandler {
 			} catch (error) {
 				console.error("Failed to get task directory size:", taskDir, error)
 			}
-			const cwd = await getCwd(path.join(os.homedir(), "Desktop"))
+			const cwd = await getCwd(getDesktopDir())
 			await this.updateTaskHistory({
 				id: this.taskId,
 				ts: lastRelevantMessage.ts,

src/core/task/tools/autoApprove.ts

@@ -1,11 +1,8 @@
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
 import { ToolUseName } from "@core/assistant-message"
 import * as path from "path"
-import * as vscode from "vscode"
 import os from "os"
-
-export const cwd =
-	vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop")
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 export class AutoApprove {
 	autoApprovalSettings: AutoApprovalSettings
@@ -54,9 +51,10 @@ export class AutoApprove {
 	// Check if the tool should be auto-approved based on the settings
 	// and the path of the action. Returns true if the tool should be auto-approved
 	// based on the user's settings and the path of the action.
-	shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): boolean {
+	async shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): Promise<boolean> {
 		let isLocalRead: boolean = false
 		if (autoApproveActionpath) {
+			const cwd = await getCwd(getDesktopDir())
 			const absolutePath = path.resolve(cwd, autoApproveActionpath)
 			isLocalRead = absolutePath.startsWith(cwd)
 		} else {

src/extension.ts

@@ -23,9 +23,10 @@ import { WebviewProviderType } from "./shared/webview/types"
 import { sendHistoryButtonClickedEvent } from "./core/controller/ui/subscribeToHistoryButtonClicked"
 import { sendAccountButtonClickedEvent } from "./core/controller/ui/subscribeToAccountButtonClicked"
 import {
-	migratePlanActGlobalToWorkspaceStorage,
+	migrateWorkspaceToGlobalStorage,
 	migrateCustomInstructionsToGlobalRules,
 	migrateModeFromWorkspaceStorageToControllerState,
+	migrateWelcomeViewCompleted,
 } from "./core/storage/state-migrations"
 
 import { sendFocusChatInputEvent } from "./core/controller/ui/subscribeToFocusChatInput"
@@ -34,6 +35,7 @@ import * as hostProviders from "@hosts/host-providers"
 import { vscodeHostBridgeClient } from "@/hosts/vscode/client/host-grpc-client"
 import { VscodeWebviewProvider } from "./core/webview/VscodeWebviewProvider"
 import { ExtensionContext } from "vscode"
+import { AuthService } from "./services/auth/AuthService"
 import { writeTextToClipboard, readTextFromClipboard } from "@/utils/env"
 
 /*
@@ -59,15 +61,18 @@ export async function activate(context: vscode.ExtensionContext) {
 
 	maybeSetupHostProviders(context)
 
-	// Migrate global storage values to workspace storage (one-time cleanup)
-	await migratePlanActGlobalToWorkspaceStorage(context)
-
 	// Migrate custom instructions to global Cline rules (one-time cleanup)
 	await migrateCustomInstructionsToGlobalRules(context)
 
 	// Migrate mode from workspace storage to controller state (one-time cleanup)
 	await migrateModeFromWorkspaceStorageToControllerState(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)
 
@@ -289,24 +294,28 @@ export async function activate(context: vscode.ExtensionContext) {
 				break
 			}
 			case "/auth": {
-				const token = query.get("token")
+				const authService = AuthService.getInstance()
+				console.log("Auth callback received:", uri.toString())
+
+				const token = query.get("idToken")
 				const state = query.get("state")
-				const apiKey = query.get("apiKey")
+				const provider = query.get("provider")
 
 				console.log("Auth callback received:", {
 					token: token,
 					state: state,
-					apiKey: apiKey,
+					provider: provider,
 				})
 
 				// Validate state parameter
-				if (!(await visibleWebview?.controller.validateAuthState(state))) {
+				if (!(authService.authNonce === state)) {
 					vscode.window.showErrorMessage("Invalid auth state")
 					return
 				}
 
-				if (token && apiKey) {
-					await visibleWebview?.controller.handleAuthCallback(token, apiKey)
+				if (token) {
+					await visibleWebview?.controller.handleAuthCallback(token, provider)
+					// await authService.handleAuthCallback(token)
 				}
 				break
 			}
@@ -640,6 +649,14 @@ export async function activate(context: vscode.ExtensionContext) {
 		}),
 	)
 
+	// Register the openWalkthrough command handler
+	context.subscriptions.push(
+		vscode.commands.registerCommand("cline.openWalkthrough", async () => {
+			await vscode.commands.executeCommand("workbench.action.openWalkthrough", "saoudrizwan.claude-dev#ClineWalkthrough")
+			telemetryService.captureButtonClick("command_openWalkthrough", undefined, true)
+		}),
+	)
+
 	// Register the generateGitCommitMessage command handler
 	context.subscriptions.push(
 		vscode.commands.registerCommand("cline.generateGitCommitMessage", async () => {