Improve auth state management for account view (#5107)

- Fix AccountView state management when user is not authenticated or is authenticated after the webview is loaded
- Add proper loading state reset and conditional data fetching

.changeset/sweet-dingos-serve.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Improve the Claude Code error messages

.eslintrc.json

@@ -20,8 +20,6 @@
 		"no-throw-literal": "warn",
 		"semi": "off",
 		"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",

.github/workflows/e2e.yml

@@ -56,6 +56,29 @@ jobs:
                   path: webview-ui/node_modules
                   key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
 
+            # Cache VS Code installation
+            - name: Cache VS Code
+              uses: actions/cache@v4
+              id: vscode-cache
+              with:
+                  path: .vscode-test
+                  key: vscode-${{ runner.os }}-stable-${{ hashFiles('.vscode-test.mjs', 'package.json') }}
+                  restore-keys: |
+                      vscode-${{ runner.os }}-stable-
+
+            # Cache Playwright browsers
+            - name: Cache Playwright browsers
+              uses: actions/cache@v4
+              id: playwright-cache
+              with:
+                  path: |
+                      ~/.cache/ms-playwright
+                      ~/Library/Caches/ms-playwright
+                      ~/AppData/Local/ms-playwright
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+                  restore-keys: |
+                      playwright-browsers-${{ runner.os }}-
+
             - name: Install root dependencies
               if: steps.root-cache.outputs.cache-hit != 'true'
               run: npm ci
@@ -68,17 +91,14 @@ jobs:
               if: matrix.runner == 'ubuntu'
               run: sudo apt-get update && sudo apt-get install -y xvfb
 
-            # Build the extension before running tests
-            - name: Build Tests and Extension
-              run: npm run pretest
-
+            # Run optimized E2E tests (eliminates redundant builds)
             - name: Run E2E tests - Linux
               if: matrix.runner == 'ubuntu'
-              run: xvfb-run -a npm run test:e2e
+              run: xvfb-run -a npm run test:e2e:optimal
 
             - name: Run E2E tests - Non-Linux
               if: matrix.runner != 'ubuntu'
-              run: npm run test:e2e
+              run: npm run test:e2e:optimal
 
             - uses: actions/upload-artifact@v4
               if: ${{ failure() }}

.github/workflows/publish.yml

@@ -94,6 +94,7 @@ jobs:
               env:
                   VSCE_PAT: ${{ secrets.VSCE_PAT }}
                   OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  CLINE_ENVIRONMENT: production
               run: |
                   # Required to generate the .vsix
                   vsce package --out "cline-${{ steps.get_version.outputs.version }}.vsix"

.gitignore

@@ -15,6 +15,9 @@ pnpm-lock.yaml
 .venv
 .actrc
 
+webview-ui/src/**/*.js
+webview-ui/src/**/*.js.map
+
 # Ignore coverage directories and files
 coverage
 # But don't ignore the coverage scripts in .github/scripts/
@@ -22,20 +25,10 @@ coverage
 
 *evals.env
 
-# Generated files
+## Generated files ##
 src/generated/
-# Core
-src/core/controller/*/methods.ts
-src/core/controller/*/index.ts
-src/core/controller/grpc-service-config.ts
-# Shared
-src/shared/proto/*.ts
-src/shared/proto/host/*.ts
-# Webview
+src/shared/proto/
 webview-ui/src/services/grpc-client.ts
-# Host bridge
-src/hosts/vscode/client/host-grpc-client.ts
-src/standalone/server-setup.ts
 
 # E2E Tests
 test-results

.prettierignore

@@ -5,4 +5,6 @@ webview-ui/build/
 package-lock.json
 src/core/prompts/system.ts
 src/core/prompts/model_prompts/claude4.ts
-evals/
+evals/
+docs/
+out/

.vscode/launch.json

@@ -6,7 +6,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension",
+			"name": "Run Extension (production)",
 			"type": "extensionHost",
 			"request": "launch",
 			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
@@ -14,7 +14,34 @@
 			"preLaunchTask": "${defaultBuildTask}",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
+			}
+		},
+		{
+			"name": "Run Extension (staging)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "${defaultBuildTask}",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "staging"
+			}
+		},
+		{
+			"name": "Run Extension (local)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
+			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"preLaunchTask": "${defaultBuildTask}",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "local"
 			}
 		},
 		{
@@ -37,7 +64,8 @@
 			"env": {
 				"IS_DEV": "true",
 				"TEMP_PROFILE": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
 			}
 		},
 		{

docs/docs.json

@@ -159,7 +159,8 @@
 					"provider-config/openai",
 					"provider-config/openai-compatible",
 					"provider-config/openrouter",
-					"provider-config/requesty"
+					"provider-config/requesty",
+					"provider-config/sap-aicore"
 				]
 			},
 			{

docs/package.json

@@ -4,13 +4,15 @@
 	"main": "index.js",
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
-		"dev": "mintlify dev"
+		"dev": "mintlify dev",
+		"check": "mintlify broken-links",
+		"rename": "mintlify rename"
 	},
 	"keywords": [],
 	"author": "",
 	"license": "ISC",
 	"description": "",
 	"dependencies": {
-		"mintlify": "^4.0.538"
+		"mintlify": "^4.2.23"
 	}
 }

docs/provider-config/claude-code.mdx

@@ -35,26 +35,8 @@ First, you'll need to install and authenticate Claude Code on your system:
 <br />
 
 <Accordion title="Windows Setup">
-On Windows, Cline supports integrating with Claude Code through WSL.
-Windows doesn't support long commands, and Claude Code only accepts the system prompt through a flag, which means we can't properly prompt Claude through Claude Code. Anthropic is [working on a workaround to streamline this](https://github.com/anthropics/claude-code/issues/3411).
-
-1. **Make sure you have WSL set-up**. You can follow [this](https://code.visualstudio.com/docs/remote/wsl#_installation) guide to do it.
-
-2. **Open VSCode from WSL** and verify it's properly set-up. You should see an indicator in the bottom left that says "WSL". You can find an image of the indicator [here](https://code.visualstudio.com/docs/remote/wsl#_from-the-wsl-terminal).
-
-3. Install Cline within WSL and make sure it shows the following:
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline_wsl_installed_extension.webp"
-		alt="Indicator that an extension is installed on WSL"
-	/>
-</Frame>
-
-4. Clone or [move](https://stackoverflow.com/a/42586455) your project over to WSL
-
-5. Follow the [instructions on how to set up Claude Code normally](#setup), but from the WSL terminal.
-
+	Anthropic introduced full support for Claude Code on Windows. Follow the [instructions on how to set up Claude Code
+	normally](#setup) and make sure you have the latest Claude Code and Cline versions.
 </Accordion>
 
 ### Finding your Claude Code path

docs/provider-config/sap-aicore.mdx

@@ -0,0 +1,39 @@
+---
+title: "SAP AI Core"
+description: "Learn how to configure and use LLM models from Generative AI Hub in SAP AI Core with Cline."
+---
+
+SAP AI Core and the generative AI hub help you to integrate LLMs and AI into new business processes in a cost-efficient manner.
+
+**Website:** [SAP Help Portal](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/what-is-sap-ai-core)
+
+### Getting a Service Binding
+
+> 💡 **Information**
+>
+> SAP AI Core, and Generative AI Hub, are offerings from SAP BTP.
+> You need an active SAP BTP contract and a existing subaccount with a SAP AI Core instance to perform these steps.
+
+1. **Access:** Go to your subaccount via [BTP Cloud Cockpit](cockpit.btp.cloud.sap/cockpit)
+2. **Create a Service Binding:** Go to "Instances and Subscriptions", select your SAP AI Core service instance and click on Service Bindings > Create.
+3. **Copy the Service Binding:** Copy the service binding values.
+
+### Supported Models
+
+SAP AI Core supports a large and growing number of models.
+Refer to the [Generative AI Hub Supported Models page](https://me.sap.com/notes/3437766) for the complete and up-to-date list.
+
+### Configuration in Cline
+
+1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
+2.  **Select Provider:** Choose "SAP AI Core" from the "API Provider" dropdown.
+3.  **Enter Client Id:** Add the `.clientid` field from the service binding into the "AI Core Client Id" field.
+4.  **Enter Client Secret:** Add the `.clientsecret` field from the service binding into the "AI Core Client Secret" field.
+5.  **Enter Base URL:** Add the `.serviceurls.AI_API_URL` field from the service binding into the "AI Core Base URL" field.
+6.  **Enter Auth URL:** Add the `.url` field from the service binding into the "AI Core Auth URL" field.
+7.  **Enter Resource Group:** Add the resource group where you have your model deployments. See [Create a Deployment for a Generative AI Model](https://help.sap.com/docs/sap-ai-core/sap-ai-core-service-guide/create-deployment-for-generative-ai-model-in-sap-ai-core).
+8.  **Select Model:** Choose your desired model from the "Model" dropdown.
+
+### Tips and Notes
+
+-   **Model Selection:** SAP AI Core offers a wide range of models. You won't be able to use the model, even if selected, if a deployment doesn't exist in the provided resource group.

eslint-rules/__tests__/no-grpc-client-object-literals.test.ts

@@ -1,174 +0,0 @@
-const { RuleTester: GrpcRuleTester } = require("eslint")
-const grpcRule = require("../no-grpc-client-object-literals")
-
-const grpcRuleTester = new GrpcRuleTester({
-	parser: require.resolve("@typescript-eslint/parser"),
-	parserOptions: {
-		ecmaVersion: 2020,
-		sourceType: "module",
-		ecmaFeatures: {
-			jsx: true,
-		},
-	},
-})
-
-grpcRuleTester.run("no-grpc-client-object-literals", grpcRule, {
-	valid: [
-		// Valid case: Using .create() method with gRPC client
-		{
-			code: `
-                import { TogglePlanActModeRequest } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                StateServiceClient.togglePlanActMode(
-                    TogglePlanActModeRequest.create({
-                        chatSettings: {
-                            mode: PlanActMode.PLAN,
-                            preferredLanguage: 'en',
-                        },
-                    })
-                );
-            `,
-		},
-		// Valid case: Using .fromPartial() method with gRPC client
-		{
-			code: `
-                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                const chatSettings = ChatSettings.fromPartial({
-                    mode: PlanActMode.PLAN,
-                    preferredLanguage: 'en',
-                });
-                
-                StateServiceClient.togglePlanActMode(
-                    TogglePlanActModeRequest.create({
-                        chatSettings: chatSettings,
-                    })
-                );
-            `,
-		},
-		// Valid case: Regular function call with object literal (not a gRPC client)
-		{
-			code: `
-                function processData(data) {
-                    console.log(data);
-                }
-                
-                processData({
-                    id: 123,
-                    name: 'test',
-                });
-            `,
-		},
-		// Valid case: Using proper nested protobuf objects
-		{
-			code: `
-                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                // Using proper nested protobuf objects
-                const chatSettings = ChatSettings.create({
-                    mode: 0,
-                    preferredLanguage: 'en',
-                });
-                
-                const request = TogglePlanActModeRequest.create({
-                    chatSettings: chatSettings,
-                });
-                
-                StateServiceClient.togglePlanActMode(request);
-            `,
-		},
-		// Valid case: Object literal in second parameter (should not be checked)
-		{
-			code: `
-                import { StateSubscribeRequest } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                const request = StateSubscribeRequest.create({
-                    topics: ['apiConfig', 'tasks']
-                });
-                
-                // Second parameter is an object literal but should not trigger the rule
-                StateServiceClient.subscribe(request, {
-                    metadata: {
-                        userId: 123,
-                        sessionId: "abc-123"
-                    }
-                });
-            `,
-		},
-	],
-	invalid: [
-		// Invalid case: Using object literal directly with gRPC client
-		{
-			code: `
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                StateServiceClient.togglePlanActMode({
-                    chatSettings: {
-                        mode: 0,
-                        preferredLanguage: 'en',
-                    },
-                });
-            `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Invalid case: Using object literal with nested properties
-		{
-			code: `
-                import { ChatSettings } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                const chatSettings = ChatSettings.create({
-                    mode: 0,
-                    preferredLanguage: 'en',
-                });
-                
-                StateServiceClient.togglePlanActMode({
-                    chatSettings: {
-                        mode: 1,
-                        preferredLanguage: 'fr',
-                    },
-                });
-            `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Invalid case: Nested object literal in protobuf create method
-		{
-			code: `
-                import { TogglePlanActModeRequest, ChatSettings } from '@shared/proto/state';
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                // Using nested object literal instead of ChatSettings.create()
-                const request = TogglePlanActModeRequest.create({
-                    chatSettings: {
-                        mode: 0,
-                        preferredLanguage: 'en',
-                    },
-                });
-                
-                StateServiceClient.togglePlanActMode(request);
-            `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-		// Invalid case: Object literal as first parameter to subscribe method
-		{
-			code: `
-                import { StateServiceClient } from '../services/grpc-client';
-                
-                // First parameter is an object literal, which should trigger the rule
-                StateServiceClient.subscribe({
-                    topics: ['apiConfig', 'tasks']
-                }, {
-                    metadata: {
-                        userId: 123,
-                        sessionId: "abc-123"
-                    }
-                });
-            `,
-			errors: [{ messageId: "useProtobufMethod" }],
-		},
-	],
-})

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

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

eslint-rules/index.js

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

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

@@ -11,8 +11,11 @@ const disallowedApis = {
 	"vscode.workspace.fs.stat": {
 		messageId: "useFsUtils",
 	},
+	"vscode.workspace.fs.writeFile": {
+		messageId: "useFsUtils",
+	},
 	"vscode.workspace.workspaceFolders": {
-		messageId: "useHostBridge",
+		messageId: "useHostBridgeWorkspace",
 	},
 	"vscode.workspace.asRelativePath": {
 		messageId: "usePathUtils",
@@ -20,6 +23,29 @@ const disallowedApis = {
 	"vscode.workspace.getWorkspaceFolder": {
 		messageId: "usePathUtils",
 	},
+	"vscode.window.showTextDocument": {
+		messageId: "useHostBridge",
+	},
+	"vscode.workspace.applyEdit": {
+		messageId: "useHostBridge",
+	},
+	// "vscode.env.openExternal": {
+	// 	messageId: "useUtils",
+	// },
+	// "vscode.window.showWarningMessage": {
+	// 	messageId: "useHostBridgeShowMessage",
+	// },
+	"vscode.window.showOpenDialog": {
+		messageId: "useHostBridgeShowMessage",
+	},
+	// There are too many warnings for these calls, uncomment the following
+	// when the migration is finished.
+	// "vscode.window.showErrorMessage": {
+	// 	messageId: "useHostBridgeShowMessage",
+	// },
+	// "vscode.window.showInformationMessage": {
+	// 	messageId: "useHostBridgeShowMessage",
+	// },
 }
 
 module.exports = createRule({
@@ -37,16 +63,28 @@ module.exports = createRule({
 				"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" +
+				"Use utilities in @/utils/fs instead of vscode.workspace.fs\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" +
+			usePathUtils:
+				"Use path utilities from @/utils/path instead of VSCode workspace path methods.\n" +
+				"This provides consistent path handling across different environments.\n" +
+				"Found: {{code}}",
+			useHostBridgeWorkspace:
+				"Use HostProvider.workspace.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" +
+			useHostBridgeShowMessage:
+				"Use HostProvider.window.showMessage instead of the vscode.window.showMessage.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			useHostBridge:
+				"Use the host bridge instead of calling vscode APIs directly.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			useUtils:
+				"Use utilities in @/utils instead of calling vscode APIs directly.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
 				"Found: {{code}}",
 		},
 		schema: [],
@@ -54,17 +92,10 @@ module.exports = createRule({
 	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) {
+			if (isExcluded(context.filename)) {
+				// Skip if this file is being excluded.
 				return
 			}
 
@@ -143,6 +174,20 @@ module.exports = createRule({
 			})
 		}
 
+		function isExcluded(filename) {
+			// Check if current file is in an exception directory or is grpc-client-base.ts
+			if (path.basename(filename) === "grpc-client-base.ts") {
+				return true
+			}
+			// Skip checking files in src/hosts/vscode or standalone/runtime-files
+			if (filename.includes("/src/hosts/vscode/")) {
+				return true
+			}
+			if (filename.includes("/standalone/runtime-files/")) {
+				return true
+			}
+		}
+
 		return {
 			// Detect basic member expressions (e.g., vscode.postMessage)
 			MemberExpression(node) {
@@ -152,7 +197,7 @@ module.exports = createRule({
 			// 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) {
+				if (isExcluded(context.filename)) {
 					return
 				}
 

eslint-rules/no-grpc-client-object-literals.js

@@ -1,216 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils")
-
-const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
-
-module.exports = createRule({
-	name: "no-grpc-client-object-literals",
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Enforce using .create() or .fromPartial() for gRPC service client parameters instead of object literals",
-			recommended: "error",
-		},
-		messages: {
-			useProtobufMethod:
-				"Use the appropriate protobuf .create() or .fromPartial() method instead of " +
-				"object literal for gRPC client parameters.\n" +
-				"Found: {{code}}\n" +
-				"gRPC client methods should always receive properly created protobuf objects.",
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-
-	create(context) {
-		// Check if a name matches the gRPC service client pattern using regex
-		// Must start with an uppercase letter and end with ServiceClient
-		const isGrpcServiceClient = (name) => {
-			return typeof name === "string" && /^[A-Z].*ServiceClient$/.test(name)
-		}
-
-		const safeObjectExpressions = new Map() // Track object expressions in create/fromPartial calls
-
-		return {
-			// Skip object literals inside create() or fromPartial() method calls
-			CallExpression(node) {
-				if (
-					node.callee &&
-					node.callee.type === "MemberExpression" &&
-					(node.callee.property.name === "create" || node.callee.property.name === "fromPartial") &&
-					node.arguments.length > 0 &&
-					node.arguments[0].type === "ObjectExpression"
-				) {
-					// Track this object expression as being used with create/fromPartial
-					safeObjectExpressions.set(node.arguments[0], { isProblematic: false })
-				}
-			},
-
-			// Track create/fromPartial calls that contain nested object literals
-			"CallExpression[callee.type='MemberExpression'][callee.property.name=/^(create|fromPartial)$/]"(node) {
-				if (node.arguments.length > 0 && node.arguments[0].type === "ObjectExpression") {
-					// Track problematic nested object literals
-					const nestedObjectLiterals = new Map() // Map of object expressions to their containing property paths
-
-					// Search for nested object literals
-					const queue = [
-						...node.arguments[0].properties.map((prop) => ({
-							property: prop,
-							path: prop.key && prop.key.name ? prop.key.name : "unknown",
-						})),
-					]
-
-					while (queue.length > 0) {
-						const { property, path } = queue.shift()
-
-						// Skip spread elements
-						if (property.type !== "Property") continue
-
-						// If this is an object literal, mark it as problematic
-						if (property.value.type === "ObjectExpression") {
-							nestedObjectLiterals.set(property.value, path)
-
-							// Add nested properties to queue
-							queue.push(
-								...property.value.properties.map((prop) => ({
-									property: prop,
-									path: `${path}.${prop.key && prop.key.name ? prop.key.name : "unknown"}`,
-								})),
-							)
-						}
-					}
-
-					// For each problematic nested object, track it with its path
-					nestedObjectLiterals.forEach((path, objectExpr) => {
-						safeObjectExpressions.set(objectExpr, {
-							isProblematic: true,
-							path: path,
-							parentNode: node,
-						})
-					})
-				}
-			},
-
-			// Check calls to gRPC service clients
-			"CallExpression[callee.type='MemberExpression']"(node) {
-				// Get the object (left side) of the member expression
-				const callee = node.callee
-				if (callee.object && callee.object.type === "Identifier") {
-					const objectName = callee.object.name
-
-					// Check if this is a call to one of our gRPC service clients
-					if (isGrpcServiceClient(objectName)) {
-						// Only check the first argument of gRPC service client calls
-						if (node.arguments.length > 0) {
-							const arg = node.arguments[0] // Only check the first parameter
-							if (arg.type === "ObjectExpression" && !safeObjectExpressions.has(arg)) {
-								// This is an object literal being passed directly to a gRPC client
-								const sourceCode = context.getSourceCode()
-								const callText = sourceCode.getText(node).trim()
-
-								context.report({
-									node: arg,
-									messageId: "useProtobufMethod",
-									data: {
-										code: callText,
-									},
-								})
-							} else if (arg.type === "ObjectExpression") {
-								// Search for nested object literals that aren't protected
-								const queue = [...arg.properties]
-								while (queue.length > 0) {
-									const property = queue.shift()
-
-									// Skip spread elements
-									if (property.type !== "Property") continue
-
-									// Check value
-									if (
-										property.value.type === "ObjectExpression" &&
-										!safeObjectExpressions.has(property.value)
-									) {
-										// Found a nested object literal
-										const sourceCode = context.getSourceCode()
-										const propertyText = sourceCode.getText(property).trim()
-
-										context.report({
-											node: property.value,
-											messageId: "useProtobufMethod",
-											data: {
-												code: `${objectName}.${callee.property.name}(... ${propertyText} ...)`,
-											},
-										})
-									}
-
-									// Add any nested properties to the queue
-									if (property.value.type === "ObjectExpression") {
-										queue.push(...property.value.properties)
-									}
-								}
-							} else if (arg.type === "Identifier") {
-								// This is a variable - check if it references a problematic protobuf object
-								const varName = arg.name
-								const sourceCode = context.getSourceCode()
-								const scope = sourceCode.getScope(node)
-
-								// Find the variable declaration
-								const variable = scope.variables.find((v) => v.name === varName)
-								if (variable && variable.references && variable.references.length > 0) {
-									// Look for definitions
-									const def = variable.defs.find(
-										(d) => d.node && d.node.type === "VariableDeclarator" && d.node.init,
-									)
-
-									if (
-										def &&
-										def.node.init.type === "CallExpression" &&
-										def.node.init.callee.type === "MemberExpression" &&
-										(def.node.init.callee.property.name === "create" ||
-											def.node.init.callee.property.name === "fromPartial")
-									) {
-										// Flag if we find problematic nested object literals in this create/fromPartial call
-										const callText = sourceCode.getText(node).trim()
-										const initCallText = sourceCode.getText(def.node.init).trim()
-
-										// Check for nested object literals in init node
-										let foundNestedLiteral = false
-										if (
-											def.node.init.arguments.length > 0 &&
-											def.node.init.arguments[0].type === "ObjectExpression"
-										) {
-											// Find any nested object literals
-											const queue = [...def.node.init.arguments[0].properties]
-											while (queue.length > 0 && !foundNestedLiteral) {
-												const property = queue.shift()
-
-												// Skip spread elements
-												if (property.type !== "Property") continue
-
-												if (property.value.type === "ObjectExpression") {
-													foundNestedLiteral = true
-
-													context.report({
-														node,
-														messageId: "useProtobufMethod",
-														data: {
-															code: `${callText} - using request created with nested object literal at: ${property.key.name}`,
-														},
-													})
-												}
-
-												// Add any nested properties to the queue
-												if (property.value.type === "ObjectExpression") {
-													queue.push(...property.value.properties)
-												}
-											}
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			},
-		}
-	},
-})

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

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

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.19.6",
+	"version": "3.20.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -186,6 +186,12 @@
 				"category": "Cline",
 				"icon": "$(robot)"
 			},
+			{
+				"command": "cline.abortGitCommitMessage",
+				"title": "Generate Commit Message with Cline - Stop",
+				"category": "Cline",
+				"icon": "$(debug-stop)"
+			},
 			{
 				"command": "cline.explainCode",
 				"title": "Explain with Cline",
@@ -213,7 +219,7 @@
 			},
 			{
 				"command": "cline.generateGitCommitMessage",
-				"when": "scmProvider == git"
+				"when": "config.git.enabled && scmProvider == git"
 			},
 			{
 				"command": "cline.focusChatInput",
@@ -306,13 +312,22 @@
 				{
 					"command": "cline.generateGitCommitMessage",
 					"group": "navigation",
-					"when": "scmProvider == git"
+					"when": "config.git.enabled && scmProvider == git && !cline.isGeneratingCommit"
+				},
+				{
+					"command": "cline.abortGitCommitMessage",
+					"group": "navigation",
+					"when": "config.git.enabled && scmProvider == git && cline.isGeneratingCommit"
 				}
 			],
 			"commandPalette": [
 				{
 					"command": "cline.generateGitCommitMessage",
-					"when": "scmProvider == git"
+					"when": "config.git.enabled && scmProvider == git && !cline.isGeneratingCommit"
+				},
+				{
+					"command": "cline.abortGitCommitMessage",
+					"when": "config.git.enabled && scmProvider == git && cline.isGeneratingCommit"
 				}
 			]
 		},
@@ -330,7 +345,7 @@
 		"watch:esbuild": "node esbuild.js --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
 		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.js --production",
-		"protos": "node scripts/build-proto.mjs && node scripts/generate-server-setup.mjs && node scripts/generate-host-bridge-client.mjs",
+		"protos": "node scripts/build-proto.mjs && node scripts/generate-protobus-setup.mjs && node scripts/generate-host-bridge-client.mjs",
 		"postprotos": "prettier src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --log-level warn",
 		"clean": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"compile-tests": "node ./scripts/build-tests.js",
@@ -347,6 +362,7 @@
 		"test:coverage": "vscode-test --coverage",
 		"e2e": "playwright test -c playwright.config.ts",
 		"test:e2e": "playwright install && vsce package --no-dependencies --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
+		"test:e2e:optimal": "vsce package --no-dependencies --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
 		"install:all": "npm install && cd webview-ui && npm install",
 		"dev:webview": "cd webview-ui && npm run dev",
 		"build:webview": "cd webview-ui && npm run build",
@@ -356,9 +372,9 @@
 		"prepare": "husky",
 		"changeset": "changeset",
 		"version-packages": "changeset version",
-		"docs": "cd docs && mintlify dev",
-		"docs:check-links": "cd docs && mintlify broken-links",
-		"docs:rename-file": "cd docs && mintlify rename",
+		"docs": "cd docs && npm run dev",
+		"docs:check-links": "cd docs && npm run check",
+		"docs:rename-file": "cd docs && npm run rename",
 		"report-issue": "node scripts/report-issue.js"
 	},
 	"lint-staged": {
@@ -396,7 +412,6 @@
 		"husky": "^9.1.7",
 		"lint-staged": "^16.1.0",
 		"minimatch": "^3.0.3",
-		"mintlify": "^4.0.515",
 		"npm-run-all": "^4.1.5",
 		"prettier": "^3.3.3",
 		"protoc-gen-ts": "^0.8.7",

proto/account.proto

@@ -53,6 +53,7 @@ message UserInfo {
   optional string display_name = 2;
   optional string email = 3;
   optional string photo_url = 4;
+  optional string app_base_url = 5; // Cline app base URL
 }
 
 message UserOrganization {

proto/host/diff.proto

@@ -10,7 +10,16 @@ import "common.proto";
 service DiffService {
   // Open the diff view/editor.
   rpc openDiff(OpenDiffRequest) returns (OpenDiffResponse);
+  // Get the contents of the diff view.
+  rpc getDocumentText(GetDocumentTextRequest) returns (GetDocumentTextResponse);
+  // Replace a text selection in the diff.
   rpc replaceText(ReplaceTextRequest) returns (ReplaceTextResponse);
+  // Truncate the diff document.
+  rpc truncateDocument(TruncateDocumentRequest) returns (TruncateDocumentResponse);
+  // Save the diff document.
+  rpc saveDocument(SaveDocumentRequest) returns (SaveDocumentResponse);
+  // Close the diff editor UI.
+  rpc closeDiff(CloseDiffRequest) returns (CloseDiffResponse);
 }
 
 message OpenDiffRequest {
@@ -26,6 +35,15 @@ message OpenDiffResponse {
   optional string diff_id = 1;
 }
 
+message GetDocumentTextRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+}
+
+message GetDocumentTextResponse {
+    optional string content = 1;
+}
+
 message ReplaceTextRequest {
   optional cline.Metadata metadata = 1;
   optional string diff_id = 2;
@@ -34,6 +52,26 @@ message ReplaceTextRequest {
   optional int32 end_line = 5;
 }
 
-message ReplaceTextResponse {
-  // TBD
+message ReplaceTextResponse {}
+
+message TruncateDocumentRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+  optional int32 end_line = 5;
 }
+
+message TruncateDocumentResponse {}
+
+message CloseDiffRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+}
+
+message CloseDiffResponse {}
+
+message SaveDocumentRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+}
+
+message SaveDocumentResponse {}

proto/host/watch.proto

@@ -6,6 +6,10 @@ option java_multiple_files = true;
 
 import "common.proto";
 
+/** 
+ * The watch service is only here as example of a streaming rpc in the host bridge. 
+ * This being replaced with a native JS file watcher.
+ */
 // WatchService provides methods for watching files in the IDE
 service WatchService {
   // Subscribe to file changes

proto/host/window.proto

@@ -12,6 +12,8 @@ service WindowService {
   rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
   rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
   rpc showMessage(ShowMessageRequest) returns (SelectedResponse);
+  rpc showInputBox(ShowInputBoxRequest) returns (ShowInputBoxResponse);
+  rpc showSaveDialog(ShowSaveDialogRequest) returns (ShowSaveDialogResponse);
 }
 
 message ShowTextDocumentRequest {
@@ -70,4 +72,33 @@ message ShowMessageRequestOptions {
 
 message SelectedResponse {
   optional string selected_option = 1;
+}
+
+message ShowSaveDialogRequest {
+  cline.Metadata metadata = 1;
+  optional ShowSaveDialogOptions options = 2;
+}
+
+message ShowSaveDialogOptions {
+  optional string default_path = 1;
+  map<string, FileExtensionList> filters = 2;
+}
+
+message FileExtensionList {
+  repeated string extensions = 1;
+}
+
+message ShowSaveDialogResponse {
+  optional string selected_path = 1;
+}
+
+message ShowInputBoxRequest {
+  cline.Metadata metadata = 1;
+  string title = 2;
+  optional string prompt = 3;
+  optional string value = 4;
+}
+
+message ShowInputBoxResponse {
+  optional string response = 1;
 }

proto/host/workspace.proto

@@ -4,10 +4,14 @@ package host;
 option java_package = "bot.cline.host.proto";
 option java_multiple_files = true;
 
+import "common.proto";
+
 // Provides methods for working with workspaces/projects.
 service WorkspaceService {
   // Returns a list of the top level directories of the workspace.
   rpc getWorkspacePaths(GetWorkspacePathsRequest) returns (GetWorkspacePathsResponse);
+  // Saves an open document if it's dirty
+  rpc saveOpenDocumentIfDirty(SaveOpenDocumentIfDirtyRequest) returns (cline.Empty);
 }
 
 message GetWorkspacePathsRequest {
@@ -22,3 +26,8 @@ message GetWorkspacePathsResponse {
   optional string id = 1;
   repeated string paths = 2;
 }
+
+message SaveOpenDocumentIfDirtyRequest {
+  cline.Metadata metadata = 1;
+  string file_path = 2;
+}

proto/models.proto

@@ -15,6 +15,8 @@ service ModelsService {
   rpc getVsCodeLmModels(EmptyRequest) returns (VsCodeLmModelsArray);
   // Refreshes and returns OpenRouter models
   rpc refreshOpenRouterModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns Hugging Face models
+  rpc refreshHuggingFaceModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns OpenAI models
   rpc refreshOpenAiModels(OpenAiModelsRequest) returns (StringArray);
   // Refreshes and returns Requesty models
@@ -126,6 +128,7 @@ enum ApiProvider {
   SAPAICORE = 25;
   CLAUDE_CODE = 26;
   MOONSHOT = 27;
+  HUGGINGFACE = 28;
 }
 
 // Model info for OpenAI-compatible models
@@ -165,85 +168,119 @@ message LiteLLMModelInfo {
 
 // Main ApiConfiguration message
 message ModelsApiConfiguration {
-  // From ApiHandlerOptions (excluding onRetryAttempt function)
-  optional string api_model_id = 1;
-  optional string api_key = 2;
-  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;
-  optional string lite_llm_api_key = 7;
-  optional bool lite_llm_use_prompt_cache = 8;
-  map<string, string> open_ai_headers = 9;
-  optional LiteLLMModelInfo lite_llm_model_info = 10;
-  optional string anthropic_base_url = 11;
-  optional string open_router_api_key = 12;
-  optional string open_router_model_id = 13;
-  optional OpenRouterModelInfo open_router_model_info = 14;
-  optional string open_router_provider_sorting = 15;
-  optional string aws_access_key = 16;
-  optional string aws_secret_key = 17;
-  optional string aws_session_token = 18;
-  optional string aws_region = 19;
-  optional bool aws_use_cross_region_inference = 20;
-  optional bool aws_bedrock_use_prompt_cache = 21;
-  optional bool aws_use_profile = 22;
-  optional string aws_profile = 23;
-  optional string aws_bedrock_endpoint = 24;
-  optional bool aws_bedrock_custom_selected = 25;
-  optional string aws_bedrock_custom_model_base_id = 26;
-  optional string vertex_project_id = 27;
-  optional string vertex_region = 28;
-  optional string open_ai_base_url = 29;
-  optional string open_ai_api_key = 30;
-  optional string open_ai_model_id = 31;
-  optional OpenAiCompatibleModelInfo open_ai_model_info = 32;
-  optional string ollama_model_id = 33;
-  optional string ollama_base_url = 34;
-  optional string ollama_api_options_ctx_num = 35;
-  optional string lm_studio_model_id = 36;
-  optional string lm_studio_base_url = 37;
-  optional string gemini_api_key = 38;
-  optional string gemini_base_url = 39;
-  optional string open_ai_native_api_key = 40;
-  optional string deep_seek_api_key = 41;
-  optional string requesty_api_key = 42;
-  optional string requesty_model_id = 43;
-  optional OpenRouterModelInfo requesty_model_info = 44;
-  optional string together_api_key = 45;
-  optional string together_model_id = 46;
-  optional string fireworks_api_key = 47;
-  optional string fireworks_model_id = 48;
-  optional int32 fireworks_model_max_completion_tokens = 49;
-  optional int32 fireworks_model_max_tokens = 50;
-  optional string qwen_api_key = 51;
-  optional string doubao_api_key = 52;
-  optional string mistral_api_key = 53;
-  optional string azure_api_version = 54;
-  optional LanguageModelChatSelector vs_code_lm_model_selector = 55;
-  optional string qwen_api_line = 56;
-  optional string nebius_api_key = 57;
-  optional string asksage_api_url = 58;
-  optional string asksage_api_key = 59;
-  optional string xai_api_key = 60;
-  optional int32 thinking_budget_tokens = 61;
-  optional string reasoning_effort = 62;
-  optional string sambanova_api_key = 63;
-  optional string cerebras_api_key = 64;
-  optional int32 request_timeout_ms = 65;
-  optional ApiProvider api_provider = 66;
-  repeated string favorited_model_ids = 67;
-  optional string sap_ai_core_client_id = 68;
-  optional string sap_ai_core_client_secret = 69;
-  optional string sap_ai_resource_group = 70;
-  optional string sap_ai_core_token_url = 71;
-  optional string sap_ai_core_base_url = 72;
-  optional string claude_code_path = 73;
-  optional string aws_authentication = 74;
-  optional string aws_bedrock_api_key = 75;
-  optional string moonshot_api_key = 76;
-  optional string moonshot_api_line = 77;
-  optional string groq_api_key = 78;
-  optional string groq_model_id = 79;
-  optional OpenRouterModelInfo groq_model_info = 80;
+  // Global configuration fields (not mode-specific)
+  optional string api_key = 1;
+  optional string cline_api_key = 2;
+  optional string task_id = 3;
+  optional string lite_llm_base_url = 4;
+  optional string lite_llm_api_key = 5;
+  optional bool lite_llm_use_prompt_cache = 6;
+  map<string, string> open_ai_headers = 7;
+  optional string anthropic_base_url = 8;
+  optional string open_router_api_key = 9;
+  optional string open_router_provider_sorting = 10;
+  optional string aws_access_key = 11;
+  optional string aws_secret_key = 12;
+  optional string aws_session_token = 13;
+  optional string aws_region = 14;
+  optional bool aws_use_cross_region_inference = 15;
+  optional bool aws_bedrock_use_prompt_cache = 16;
+  optional bool aws_use_profile = 17;
+  optional string aws_profile = 18;
+  optional string aws_bedrock_endpoint = 19;
+  optional string claude_code_path = 20;
+  optional string vertex_project_id = 21;
+  optional string vertex_region = 22;
+  optional string open_ai_base_url = 23;
+  optional string open_ai_api_key = 24;
+  optional string ollama_base_url = 25;
+  optional string ollama_api_options_ctx_num = 26;
+  optional string lm_studio_base_url = 27;
+  optional string gemini_api_key = 28;
+  optional string gemini_base_url = 29;
+  optional string open_ai_native_api_key = 30;
+  optional string deep_seek_api_key = 31;
+  optional string requesty_api_key = 32;
+  optional string together_api_key = 33;
+  optional string fireworks_api_key = 34;
+  optional int32 fireworks_model_max_completion_tokens = 35;
+  optional int32 fireworks_model_max_tokens = 36;
+  optional string qwen_api_key = 37;
+  optional string doubao_api_key = 38;
+  optional string mistral_api_key = 39;
+  optional string azure_api_version = 40;
+  optional string qwen_api_line = 41;
+  optional string nebius_api_key = 42;
+  optional string asksage_api_url = 43;
+  optional string asksage_api_key = 44;
+  optional string xai_api_key = 45;
+  optional string sambanova_api_key = 46;
+  optional string cerebras_api_key = 47;
+  optional int32 request_timeout_ms = 48;
+  optional string sap_ai_core_client_id = 49;
+  optional string sap_ai_core_client_secret = 50;
+  optional string sap_ai_resource_group = 51;
+  optional string sap_ai_core_token_url = 52;
+  optional string sap_ai_core_base_url = 53;
+  optional string moonshot_api_key = 54;
+  optional string moonshot_api_line = 55;
+  optional string aws_authentication = 56;
+  optional string aws_bedrock_api_key = 57;
+  optional string cline_account_id = 58;
+  optional string groq_api_key = 59;
+  optional string hugging_face_api_key = 60;
+
+  // Plan mode configurations
+  optional ApiProvider plan_mode_api_provider = 100;
+  optional string plan_mode_api_model_id = 101;
+  optional int32 plan_mode_thinking_budget_tokens = 102;
+  optional string plan_mode_reasoning_effort = 103;
+  optional LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 104;
+  optional bool plan_mode_aws_bedrock_custom_selected = 105;
+  optional string plan_mode_aws_bedrock_custom_model_base_id = 106;
+  optional string plan_mode_open_router_model_id = 107;
+  optional OpenRouterModelInfo plan_mode_open_router_model_info = 108;
+  optional string plan_mode_open_ai_model_id = 109;
+  optional OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 110;
+  optional string plan_mode_ollama_model_id = 111;
+  optional string plan_mode_lm_studio_model_id = 112;
+  optional string plan_mode_lite_llm_model_id = 113;
+  optional LiteLLMModelInfo plan_mode_lite_llm_model_info = 114;
+  optional string plan_mode_requesty_model_id = 115;
+  optional OpenRouterModelInfo plan_mode_requesty_model_info = 116;
+  optional string plan_mode_together_model_id = 117;
+  optional string plan_mode_fireworks_model_id = 118;
+  optional string plan_mode_sap_ai_core_model_id = 119;
+  optional string plan_mode_groq_model_id = 120;
+  optional OpenRouterModelInfo plan_mode_groq_model_info = 121;
+  optional string plan_mode_hugging_face_model_id = 122;
+  optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 123;
+
+  // Act mode configurations
+  optional ApiProvider act_mode_api_provider = 200;
+  optional string act_mode_api_model_id = 201;
+  optional int32 act_mode_thinking_budget_tokens = 202;
+  optional string act_mode_reasoning_effort = 203;
+  optional LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 204;
+  optional bool act_mode_aws_bedrock_custom_selected = 205;
+  optional string act_mode_aws_bedrock_custom_model_base_id = 206;
+  optional string act_mode_open_router_model_id = 207;
+  optional OpenRouterModelInfo act_mode_open_router_model_info = 208;
+  optional string act_mode_open_ai_model_id = 209;
+  optional OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 210;
+  optional string act_mode_ollama_model_id = 211;
+  optional string act_mode_lm_studio_model_id = 212;
+  optional string act_mode_lite_llm_model_id = 213;
+  optional LiteLLMModelInfo act_mode_lite_llm_model_info = 214;
+  optional string act_mode_requesty_model_id = 215;
+  optional OpenRouterModelInfo act_mode_requesty_model_info = 216;
+  optional string act_mode_together_model_id = 217;
+  optional string act_mode_fireworks_model_id = 218;
+  optional string act_mode_sap_ai_core_model_id = 219;
+  optional string act_mode_groq_model_id = 220;
+  optional OpenRouterModelInfo act_mode_groq_model_info = 221;
+  optional string act_mode_hugging_face_model_id = 222;
+  optional OpenRouterModelInfo act_mode_hugging_face_model_info = 223;
+
+  repeated string favorited_model_ids = 300;
 }

proto/state.proto

@@ -118,126 +118,113 @@ message UpdateSettingsRequest {
 
 // Complete API Configuration message
 message ApiConfiguration {
-  // Core API fields
-  optional string api_provider = 1;
-  optional string api_model_id = 2;
-  optional string api_key = 3; // anthropic
-  optional string api_base_url = 4;
+  // Global configuration fields (not mode-specific)
+  optional string api_key = 1; // anthropic
+  optional string cline_api_key = 2;
+  optional string task_id = 3;
+  optional string lite_llm_base_url = 4;
+  optional string lite_llm_api_key = 5;
+  optional bool lite_llm_use_prompt_cache = 6;
+  optional string openai_headers = 7; // JSON string
+  optional string anthropic_base_url = 8;
+  optional string openrouter_api_key = 9;
+  optional string openrouter_provider_sorting = 10;
+  optional string aws_access_key = 11;
+  optional string aws_secret_key = 12;
+  optional string aws_session_token = 13;
+  optional string aws_region = 14;
+  optional bool aws_use_cross_region_inference = 15;
+  optional bool aws_bedrock_use_prompt_cache = 16;
+  optional bool aws_use_profile = 17;
+  optional string aws_profile = 18;
+  optional string aws_bedrock_endpoint = 19;
+  optional string claude_code_path = 20;
+  optional string vertex_project_id = 21;
+  optional string vertex_region = 22;
+  optional string openai_base_url = 23;
+  optional string openai_api_key = 24;
+  optional string ollama_base_url = 25;
+  optional string ollama_api_options_ctx_num = 26;
+  optional string lm_studio_base_url = 27;
+  optional string gemini_api_key = 28;
+  optional string gemini_base_url = 29;
+  optional string openai_native_api_key = 30;
+  optional string deep_seek_api_key = 31;
+  optional string requesty_api_key = 32;
+  optional string together_api_key = 33;
+  optional string fireworks_api_key = 34;
+  optional int64 fireworks_model_max_completion_tokens = 35;
+  optional int64 fireworks_model_max_tokens = 36;
+  optional string qwen_api_key = 37;
+  optional string doubao_api_key = 38;
+  optional string mistral_api_key = 39;
+  optional string azure_api_version = 40;
+  optional string qwen_api_line = 41;
+  optional string nebius_api_key = 42;
+  optional string asksage_api_url = 43;
+  optional string asksage_api_key = 44;
+  optional string xai_api_key = 45;
+  optional string sambanova_api_key = 46;
+  optional string cerebras_api_key = 47;
+  optional int64 request_timeout_ms = 48;
+  optional string sap_ai_core_client_id = 49;
+  optional string sap_ai_core_client_secret = 50;
+  optional string sap_ai_resource_group = 51;
+  optional string sap_ai_core_token_url = 52;
+  optional string sap_ai_core_base_url = 53;
+  optional string moonshot_api_key = 54;
+  optional string moonshot_api_line = 55;
   
-  // Provider-specific API keys
-  optional string cline_account_id = 5;
-  optional string openrouter_api_key = 6;
-  optional string anthropic_base_url = 7;
-  optional string openai_api_key = 8;
-  optional string openai_native_api_key = 9;
-  optional string gemini_api_key = 10;
-  optional string deepseek_api_key = 11;
-  optional string requesty_api_key = 12;
-  optional string together_api_key = 13;
-  optional string fireworks_api_key = 14;
-  optional string qwen_api_key = 15;
-  optional string doubao_api_key = 16;
-  optional string mistral_api_key = 17;
-  optional string nebius_api_key = 18;
-  optional string asksage_api_key = 19;
-  optional string xai_api_key = 20;
-  optional string sambanova_api_key = 21;
-  optional string cerebras_api_key = 22;
+  // Plan mode configurations
+  optional string plan_mode_api_provider = 100;
+  optional string plan_mode_api_model_id = 101;
+  optional int64 plan_mode_thinking_budget_tokens = 102;
+  optional string plan_mode_reasoning_effort = 103;
+  optional string plan_mode_vscode_lm_model_selector = 104; // JSON string
+  optional bool plan_mode_aws_bedrock_custom_selected = 105;
+  optional string plan_mode_aws_bedrock_custom_model_base_id = 106;
+  optional string plan_mode_openrouter_model_id = 107;
+  optional string plan_mode_openrouter_model_info = 108; // JSON string
+  optional string plan_mode_openai_model_id = 109;
+  optional string plan_mode_openai_model_info = 110; // JSON string
+  optional string plan_mode_ollama_model_id = 111;
+  optional string plan_mode_lm_studio_model_id = 112;
+  optional string plan_mode_lite_llm_model_id = 113;
+  optional string plan_mode_lite_llm_model_info = 114; // JSON string
+  optional string plan_mode_requesty_model_id = 115;
+  optional string plan_mode_requesty_model_info = 116; // JSON string
+  optional string plan_mode_together_model_id = 117;
+  optional string plan_mode_fireworks_model_id = 118;
+  optional string plan_mode_sap_ai_core_model_id = 119;
   
-  // Model IDs
-  optional string openrouter_model_id = 23;
-  optional string openai_model_id = 24;
-  optional string anthropic_model_id = 25;
-  optional string bedrock_model_id = 26;
-  optional string vertex_model_id = 27;
-  optional string gemini_model_id = 28;
-  optional string ollama_model_id = 29;
-  optional string lm_studio_model_id = 30;
-  optional string litellm_model_id = 31;
-  optional string requesty_model_id = 32;
-  optional string together_model_id = 33;
-  optional string fireworks_model_id = 34;
-  
-  // AWS Bedrock fields
-  optional bool aws_bedrock_custom_selected = 35;
-  optional string aws_bedrock_custom_model_base_id = 36;
-  optional string aws_access_key = 37;
-  optional string aws_secret_key = 38;
-  optional string aws_session_token = 39;
-  optional string aws_region = 40;
-  optional bool aws_use_cross_region_inference = 41;
-  optional bool aws_bedrock_use_prompt_cache = 42;
-  optional bool aws_use_profile = 43;
-  optional string aws_profile = 44;
-  optional string aws_bedrock_endpoint = 45;
-  
-  // Vertex AI fields
-  optional string vertex_project_id = 46;
-  optional string vertex_region = 47;
-  
-  // Base URLs and endpoints
-  optional string openai_base_url = 48;
-  optional string ollama_base_url = 49;
-  optional string lm_studio_base_url = 50;
-  optional string gemini_base_url = 51;
-  optional string litellm_base_url = 52;
-  optional string asksage_api_url = 53;
-  
-  // LiteLLM specific fields
-  optional string litellm_api_key = 54;
-  optional bool litellm_use_prompt_cache = 55;
-  
-  // Model configuration
-  optional int64 thinking_budget_tokens = 56;
-  optional string reasoning_effort = 57;
-  optional int64 request_timeout_ms = 58;
-  
-  // Fireworks specific
-  optional int64 fireworks_model_max_completion_tokens = 59;
-  optional int64 fireworks_model_max_tokens = 60;
-  
-  // Azure specific
-  optional string azure_api_version = 61;
-  
-  // Ollama specific
-  optional string ollama_api_options_ctx_num = 62;
-  
-  // Qwen specific
-  optional string qwen_api_line = 63;
-  
-  // OpenRouter specific
-  optional string openrouter_provider_sorting = 64;
-  
-  // VSCode LM (stored as JSON string due to complex type)
-  optional string vscode_lm_model_selector = 65;
-  
-  // Model info objects (stored as JSON strings)
-  optional string openrouter_model_info = 66;
-  optional string openai_model_info = 67;
-  optional string requesty_model_info = 68;
-  optional string litellm_model_info = 69;
-  
-  // OpenAI headers (stored as JSON string)
-  optional string openai_headers = 70;
+  // Act mode configurations
+  optional string act_mode_api_provider = 200;
+  optional string act_mode_api_model_id = 201;
+  optional int64 act_mode_thinking_budget_tokens = 202;
+  optional string act_mode_reasoning_effort = 203;
+  optional string act_mode_vscode_lm_model_selector = 204; // JSON string
+  optional bool act_mode_aws_bedrock_custom_selected = 205;
+  optional string act_mode_aws_bedrock_custom_model_base_id = 206;
+  optional string act_mode_openrouter_model_id = 207;
+  optional string act_mode_openrouter_model_info = 208; // JSON string
+  optional string act_mode_openai_model_id = 209;
+  optional string act_mode_openai_model_info = 210; // JSON string
+  optional string act_mode_ollama_model_id = 211;
+  optional string act_mode_lm_studio_model_id = 212;
+  optional string act_mode_lite_llm_model_id = 213;
+  optional string act_mode_lite_llm_model_info = 214; // JSON string
+  optional string act_mode_requesty_model_id = 215;
+  optional string act_mode_requesty_model_info = 216; // JSON string
+  optional string act_mode_together_model_id = 217;
+  optional string act_mode_fireworks_model_id = 218;
+  optional string act_mode_sap_ai_core_model_id = 219;
   
   // Favorited model IDs
-  repeated string favorited_model_ids = 71;
-
-  // SAP AI Core specific
-  optional string sap_ai_core_client_id = 72;
-  optional string sap_ai_core_client_secret = 73;
-  optional string sap_ai_core_base_url = 74;
-  optional string sap_ai_core_token_url = 75;
-  optional string sap_ai_resource_group = 76;
-
-  // Claude Code specific
-  optional string claude_code_path = 77;
+  repeated string favorited_model_ids = 300;
 
   // Extension fields for Bedrock Api Keys
-  optional string aws_authentication = 78;
-  optional string aws_bedrock_api_key = 79;
+  optional string aws_authentication = 301;
+  optional string aws_bedrock_api_key = 302;
 
-  // Moonshot
-  optional string moonshot_api_key = 80;
-  optional string moonshot_api_line = 81;
+  optional string cline_account_id = 303;
 }

scripts/build-proto-config.mjs

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

scripts/build-proto.mjs

@@ -1,21 +1,18 @@
 #!/usr/bin/env node
 
+import chalk from "chalk"
+import { execSync } from "child_process"
 import * as fs from "fs/promises"
+import { globby } from "globby"
+import { createRequire } from "module"
+import os from "os"
 import * as path from "path"
 import { fileURLToPath } from "url"
-import { execSync } from "child_process"
-import { globby } from "globby"
-import chalk from "chalk"
-import os from "os"
-
-import { createRequire } from "module"
-import { serviceNameMap } from "./build-proto-config.mjs"
+import { rmrf } from "./file-utils.mjs"
 
 const require = createRequire(import.meta.url)
 const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 
-const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
-
 const PROTO_DIR = path.resolve("proto")
 const TS_OUT_DIR = path.resolve("src/shared/proto")
 const GRPC_JS_OUT_DIR = path.resolve("src/generated/grpc-js")
@@ -36,11 +33,10 @@ const TS_PROTO_OPTIONS = [
 	"useDate=false", // Timestamp fields will not be automatically converted to Date.
 ]
 
-// Service directories derived from imported serviceNameMap
-const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join("src/core/controller", serviceKey))
-
 async function main() {
-	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))
+	console.log(chalk.bold.blue("Compiling Protocol Buffers..."))
+
+	await cleanup()
 
 	// Check for Apple Silicon compatibility before proceeding
 	checkAppleSiliconCompatibility()
@@ -50,11 +46,6 @@ async function main() {
 		await fs.mkdir(dir, { recursive: true })
 	}
 
-	await cleanup()
-
-	// Check for missing proto files for services in serviceNameMap
-	await ensureProtoFilesExist()
-
 	// Process all proto files
 	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR, realpath: true })
 	console.log(chalk.cyan(`Processing ${protoFiles.length} proto files from`), PROTO_DIR)
@@ -83,12 +74,6 @@ async function main() {
 
 	log_verbose(chalk.green("Protocol Buffer code generation completed successfully."))
 	log_verbose(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))
-
-	await generateProtoBusServiceConfig()
-	await generateProtoBusMethodRegistrations()
-	await generateProtoBusGrpcClientConfig()
-
-	console.log(chalk.bold.blue("Finished Protocol Buffer code generation."))
 }
 
 async function tsProtoc(outDir, protoFiles, protoOptions) {
@@ -111,329 +96,17 @@ async function tsProtoc(outDir, protoFiles, protoOptions) {
 	}
 }
 
-/**
- * Generate a gRPC client configuration file for the webview
- * This eliminates the need for manual imports and client creation in grpc-client.ts
- */
-async function generateProtoBusGrpcClientConfig() {
-	log_verbose(chalk.cyan("Generating gRPC client configuration..."))
-
-	const serviceImports = []
-	const serviceClientCreations = []
-	const serviceExports = []
-
-	// Process each service in the serviceNameMap
-	for (const [dirName, _fullServiceName] of Object.entries(serviceNameMap)) {
-		const capitalizedName = dirName.charAt(0).toUpperCase() + dirName.slice(1)
-
-		// Add import statement
-		serviceImports.push(`import { ${capitalizedName}ServiceDefinition } from "@shared/proto/${dirName}"`)
-
-		// Add client creation
-		serviceClientCreations.push(
-			`const ${capitalizedName}ServiceClient = createGrpcClient(${capitalizedName}ServiceDefinition)`,
-		)
-
-		// Add to exports
-		serviceExports.push(`${capitalizedName}ServiceClient`)
-	}
-
-	// Generate the file content
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-import { createGrpcClient } from "./grpc-client-base"
-${serviceImports.join("\n")}
-
-${serviceClientCreations.join("\n")}
-
-export {
-	${serviceExports.join(",\n\t")}
-}`
-
-	const filePath = path.resolve("webview-ui/src/services/grpc-client.ts")
-	await writeFileWithMkdirs(filePath, content)
-	log_verbose(chalk.green(`Generated gRPC client at ${filePath}`))
-}
-
-/**
- * Parse proto files to extract streaming method information
- * @param protoFiles Array of proto file names
- * @param scriptDir Directory containing proto files
- * @returns Map of service names to their streaming methods
- */
-async function parseProtoForStreamingMethods(protoFiles, scriptDir) {
-	log_verbose(chalk.cyan("Parsing proto files for streaming methods..."))
-
-	// Map of service name to array of streaming method names
-	const streamingMethodsMap = new Map()
-
-	for (const protoFile of protoFiles) {
-		const content = await fs.readFile(path.join(scriptDir, protoFile), "utf8")
-
-		// Extract package name
-		const packageMatch = content.match(/package\s+([^;]+);/)
-		const packageName = packageMatch ? packageMatch[1].trim() : "unknown"
-
-		// Extract service definitions
-		const serviceMatches = Array.from(content.matchAll(/service\s+(\w+)\s*\{([^}]+)\}/g))
-		for (const serviceMatch of serviceMatches) {
-			const serviceName = serviceMatch[1]
-			const serviceBody = serviceMatch[2]
-			const fullServiceName = `${packageName}.${serviceName}`
-
-			// Extract method definitions with streaming
-			const methodMatches = Array.from(
-				serviceBody.matchAll(/rpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s*returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g),
-			)
-
-			const streamingMethods = []
-			for (const methodMatch of methodMatches) {
-				const methodName = methodMatch[1]
-				const isRequestStreaming = !!methodMatch[2]
-				const requestType = methodMatch[3]
-				const isResponseStreaming = !!methodMatch[4]
-				const responseType = methodMatch[5]
-
-				if (isResponseStreaming) {
-					streamingMethods.push({
-						name: methodName,
-						requestType,
-						responseType,
-						isRequestStreaming,
-					})
-				}
-			}
-
-			if (streamingMethods.length > 0) {
-				streamingMethodsMap.set(fullServiceName, streamingMethods)
-			}
-		}
-	}
-
-	return streamingMethodsMap
-}
-
-async function generateProtoBusMethodRegistrations() {
-	log_verbose(chalk.cyan("Generating method registration files..."))
-
-	// Parse proto files for streaming methods
-	const protoFiles = await globby("*.proto", { cwd: PROTO_DIR })
-	const streamingMethodsMap = await parseProtoForStreamingMethods(protoFiles, PROTO_DIR)
-
-	for (const serviceDir of serviceDirs) {
-		const serviceName = path.basename(serviceDir)
-		const fullServiceName = serviceNameMap[serviceName]
-		const streamingMethods = streamingMethodsMap.get(fullServiceName) || []
-
-		log_verbose(chalk.cyan(`Generating method registrations for ${serviceName}...`))
-
-		// Get all TypeScript files in the service directory
-		const files = await globby("*.ts", { cwd: serviceDir })
-
-		// Filter out index.ts and methods.ts
-		const implementationFiles = files.filter((file) => file !== "index.ts" && file !== "methods.ts")
-
-		// Create the methods.ts file with header
-		let methodsContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-// Import all method implementations
-import { registerMethod } from "./index"\n`
-
-		// Import implementations directly
-		for (const file of implementationFiles) {
-			const baseName = path.basename(file, ".ts")
-			methodsContent += `import { ${baseName} } from "./${baseName}"\n`
-		}
-
-		// Add streaming methods information
-		if (streamingMethods.length > 0) {
-			methodsContent += `\n// Streaming methods for this service
-export const streamingMethods = ${JSON.stringify(
-				streamingMethods.map((m) => m.name),
-				null,
-				2,
-			)}\n`
-		}
-
-		// Add registration function
-		methodsContent += `\n// Register all ${serviceName} service methods
-export function registerAllMethods(): void {
-\t// Register each method with the registry\n`
-
-		// Add registration statements
-		for (const file of implementationFiles) {
-			const baseName = path.basename(file, ".ts")
-			const isStreaming = streamingMethods.some((m) => m.name === baseName)
-
-			if (isStreaming) {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName}, { isStreaming: true })\n`
-			} else {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName})\n`
-			}
-		}
-
-		// Close the function
-		methodsContent += `}`
-
-		// Write the methods.ts file
-		const registryFile = path.join(serviceDir, "methods.ts")
-		await writeFileWithMkdirs(registryFile, methodsContent)
-		log_verbose(chalk.green(`Generated ${registryFile}`))
-
-		// Generate index.ts file
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1)
-		const indexContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
-import { registerAllMethods } from "./methods"
-
-// Create ${serviceName} service registry
-const ${serviceName}Service = createServiceRegistry("${serviceName}")
-
-// Export the method handler types and registration function
-export type ${capitalizedServiceName}MethodHandler = ServiceMethodHandler
-export type ${capitalizedServiceName}StreamingMethodHandler = StreamingMethodHandler
-export const registerMethod = ${serviceName}Service.registerMethod
-
-// Export the request handlers
-export const handle${capitalizedServiceName}ServiceRequest = ${serviceName}Service.handleRequest
-export const handle${capitalizedServiceName}ServiceStreamingRequest = ${serviceName}Service.handleStreamingRequest
-export const isStreamingMethod = ${serviceName}Service.isStreamingMethod
-
-// Register all ${serviceName} methods
-registerAllMethods()`
-
-		// Write the index.ts file
-		const indexFile = path.join(serviceDir, "index.ts")
-		await writeFileWithMkdirs(indexFile, indexContent)
-		log_verbose(chalk.green(`Generated ${indexFile}`))
-	}
-
-	log_verbose(chalk.green("Method registration files generated successfully."))
-}
-
-/**
- * Generate a service configuration file that maps service names to their handlers
- * This eliminates the need for manual switch/case statements in grpc-handler.ts
- */
-async function generateProtoBusServiceConfig() {
-	log_verbose(chalk.cyan("Generating service configuration file..."))
-
-	const serviceImports = []
-	const serviceConfigs = []
-
-	// Add all services from the serviceNameMap
-	for (const [dirName, fullServiceName] of Object.entries(serviceNameMap)) {
-		const capitalizedName = dirName.charAt(0).toUpperCase() + dirName.slice(1)
-		serviceImports.push(
-			`import { handle${capitalizedName}ServiceRequest, handle${capitalizedName}ServiceStreamingRequest } from "./${dirName}/index"`,
-		)
-		serviceConfigs.push(`
-  "${fullServiceName}": {
-    requestHandler: handle${capitalizedName}ServiceRequest,
-    streamingHandler: handle${capitalizedName}ServiceStreamingRequest
-  }`)
-	}
-
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by ${SCRIPT_NAME}
-
-import { Controller } from "./index"
-import { StreamingResponseHandler } from "./grpc-handler"
-${serviceImports.join("\n")}
-
-/**
- * Configuration for a service handler
- */
-export interface ServiceHandlerConfig {
-  requestHandler: (controller: Controller, method: string, message: any) => Promise<any>;
-  streamingHandler: (controller: Controller, method: string, message: any, responseStream: StreamingResponseHandler, requestId?: string) => Promise<void>;
-}
-
-/**
- * Map of service names to their handler configurations
- */
-export const serviceHandlers: Record<string, ServiceHandlerConfig> = {${serviceConfigs.join(",")}
-};`
-
-	const configPath = path.resolve("src/core/controller/grpc-service-config.ts")
-	await writeFileWithMkdirs(configPath, content)
-	log_verbose(chalk.green(`Generated service configuration at ${configPath}`))
-}
-
-/**
- * Ensure that a .proto file exists for each service in the serviceNameMap
- * If a .proto file doesn't exist, create a template file
- */
-async function ensureProtoFilesExist() {
-	log_verbose(chalk.cyan("Checking for missing proto files..."))
-
-	// Get existing proto files
-	const existingProtoFiles = await globby("*.proto", { cwd: PROTO_DIR })
-	const existingProtoServices = existingProtoFiles.map((file) => path.basename(file, ".proto"))
-
-	// Check each service in serviceNameMap
-	for (const [serviceName, fullServiceName] of Object.entries(serviceNameMap)) {
-		if (!existingProtoServices.includes(serviceName)) {
-			log_verbose(chalk.yellow(`Creating template proto file for ${serviceName}...`))
-
-			// Extract service class name from full name (e.g., "cline.ModelsService" -> "ModelsService")
-			const serviceClassName = fullServiceName.split(".").pop()
-
-			// Create template proto file
-			const protoContent = `syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// ${serviceClassName} provides methods for managing ${serviceName}
-service ${serviceClassName} {
-  // Add your RPC methods here
-  // Example (String is from common.proto, responses should be generic types):
-  // rpc YourMethod(YourRequest) returns (String);
-}
-
-// Add your message definitions here
-// Example (Requests must always start with Metadata):
-// message YourRequest {
-//   Metadata metadata = 1;
-//   string stringField = 2;
-//   int32 int32Field = 3;
-// }
-`
-
-			// Write the template proto file
-			const protoFilePath = path.join(PROTO_DIR, `${serviceName}.proto`)
-			await fs.writeFile(protoFilePath, protoContent)
-			log_verbose(chalk.green(`Created template proto file at ${protoFilePath}`))
-		}
-	}
-}
-
 async function cleanup() {
 	// Clean up existing generated files
 	log_verbose(chalk.cyan("Cleaning up existing generated TypeScript files..."))
-	const existingFiles = await globby("**/*.ts", { cwd: TS_OUT_DIR })
-	for (const file of existingFiles) {
-		await fs.unlink(path.join(TS_OUT_DIR, file))
-	}
-	await rmdir("src/generated")
+	await rmrf(TS_OUT_DIR)
+	await rmrf("src/generated")
 
 	// Clean up generated files that were moved.
-	await fs.rm("src/standalone/services/host-grpc-client.ts", { force: true })
-	await rmdir("src/standalone/services")
-	await fs.rm("hosts/vscode", { force: true, recursive: true })
-	await rmdir("hosts")
-
-	await fs.rm("src/standalone/server-setup.ts", { force: true })
-	await fs.rm("src/hosts/vscode/host-grpc-service-config.ts", { force: true })
+	await rmrf("src/standalone/services/host-grpc-client.ts")
+	await rmrf("src/standalone/server-setup.ts")
+	await rmrf("src/hosts/vscode/host-grpc-service-config.ts")
+	await rmrf("src/core/controller/grpc-service-config.ts")
 	const oldhostbridgefiles = [
 		"src/hosts/vscode/workspace/methods.ts",
 		"src/hosts/vscode/workspace/index.ts",
@@ -448,30 +121,32 @@ async function cleanup() {
 		"src/hosts/vscode/uri/methods.ts",
 		"src/hosts/vscode/uri/index.ts",
 	]
-	for (const file of oldhostbridgefiles) {
-		await fs.rm(file, { force: true })
-	}
-}
-
-/**
- * Write `contents` to `filePath`, creating any necessary directories in `filePath`.
- */
-async function writeFileWithMkdirs(filePath, content) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true })
-	await fs.writeFile(filePath, content)
-}
-
-/**
- * Remove an empty dir, do nothing if the directory doesn't exist or is not empty.
- */
-async function rmdir(path) {
-	try {
-		await fs.rmdir(path)
-	} catch (error) {
-		if (error.code !== "ENOTEMPTY" && error.code !== "ENOENT") {
-			// Only re-throw if it's not "not empty" or "doesn't exist"
-			throw error
-		}
+	const oldprotobusfiles = [
+		"src/core/controller/account/index.ts",
+		"src/core/controller/account/methods.ts",
+		"src/core/controller/browser/index.ts",
+		"src/core/controller/browser/methods.ts",
+		"src/core/controller/checkpoints/index.ts",
+		"src/core/controller/checkpoints/methods.ts",
+		"src/core/controller/file/index.ts",
+		"src/core/controller/file/methods.ts",
+		"src/core/controller/mcp/index.ts",
+		"src/core/controller/mcp/methods.ts",
+		"src/core/controller/models/index.ts",
+		"src/core/controller/models/methods.ts",
+		"src/core/controller/slash/index.ts",
+		"src/core/controller/slash/methods.ts",
+		"src/core/controller/state/index.ts",
+		"src/core/controller/state/methods.ts",
+		"src/core/controller/task/index.ts",
+		"src/core/controller/task/methods.ts",
+		"src/core/controller/ui/index.ts",
+		"src/core/controller/ui/methods.ts",
+		"src/core/controller/web/index.ts",
+		"src/core/controller/web/methods.ts",
+	]
+	for (const file of [...oldhostbridgefiles, ...oldprotobusfiles]) {
+		await rmrf(file)
 	}
 }
 

scripts/file-utils.mjs

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

scripts/generate-host-bridge-client.mjs

@@ -1,12 +1,9 @@
 #!/usr/bin/env node
 
-import * as fs from "fs/promises"
+import { writeFileWithMkdirs } from "./file-utils.mjs"
 import * as path from "path"
-import * as grpc from "@grpc/grpc-js"
-import * as protoLoader from "@grpc/proto-loader"
 import chalk from "chalk"
-
-const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
+import { loadServicesFromProtoDescriptor, getFqn } from "./proto-utils.mjs"
 
 // Contains the interface definitions for the host bridge clients.
 const TYPES_FILE = path.resolve("src/generated/hosts/host-bridge-client-types.ts")
@@ -15,49 +12,17 @@ const EXTERNAL_CLIENT_FILE = path.resolve("src/generated/hosts/standalone/host-b
 // Contains the handler map for the external host bridge clients (using the custom service registry).
 const VSCODE_CLIENT_FILE = path.resolve("src/generated/hosts/vscode/hostbridge-grpc-service-config.ts")
 
-const typeNameToFQN = new Map()
-
-function addTypeNameToFqn(name, fqn) {
-	if (typeNameToFQN.has(name)) {
-		throw new Error(`Proto type ${name} redefined (${fqn}).`)
-	}
-	typeNameToFQN.set(name, fqn)
-}
-function getFqn(name) {
-	if (!typeNameToFQN.has(name)) {
-		throw Error(`No FQN for ${name}`)
-	}
-	return typeNameToFQN.get(name)
-}
 /**
  * Main function to generate the host bridge client
  */
 async function main() {
-	// Load service definitions from descriptor set
-	const descriptorBuffer = await fs.readFile(DESCRIPTOR_SET)
-	const packageDefinition = protoLoader.loadFileDescriptorSetFromBuffer(descriptorBuffer)
-	const proto = grpc.loadPackageDefinition(packageDefinition)
-
-	// Extract host services and proto messages from the proto definition
-	const hostServices = {}
-	for (const [name, def] of Object.entries(proto.host)) {
-		if (def && "service" in def) {
-			hostServices[name] = def
-		} else {
-			addTypeNameToFqn(name, `proto.host.${name}`)
-		}
-	}
-	for (const [name, def] of Object.entries(proto.cline)) {
-		if (def && !("service" in def)) {
-			addTypeNameToFqn(name, `proto.cline.${name}`)
-		}
-	}
+	const { hostServices } = await loadServicesFromProtoDescriptor()
 
 	await generateTypesFile(hostServices)
 	await generateExternalClientFile(hostServices)
 	await generateVscodeClientFile(hostServices)
 
-	console.log(`Generated host bridge client files at:`)
+	console.log(`Generated Host Bridge client files at:`)
 	console.log(`- ${TYPES_FILE}`)
 	console.log(`- ${EXTERNAL_CLIENT_FILE}`)
 	console.log(`- ${VSCODE_CLIENT_FILE}`)
@@ -80,8 +45,7 @@ import { StreamingCallbacks } from "@hosts/host-provider-types"
 ${clientInterfaces.join("\n\n")}
 `
 	// Write output file
-	await fs.mkdir(path.dirname(TYPES_FILE), { recursive: true })
-	await fs.writeFile(TYPES_FILE, content)
+	await writeFileWithMkdirs(TYPES_FILE, content)
 }
 
 /**
@@ -135,14 +99,14 @@ import * as niceGrpc from "@generated/nice-grpc/index"
 import { StreamingCallbacks } from "@hosts/host-provider-types"
 import * as proto from "@shared/proto/index"
 import { Channel, createClient } from "nice-grpc"
+import { BaseGrpcClient } from "@/hosts/external/grpc-types"
 
 ${imports.join("\n")}
 
 ${clientImplementations.join("\n\n")}
 `
 	// Write output file
-	await fs.mkdir(path.dirname(EXTERNAL_CLIENT_FILE), { recursive: true })
-	await fs.writeFile(EXTERNAL_CLIENT_FILE, content)
+	await writeFileWithMkdirs(EXTERNAL_CLIENT_FILE, content)
 }
 
 /**
@@ -158,31 +122,49 @@ function generateExternalClientSetup(serviceName, serviceDefinition) {
 			const isStreamingResponse = methodDef.responseStream
 
 			if (!isStreamingResponse) {
-				return `  ${methodName}(request: ${requestType}): Promise<${responseType}> {
-    return this.client.${methodName}(request)
-  }`
+				return `    ${methodName}(request: ${requestType}): Promise<${responseType}> {
+      return this.makeRequest((client) => client.${methodName}(request))
+    }`
 			} else {
 				// Generate streaming method
-				return `  ${methodName}(request: ${requestType}, callbacks: StreamingCallbacks<${responseType}>): () => void {
-	const abortController = new AbortController()
-	const stream: AsyncIterable<${responseType}> = this.client.${methodName}(request, {signal: abortController.signal})
-    asyncIteratorToCallbacks(stream, callbacks)
-	return () => {abortController.abort()}
-  }`
+				return `  ${methodName}(
+		request: ${requestType},
+		callbacks: StreamingCallbacks<${responseType}>,
+	): () => void {
+		const client = this.getClient()
+		const abortController = new AbortController()
+		const stream: AsyncIterable<${responseType}> = client.${methodName}(request, {
+			signal: abortController.signal,
+		})
+		const wrappedCallbacks: StreamingCallbacks<${responseType}> = {
+			...callbacks,
+			onError: (error: any) => {
+				if (error?.code === "UNAVAILABLE") {
+					this.destroyClient()
+				}
+				callbacks.onError?.(error)
+			},
+		}
+		asyncIteratorToCallbacks(stream, wrappedCallbacks)
+		return () => {
+			abortController.abort()
+		}
+	}\n`
 			}
 		})
-		.join("\n\n")
+		.join("\n")
 
 	// Generate the class
 	return `/**
  * Type-safe client implementation for ${serviceName}.
  */
-export class ${serviceName}ClientImpl implements ${serviceName}ClientInterface {
-  private client: niceGrpc.host.${serviceName}Client 
+export class ${serviceName}ClientImpl 
+	extends BaseGrpcClient<niceGrpc.host.${serviceName}Client> 
+	implements ${serviceName}ClientInterface {
 
-  constructor(channel: Channel) {
-    this.client = createClient(niceGrpc.host.${serviceName}Definition, channel)
-  }
+	protected createClient(channel: Channel): niceGrpc.host.${serviceName}Client {
+		return createClient(niceGrpc.host.${serviceName}Definition, channel)
+	}
 
 ${methods}
 }`
@@ -227,8 +209,7 @@ ${handlerMap.join("\n")}
 `
 
 	// Write output file
-	await fs.mkdir(path.dirname(VSCODE_CLIENT_FILE), { recursive: true })
-	await fs.writeFile(VSCODE_CLIENT_FILE, content)
+	await writeFileWithMkdirs(VSCODE_CLIENT_FILE, content)
 }
 
 function generateVscodeClientImplementation(serviceName, serviceDefinition) {

scripts/generate-protobus-setup.mjs

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

scripts/generate-server-setup.mjs

@@ -1,81 +0,0 @@
-import * as grpc from "@grpc/grpc-js"
-import * as protoLoader from "@grpc/proto-loader"
-import * as fs from "fs"
-import * as health from "grpc-health-check"
-import path, { basename, dirname } from "path"
-import { fileURLToPath } from "url"
-
-const OUT_FILE = path.resolve("src/generated/standalone/server-setup.ts")
-const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
-
-// Load service definitions.
-const clineDef = protoLoader.loadFileDescriptorSetFromBuffer(fs.readFileSync(DESCRIPTOR_SET))
-const healthDef = protoLoader.loadSync(health.protoPath)
-const packageDefinition = { ...clineDef, ...healthDef }
-const proto = grpc.loadPackageDefinition(packageDefinition)
-
-/**
- * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
- */
-function generateHandlersAndExports() {
-	let imports = []
-	let handlerSetup = []
-
-	for (const [name, def] of Object.entries(proto.cline)) {
-		if (!def || !("service" in def)) {
-			continue
-		}
-		const domain = name.replace(/Service$/, "")
-		const dir = domain.charAt(0).toLowerCase() + domain.slice(1)
-		imports.push(`// ${domain} Service`)
-		handlerSetup.push(`    // ${domain} Service`)
-		handlerSetup.push(`    server.addService(cline.${name}Service, {`)
-		for (const [rpcName, rpc] of Object.entries(def.service)) {
-			imports.push(`import { ${rpcName} } from "@core/controller/${dir}/${rpcName}"`)
-			const requestType = "cline." + rpc.requestType.type.name
-			if (rpc.requestStream) {
-				throw new Error("Request streaming is not supported")
-			}
-			if (rpc.responseStream) {
-				handlerSetup.push(`        ${rpcName}: wrapStreamingResponse<${requestType},void>(${rpcName}, controller),`)
-			} else {
-				const responseType = "cline." + rpc.responseType.type.name
-				handlerSetup.push(`         ${rpcName}: wrapper<${requestType},${responseType}>(${rpcName}, controller),`)
-			}
-		}
-		handlerSetup.push(`    });`)
-		imports.push("")
-		handlerSetup.push("")
-	}
-	return {
-		imports: imports.join("\n"),
-		handlerSetup: handlerSetup.join("\n"),
-	}
-}
-
-const { imports, handlerSetup } = generateHandlersAndExports()
-const scriptName = path.basename(fileURLToPath(import.meta.url))
-
-// Create output file
-let output = `// GENERATED CODE -- DO NOT EDIT!
-// Generated by ${scriptName}
-import * as grpc from "@grpc/grpc-js"
-import { cline } from "@generated/grpc-js"
-import { Controller } from "@core/controller"
-import { GrpcHandlerWrapper, GrpcStreamingResponseHandlerWrapper } from "@/standalone/grpc-types"
-
-${imports}
-export function addProtobusServices(
-	server: grpc.Server,
-	controller: Controller,
-	wrapper: GrpcHandlerWrapper,
-	wrapStreamingResponse: GrpcStreamingResponseHandlerWrapper,
-): void {
-${handlerSetup}
-}
-`
-// Write output file
-fs.mkdirSync(dirname(OUT_FILE), { recursive: true })
-fs.writeFileSync(OUT_FILE, output)
-
-console.log(`Generated service handlers in ${OUT_FILE}.`)

scripts/proto-utils.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import * as fs from "fs/promises"
+import * as path from "path"
+import * as grpc from "@grpc/grpc-js"
+import * as protoLoader from "@grpc/proto-loader"
+
+const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
+
+const typeNameToFQN = new Map()
+
+function addTypeNameToFqn(name, fqn) {
+	if (typeNameToFQN.has(name)) {
+		throw new Error(`Proto type ${name} redefined (${fqn}).`)
+	}
+	typeNameToFQN.set(name, fqn)
+}
+// Get the fully qualified name for a proto type, e.g. getFqn('StringRequest') returns 'cline.StringRequest'
+export function getFqn(name) {
+	if (!typeNameToFQN.has(name)) {
+		throw Error(`No FQN for ${name}`)
+	}
+	return typeNameToFQN.get(name)
+}
+
+export async function loadServicesFromProtoDescriptor() {
+	// Load service definitions from descriptor set
+	const descriptorBuffer = await fs.readFile(DESCRIPTOR_SET)
+	const packageDefinition = protoLoader.loadFileDescriptorSetFromBuffer(descriptorBuffer)
+	const proto = grpc.loadPackageDefinition(packageDefinition)
+
+	// Extract host services and proto messages from the proto definition
+	const hostServices = {}
+	for (const [name, def] of Object.entries(proto.host)) {
+		if (def && "service" in def) {
+			hostServices[name] = def
+		} else {
+			addTypeNameToFqn(name, `proto.host.${name}`)
+		}
+	}
+	const protobusServices = {}
+	for (const [name, def] of Object.entries(proto.cline)) {
+		if (def && "service" in def) {
+			protobusServices[name] = def
+		} else {
+			addTypeNameToFqn(name, `proto.cline.${name}`)
+		}
+	}
+	return { protobusServices, hostServices }
+}

scripts/runclinecore.sh

@@ -1,21 +1,21 @@
 #!/usr/bin/env bash
 set -eu #x
-# This compiles the cline-core app, installs it to the user's home directory,
-# and runs the service.
+# This installs the cline-core app to the user's home directory,
+# and starts the service.
 
 CORE_DIR=~/.cline/core
 INSTALL_DIR=$CORE_DIR/0.0.1
 
-# Build cline core
-npm run compile-standalone
+ZIP_FILE=standalone.zip
+ZIP=dist-standalone/${ZIP_FILE}
 
 # Remove old unpacked versions to force reinstall
 rm -rf $CORE_DIR/* || true
 
 mkdir -p $INSTALL_DIR
-cp dist-standalone/standalone.zip $INSTALL_DIR
+cp $ZIP $INSTALL_DIR
 cd $INSTALL_DIR
-unp standalone.zip > /dev/null
+unp $ZIP_FILE > /dev/null
 
 pkill -f cline-core.js || true
-NODE_PATH=./node_modules node cline-core.js
+NODE_PATH=./node_modules DEV_WORKSPACE_FOLDER=/tmp/ node cline-core.js

src/api/index.ts

@@ -29,6 +29,8 @@ import { SapAiCoreHandler } from "./providers/sapaicore"
 import { ClaudeCodeHandler } from "./providers/claude-code"
 import { MoonshotHandler } from "./providers/moonshot"
 import { GroqHandler } from "./providers/groq"
+import { Mode } from "../shared/ChatSettings"
+import { HuggingFaceHandler } from "./providers/huggingface"
 
 export interface ApiHandler {
 	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
@@ -40,27 +42,33 @@ export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
 }
 
-function createHandlerForProvider(apiProvider: string | undefined, options: Omit<ApiConfiguration, "apiProvider">): ApiHandler {
+function createHandlerForProvider(
+	apiProvider: string | undefined,
+	options: Omit<ApiConfiguration, "apiProvider">,
+	mode: Mode,
+): ApiHandler {
 	switch (apiProvider) {
 		case "anthropic":
 			return new AnthropicHandler({
 				apiKey: options.apiKey,
 				anthropicBaseUrl: options.anthropicBaseUrl,
-				apiModelId: options.apiModelId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "openrouter":
 			return new OpenRouterHandler({
 				openRouterApiKey: options.openRouterApiKey,
-				openRouterModelId: options.openRouterModelId,
-				openRouterModelInfo: options.openRouterModelInfo,
+				openRouterModelId: mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId,
+				openRouterModelInfo: mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo,
 				openRouterProviderSorting: options.openRouterProviderSorting,
-				reasoningEffort: options.reasoningEffort,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "bedrock":
 			return new AwsBedrockHandler({
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 				awsAccessKey: options.awsAccessKey,
 				awsSecretKey: options.awsSecretKey,
 				awsSessionToken: options.awsSessionToken,
@@ -72,16 +80,20 @@ function createHandlerForProvider(apiProvider: string | undefined, options: Omit
 				awsUseProfile: options.awsUseProfile,
 				awsProfile: options.awsProfile,
 				awsBedrockEndpoint: options.awsBedrockEndpoint,
-				awsBedrockCustomSelected: options.awsBedrockCustomSelected,
-				awsBedrockCustomModelBaseId: options.awsBedrockCustomModelBaseId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				awsBedrockCustomSelected:
+					mode === "plan" ? options.planModeAwsBedrockCustomSelected : options.actModeAwsBedrockCustomSelected,
+				awsBedrockCustomModelBaseId:
+					mode === "plan" ? options.planModeAwsBedrockCustomModelBaseId : options.actModeAwsBedrockCustomModelBaseId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "vertex":
 			return new VertexHandler({
 				vertexProjectId: options.vertexProjectId,
 				vertexRegion: options.vertexRegion,
-				apiModelId: options.apiModelId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 				geminiApiKey: options.geminiApiKey,
 				geminiBaseUrl: options.geminiBaseUrl,
 				taskId: options.taskId,
@@ -92,21 +104,21 @@ function createHandlerForProvider(apiProvider: string | undefined, options: Omit
 				openAiBaseUrl: options.openAiBaseUrl,
 				azureApiVersion: options.azureApiVersion,
 				openAiHeaders: options.openAiHeaders,
-				openAiModelId: options.openAiModelId,
-				openAiModelInfo: options.openAiModelInfo,
-				reasoningEffort: options.reasoningEffort,
+				openAiModelId: mode === "plan" ? options.planModeOpenAiModelId : options.actModeOpenAiModelId,
+				openAiModelInfo: mode === "plan" ? options.planModeOpenAiModelInfo : options.actModeOpenAiModelInfo,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
 			})
 		case "ollama":
 			return new OllamaHandler({
 				ollamaBaseUrl: options.ollamaBaseUrl,
-				ollamaModelId: options.ollamaModelId,
+				ollamaModelId: mode === "plan" ? options.planModeOllamaModelId : options.actModeOllamaModelId,
 				ollamaApiOptionsCtxNum: options.ollamaApiOptionsCtxNum,
 				requestTimeoutMs: options.requestTimeoutMs,
 			})
 		case "lmstudio":
 			return new LmStudioHandler({
 				lmStudioBaseUrl: options.lmStudioBaseUrl,
-				lmStudioModelId: options.lmStudioModelId,
+				lmStudioModelId: mode === "plan" ? options.planModeLmStudioModelId : options.actModeLmStudioModelId,
 			})
 		case "gemini":
 			return new GeminiHandler({
@@ -114,78 +126,85 @@ function createHandlerForProvider(apiProvider: string | undefined, options: Omit
 				vertexRegion: options.vertexRegion,
 				geminiApiKey: options.geminiApiKey,
 				geminiBaseUrl: options.geminiBaseUrl,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
-				apiModelId: options.apiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 				taskId: options.taskId,
 			})
 		case "openai-native":
 			return new OpenAiNativeHandler({
 				openAiNativeApiKey: options.openAiNativeApiKey,
-				reasoningEffort: options.reasoningEffort,
-				apiModelId: options.apiModelId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "deepseek":
 			return new DeepSeekHandler({
 				deepSeekApiKey: options.deepSeekApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "requesty":
 			return new RequestyHandler({
 				requestyApiKey: options.requestyApiKey,
-				reasoningEffort: options.reasoningEffort,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
-				requestyModelId: options.requestyModelId,
-				requestyModelInfo: options.requestyModelInfo,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				requestyModelId: mode === "plan" ? options.planModeRequestyModelId : options.actModeRequestyModelId,
+				requestyModelInfo: mode === "plan" ? options.planModeRequestyModelInfo : options.actModeRequestyModelInfo,
 			})
 		case "fireworks":
 			return new FireworksHandler({
 				fireworksApiKey: options.fireworksApiKey,
-				fireworksModelId: options.fireworksModelId,
+				fireworksModelId: mode === "plan" ? options.planModeFireworksModelId : options.actModeFireworksModelId,
 				fireworksModelMaxCompletionTokens: options.fireworksModelMaxCompletionTokens,
 				fireworksModelMaxTokens: options.fireworksModelMaxTokens,
 			})
 		case "together":
 			return new TogetherHandler({
 				togetherApiKey: options.togetherApiKey,
-				togetherModelId: options.togetherModelId,
+				togetherModelId: mode === "plan" ? options.planModeTogetherModelId : options.actModeTogetherModelId,
 			})
 		case "qwen":
 			return new QwenHandler({
 				qwenApiKey: options.qwenApiKey,
 				qwenApiLine: options.qwenApiLine,
-				apiModelId: options.apiModelId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "doubao":
 			return new DoubaoHandler({
 				doubaoApiKey: options.doubaoApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "mistral":
 			return new MistralHandler({
 				mistralApiKey: options.mistralApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "vscode-lm":
 			return new VsCodeLmHandler({
-				vsCodeLmModelSelector: options.vsCodeLmModelSelector,
+				vsCodeLmModelSelector:
+					mode === "plan" ? options.planModeVsCodeLmModelSelector : options.actModeVsCodeLmModelSelector,
 			})
 		case "cline":
 			return new ClineHandler({
+				clineAccountId: options.clineAccountId,
 				taskId: options.taskId,
-				reasoningEffort: options.reasoningEffort,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 				openRouterProviderSorting: options.openRouterProviderSorting,
-				openRouterModelId: options.openRouterModelId,
-				openRouterModelInfo: options.openRouterModelInfo,
+				openRouterModelId: mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId,
+				openRouterModelInfo: mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo,
 			})
 		case "litellm":
 			return new LiteLlmHandler({
 				liteLlmApiKey: options.liteLlmApiKey,
 				liteLlmBaseUrl: options.liteLlmBaseUrl,
-				liteLlmModelId: options.liteLlmModelId,
-				liteLlmModelInfo: options.liteLlmModelInfo,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				liteLlmModelId: mode === "plan" ? options.planModeLiteLlmModelId : options.actModeLiteLlmModelId,
+				liteLlmModelInfo: mode === "plan" ? options.planModeLiteLlmModelInfo : options.actModeLiteLlmModelInfo,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 				liteLlmUsePromptCache: options.liteLlmUsePromptCache,
 				taskId: options.taskId,
 			})
@@ -193,41 +212,48 @@ function createHandlerForProvider(apiProvider: string | undefined, options: Omit
 			return new MoonshotHandler({
 				moonshotApiKey: options.moonshotApiKey,
 				moonshotApiLine: options.moonshotApiLine,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "huggingface":
+			return new HuggingFaceHandler({
+				huggingFaceApiKey: options.huggingFaceApiKey,
+				huggingFaceModelId: mode === "plan" ? options.planModeHuggingFaceModelId : options.actModeHuggingFaceModelId,
+				huggingFaceModelInfo:
+					mode === "plan" ? options.planModeHuggingFaceModelInfo : options.actModeHuggingFaceModelInfo,
 			})
 		case "nebius":
 			return new NebiusHandler({
 				nebiusApiKey: options.nebiusApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "asksage":
 			return new AskSageHandler({
 				asksageApiKey: options.asksageApiKey,
 				asksageApiUrl: options.asksageApiUrl,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "xai":
 			return new XAIHandler({
 				xaiApiKey: options.xaiApiKey,
-				reasoningEffort: options.reasoningEffort,
-				apiModelId: options.apiModelId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "sambanova":
 			return new SambanovaHandler({
 				sambanovaApiKey: options.sambanovaApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "cerebras":
 			return new CerebrasHandler({
 				cerebrasApiKey: options.cerebrasApiKey,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "groq":
 			return new GroqHandler({
 				groqApiKey: options.groqApiKey,
-				groqModelId: options.groqModelId,
-				groqModelInfo: options.groqModelInfo,
-				apiModelId: options.apiModelId,
+				groqModelId: mode === "plan" ? options.planModeGroqModelId : options.actModeGroqModelId,
+				groqModelInfo: mode === "plan" ? options.planModeGroqModelInfo : options.actModeGroqModelInfo,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "sapaicore":
 			return new SapAiCoreHandler({
@@ -236,37 +262,46 @@ function createHandlerForProvider(apiProvider: string | undefined, options: Omit
 				sapAiCoreTokenUrl: options.sapAiCoreTokenUrl,
 				sapAiResourceGroup: options.sapAiResourceGroup,
 				sapAiCoreBaseUrl: options.sapAiCoreBaseUrl,
-				apiModelId: options.apiModelId,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
 			})
 		case "claude-code":
 			return new ClaudeCodeHandler({
 				claudeCodePath: options.claudeCodePath,
-				apiModelId: options.apiModelId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		default:
 			return new AnthropicHandler({
 				apiKey: options.apiKey,
 				anthropicBaseUrl: options.anthropicBaseUrl,
-				apiModelId: options.apiModelId,
-				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 	}
 }
 
-export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
-	const { apiProvider, ...options } = configuration
+export function buildApiHandler(configuration: ApiConfiguration, mode: Mode): ApiHandler {
+	const { planModeApiProvider, actModeApiProvider, ...options } = configuration
+
+	const apiProvider = mode === "plan" ? planModeApiProvider : actModeApiProvider
 
 	// Validate thinking budget tokens against model's maxTokens to prevent API errors
 	// wrapped in a try-catch for safety, but this should never throw
 	try {
-		if (options.thinkingBudgetTokens && options.thinkingBudgetTokens > 0) {
-			const handler = createHandlerForProvider(apiProvider, options)
+		const thinkingBudgetTokens = mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens
+		if (thinkingBudgetTokens && thinkingBudgetTokens > 0) {
+			const handler = createHandlerForProvider(apiProvider, options, mode)
 
 			const modelInfo = handler.getModel().info
-			if (modelInfo.maxTokens && options.thinkingBudgetTokens > modelInfo.maxTokens) {
+			if (modelInfo.maxTokens && thinkingBudgetTokens > modelInfo.maxTokens) {
 				const clippedValue = modelInfo.maxTokens - 1
-				options.thinkingBudgetTokens = clippedValue
+				if (mode === "plan") {
+					options.planModeThinkingBudgetTokens = clippedValue
+				} else {
+					options.actModeThinkingBudgetTokens = clippedValue
+				}
 			} else {
 				return handler // don't rebuild unless its necessary
 			}
@@ -275,5 +310,5 @@ export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
 		console.error("buildApiHandler error:", error)
 	}
 
-	return createHandlerForProvider(apiProvider, options)
+	return createHandlerForProvider(apiProvider, options, mode)
 }

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

@@ -203,7 +203,7 @@ describe("AwsBedrockHandler", () => {
 	})
 
 	const mockOptions: ApiHandlerOptions = {
-		apiModelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
+		actModeApiModelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
 		awsRegion: "us-east-1",
 		awsAccessKey: "test-key",
 		awsSecretKey: "test-secret",
@@ -214,9 +214,9 @@ describe("AwsBedrockHandler", () => {
 		awsBedrockUsePromptCache: false,
 		awsUseCrossRegionInference: false,
 		awsBedrockEndpoint: "",
-		awsBedrockCustomSelected: false,
-		awsBedrockCustomModelBaseId: undefined,
-		thinkingBudgetTokens: 1600,
+		actModeAwsBedrockCustomSelected: false,
+		actModeAwsBedrockCustomModelBaseId: undefined,
+		actModeThinkingBudgetTokens: 1600,
 	}
 
 	const mockModelInfo = {
@@ -616,8 +616,8 @@ describe("AwsBedrockHandler", () => {
 		it("should return raw model ID for custom models", async () => {
 			const customOptions: ApiHandlerOptions = {
 				...mockOptions,
-				awsBedrockCustomSelected: true,
-				apiModelId:
+				actModeAwsBedrockCustomSelected: true,
+				actModeApiModelId:
 					"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
 			}
 			const customHandler = new AwsBedrockHandler(customOptions)
@@ -631,8 +631,8 @@ describe("AwsBedrockHandler", () => {
 		it("should not encode custom model IDs with slashes", async () => {
 			const customOptions: ApiHandlerOptions = {
 				...mockOptions,
-				awsBedrockCustomSelected: true,
-				apiModelId: "my-namespace/my-custom-model",
+				actModeAwsBedrockCustomSelected: true,
+				actModeApiModelId: "my-namespace/my-custom-model",
 			}
 			const customHandler = new AwsBedrockHandler(customOptions)
 
@@ -680,8 +680,8 @@ describe("AwsBedrockHandler", () => {
 		it("should not apply cross-region prefix for custom models even when enabled", async () => {
 			const customCrossRegionOptions: ApiHandlerOptions = {
 				...mockOptions,
-				awsBedrockCustomSelected: true,
-				apiModelId: "arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model",
+				actModeAwsBedrockCustomSelected: true,
+				actModeApiModelId: "arn:aws:bedrock:us-west-2:123456789012:custom-model/my-model",
 				awsUseCrossRegionInference: true,
 			}
 			const customCrossRegionHandler = new AwsBedrockHandler(customCrossRegionOptions)
@@ -693,10 +693,10 @@ describe("AwsBedrockHandler", () => {
 		it("should handle UltraThink model ARN correctly", async () => {
 			const ultraThinkOptions: ApiHandlerOptions = {
 				...mockOptions,
-				awsBedrockCustomSelected: true,
-				apiModelId:
+				actModeAwsBedrockCustomSelected: true,
+				actModeApiModelId:
 					"arn:aws:bedrock:us-west-2:123456789012:custom-model/anthropic.claude-3-5-sonnet-20241022-v2:0/Qk8MMyLmRd",
-				awsBedrockCustomModelBaseId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
+				actModeAwsBedrockCustomModelBaseId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
 			}
 			const ultraThinkHandler = new AwsBedrockHandler(ultraThinkOptions)
 

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

@@ -26,7 +26,7 @@ describe("OllamaHandler", () => {
 
 	beforeEach(() => {
 		options = {
-			ollamaModelId: "llama2",
+			actModeOllamaModelId: "llama2",
 			ollamaBaseUrl: "http://localhost:11434",
 		}
 		handler = new OllamaHandler(options)

src/api/providers/anthropic.ts

@@ -13,7 +13,7 @@ interface AnthropicHandlerOptions {
 }
 
 export class AnthropicHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private options: AnthropicHandlerOptions
 	private client: Anthropic | undefined
 
 	constructor(options: AnthropicHandlerOptions) {

src/api/providers/cerebras.ts

@@ -56,7 +56,7 @@ export class CerebrasHandler implements ApiHandler {
 
 		// 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")
+		const isReasoningModel = modelId.includes("qwen")
 
 		// Convert Anthropic messages to Cerebras format
 		for (const message of messages) {

src/api/providers/cline.ts

@@ -177,17 +177,7 @@ export class ClineHandler implements ApiHandler {
 			}
 		} catch (error) {
 			console.error("Cline API Error:", error)
-			const requestId = error?.request_id ? `\n | Request ID: ${error.request_id}` : ""
-			if (error.code === "ERR_BAD_REQUEST" || error.status === 401) {
-				throw new Error(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE + requestId)
-			} else if (error.code === "insufficient_credits" || error.status === 402) {
-				if (error.error) {
-					throw new Error(JSON.stringify(error.error))
-				}
-			}
-			const _error = error instanceof Error ? error : new Error(String(error))
-			_error.message = _error.message + requestId
-			throw _error
+			throw error
 		}
 	}
 

src/api/providers/gemini.ts

@@ -44,7 +44,7 @@ interface GeminiHandlerOptions {
  * 4. Separating immediate costs from ongoing costs to avoid double-counting
  */
 export class GeminiHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private options: GeminiHandlerOptions
 	private client: GoogleGenAI | undefined
 
 	constructor(options: GeminiHandlerOptions) {

src/api/providers/huggingface.ts

@@ -0,0 +1,142 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { withRetry } from "../retry"
+import { ApiHandler } from "../"
+import { ApiHandlerOptions, HuggingFaceModelId, ModelInfo, huggingFaceDefaultModelId, huggingFaceModels } from "@shared/api"
+import { calculateApiCostOpenAI } from "../../utils/cost"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+
+interface HuggingFaceHandlerOptions {
+	huggingFaceApiKey?: string
+	huggingFaceModelId?: string
+	huggingFaceModelInfo?: ModelInfo
+}
+
+export class HuggingFaceHandler implements ApiHandler {
+	private options: HuggingFaceHandlerOptions
+	private client: OpenAI | undefined
+	private cachedModel: { id: HuggingFaceModelId; info: ModelInfo } | undefined
+
+	constructor(options: HuggingFaceHandlerOptions) {
+		this.options = options
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.huggingFaceApiKey) {
+				throw new Error("Hugging Face API key is required")
+			}
+
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://router.huggingface.co/v1",
+					apiKey: this.options.huggingFaceApiKey,
+					defaultHeaders: {
+						"User-Agent": "Cline/1.0",
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Hugging Face client: ${error.message}`)
+			}
+		}
+		return this.client
+	}
+
+	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
+		if (!usage) {
+			return
+		}
+
+		const inputTokens = usage.prompt_tokens || 0
+		const outputTokens = usage.completion_tokens || 0
+		const totalCost = calculateApiCostOpenAI(info, inputTokens, outputTokens)
+
+		const usageData = {
+			type: "usage" as const,
+			inputTokens: inputTokens,
+			outputTokens: outputTokens,
+			cacheWriteTokens: 0,
+			cacheReadTokens: 0,
+			totalCost: totalCost,
+		}
+
+		yield usageData
+	}
+
+	@withRetry()
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		try {
+			const client = this.ensureClient()
+			const model = this.getModel()
+
+			const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+				{ role: "system", content: systemPrompt },
+				...convertToOpenAiMessages(messages),
+			]
+
+			const requestParams = {
+				model: model.id,
+				max_tokens: model.info.maxTokens,
+				messages: openAiMessages,
+				stream: true,
+				stream_options: { include_usage: true },
+				temperature: 0,
+			}
+
+			const stream = (await client.chat.completions.create(requestParams)) as any
+
+			let chunkCount = 0
+			let totalContent = ""
+
+			for await (const chunk of stream) {
+				chunkCount++
+				const delta = chunk.choices[0]?.delta
+				if (delta?.content) {
+					totalContent += delta.content
+
+					yield {
+						type: "text",
+						text: delta.content,
+					}
+				}
+
+				if (chunk.usage) {
+					yield* this.yieldUsage(model.info, chunk.usage)
+				}
+			}
+		} catch (error: any) {
+			throw error
+		}
+	}
+
+	getModel(): { id: HuggingFaceModelId; info: ModelInfo } {
+		// Return cached model if available
+		if (this.cachedModel) {
+			return this.cachedModel
+		}
+
+		const modelId = this.options.huggingFaceModelId
+
+		// List all available models for debugging
+		const availableModels = Object.keys(huggingFaceModels)
+		let result: { id: HuggingFaceModelId; info: ModelInfo }
+
+		if (modelId && modelId in huggingFaceModels) {
+			const id = modelId as HuggingFaceModelId
+			const modelInfo = huggingFaceModels[id]
+			result = { id, info: modelInfo }
+		} else {
+			const defaultInfo = huggingFaceModels[huggingFaceDefaultModelId]
+			result = {
+				id: huggingFaceDefaultModelId,
+				info: defaultInfo,
+			}
+		}
+
+		// Cache the result for future calls
+		this.cachedModel = result
+
+		return result
+	}
+}

src/api/providers/openrouter.ts

@@ -19,6 +19,15 @@ interface OpenRouterHandlerOptions {
 	thinkingBudgetTokens?: number
 }
 
+interface OpenRouterHandlerOptions {
+	openRouterApiKey?: string
+	openRouterModelId?: string
+	openRouterModelInfo?: ModelInfo
+	openRouterProviderSorting?: string
+	reasoningEffort?: string
+	thinkingBudgetTokens?: number
+}
+
 export class OpenRouterHandler implements ApiHandler {
 	private options: OpenRouterHandlerOptions
 	private client: OpenAI | undefined

src/api/providers/xai.ts

@@ -14,6 +14,12 @@ interface XAIHandlerOptions {
 	apiModelId?: string
 }
 
+interface XAIHandlerOptions {
+	xaiApiKey?: string
+	reasoningEffort?: string
+	apiModelId?: string
+}
+
 export class XAIHandler implements ApiHandler {
 	private options: XAIHandlerOptions
 	private client: OpenAI | undefined

src/config.ts

@@ -1,6 +1,8 @@
-export type Environment = "production" | "staging" | "local"
-
-const CURRENT_ENVIRONMENT: Environment = "production"
+export enum Environment {
+	production = "production",
+	staging = "staging",
+	local = "local",
+}
 
 interface EnvironmentConfig {
 	appBaseUrl: string
@@ -16,43 +18,63 @@ interface EnvironmentConfig {
 	}
 }
 
-const configs: Record<Environment, EnvironmentConfig> = {
-	production: {
-		appBaseUrl: "https://app.cline.bot",
-		apiBaseUrl: "https://api.cline.bot",
-		mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-		firebase: {
-			apiKey: "AIzaSyC5rx59Xt8UgwdU3PCfzUF7vCwmp9-K2vk",
-			authDomain: "cline-prod.firebaseapp.com",
-			projectId: "cline-prod",
-			storageBucket: "cline-prod.firebasestorage.app",
-			messagingSenderId: "941048379330",
-			appId: "1:941048379330:web:45058eedeefc5cdfcc485b",
-		},
-	},
-	staging: {
-		appBaseUrl: "https://staging-app.cline.bot",
-		apiBaseUrl: "https://core-api.staging.int.cline.bot",
-		mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-		firebase: {
-			apiKey: "AIzaSyASSwkwX1kSO8vddjZkE5N19QU9cVQ0CIk",
-			authDomain: "cline-staging.firebaseapp.com",
-			projectId: "cline-staging",
-			storageBucket: "cline-staging.firebasestorage.app",
-			messagingSenderId: "853479478430",
-			appId: "1:853479478430:web:2de0dba1c63c3262d4578f",
-		},
-	},
-	local: {
-		appBaseUrl: "http://localhost:3000",
-		apiBaseUrl: "http://localhost:7777",
-		mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-		firebase: {
-			apiKey: "AIzaSyD8wtkd1I-EICuAg6xgAQpRdwYTvwxZG2w",
-			authDomain: "cline-preview.firebaseapp.com",
-			projectId: "cline-preview",
-		},
-	},
+function getClineEnv(): Environment {
+	const _env = process?.env?.CLINE_ENVIRONMENT
+	if (_env && Object.values(Environment).includes(_env as Environment)) {
+		return _env as Environment
+	}
+	return Environment.production
 }
 
-export const clineEnvConfig = configs[CURRENT_ENVIRONMENT]
+// Config getter function to avoid storing all configs in memory
+function getEnvironmentConfig(env: Environment): EnvironmentConfig {
+	switch (env) {
+		case Environment.staging:
+			return {
+				appBaseUrl: "https://staging-app.cline.bot",
+				apiBaseUrl: "https://core-api.staging.int.cline.bot",
+				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+				firebase: {
+					apiKey: "AIzaSyASSwkwX1kSO8vddjZkE5N19QU9cVQ0CIk",
+					authDomain: "cline-staging.firebaseapp.com",
+					projectId: "cline-staging",
+					storageBucket: "cline-staging.firebasestorage.app",
+					messagingSenderId: "853479478430",
+					appId: "1:853479478430:web:2de0dba1c63c3262d4578f",
+				},
+			}
+		case Environment.local:
+			return {
+				appBaseUrl: "http://localhost:3000",
+				apiBaseUrl: "http://localhost:7777",
+				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+				firebase: {
+					apiKey: "AIzaSyD8wtkd1I-EICuAg6xgAQpRdwYTvwxZG2w",
+					authDomain: "cline-preview.firebaseapp.com",
+					projectId: "cline-preview",
+				},
+			}
+		default:
+			return {
+				appBaseUrl: "https://app.cline.bot",
+				apiBaseUrl: "https://api.cline.bot",
+				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+				firebase: {
+					apiKey: "AIzaSyC5rx59Xt8UgwdU3PCfzUF7vCwmp9-K2vk",
+					authDomain: "cline-prod.firebaseapp.com",
+					projectId: "cline-prod",
+					storageBucket: "cline-prod.firebasestorage.app",
+					messagingSenderId: "941048379330",
+					appId: "1:941048379330:web:45058eedeefc5cdfcc485b",
+				},
+			}
+	}
+}
+
+// Get environment once at module load
+const CLINE_ENVIRONMENT = getClineEnv()
+const _configCache = getEnvironmentConfig(CLINE_ENVIRONMENT)
+
+console.info("Cline environment:", CLINE_ENVIRONMENT)
+
+export const clineEnvConfig = _configCache

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

@@ -6,8 +6,8 @@ import * as path from "path"
 import { FileContextTracker } from "./FileContextTracker"
 import * as diskModule from "@core/storage/disk"
 import type { TaskMetadata, FileMetadataEntry } from "./ContextTrackerTypes"
-import type { DiffViewProviderCreator, WebviewProviderCreator } from "@/hosts/host-providers"
-import * as hostProviders from "@hosts/host-providers"
+import type { DiffViewProviderCreator, WebviewProviderCreator } from "@/hosts/host-provider"
+import { HostProvider } from "@/hosts/host-provider"
 import { vscodeHostBridgeClient } from "@/hosts/vscode/hostbridge/client/host-grpc-client"
 
 describe("FileContextTracker", () => {
@@ -53,7 +53,10 @@ describe("FileContextTracker", () => {
 		mockTaskMetadata = { files_in_context: [], model_usage: [] }
 		getTaskMetadataStub = sandbox.stub(diskModule, "getTaskMetadata").resolves(mockTaskMetadata)
 		saveTaskMetadataStub = sandbox.stub(diskModule, "saveTaskMetadata").resolves()
-		hostProviders.initializeHostProviders(
+
+		// Reset HostProvider before initializing to avoid "already initialized" errors
+		HostProvider.reset()
+		HostProvider.initialize(
 			((_) => {}) as WebviewProviderCreator,
 			(() => {}) as DiffViewProviderCreator,
 			vscodeHostBridgeClient,
@@ -66,6 +69,8 @@ describe("FileContextTracker", () => {
 
 	afterEach(() => {
 		sandbox.restore()
+		// Reset HostProvider after each test to ensure clean state
+		HostProvider.reset()
 	})
 
 	it("should add a record when a file is read by a tool", async () => {

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

@@ -5,7 +5,7 @@ import { getWorkspaceState, updateWorkspaceState } from "@core/storage/state"
 import { getGlobalState } from "@core/storage/state"
 import type { FileMetadataEntry } from "./ContextTrackerTypes"
 import type { ClineMessage } from "@shared/ExtensionMessage"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 import { getCwd } from "@/utils/path"
 
 // This class is responsible for tracking file operations that may result in stale context.

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

@@ -240,7 +240,7 @@ export async function deleteRuleFile(
 		}
 
 		// Delete the file from disk
-		await fs.unlink(rulePath)
+		await fs.rm(rulePath, { force: true })
 
 		// Get the filename for messages
 		const fileName = path.basename(rulePath)

src/core/controller/account/accountLoginClicked.ts

@@ -1,7 +1,6 @@
 import { Controller } from "../index"
 import { AuthService } from "@/services/auth/AuthService"
 import { EmptyRequest, String } from "../../../shared/proto/common"
-import { openExternal } from "@utils/env"
 
 const authService = AuthService.getInstance()
 
@@ -13,6 +12,6 @@ const authService = AuthService.getInstance()
  * @param controller The controller instance.
  * @returns The login URL as a string.
  */
-export async function accountLoginClicked(controller: Controller, _: EmptyRequest): Promise<String> {
+export async function accountLoginClicked(_controller: Controller, _: EmptyRequest): Promise<String> {
 	return await authService.createAuthRequest()
 }

src/core/controller/checkpoints/checkpointRestore.ts

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

src/core/controller/file/copyToClipboard.ts

@@ -1,6 +1,5 @@
-import * as vscode from "vscode"
 import { Controller } from ".."
-import { Empty, StringRequest } from "../../../shared/proto/common"
+import { Empty, StringRequest } from "@shared/proto/common"
 import { writeTextToClipboard } from "@/utils/env"
 
 /**
@@ -9,7 +8,7 @@ import { writeTextToClipboard } from "@/utils/env"
  * @param request The request containing the text to copy
  * @returns Empty response
  */
-export async function copyToClipboard(controller: Controller, request: StringRequest): Promise<Empty> {
+export async function copyToClipboard(_controller: Controller, request: StringRequest): Promise<Empty> {
 	try {
 		if (request.value) {
 			await writeTextToClipboard(request.value)

src/core/controller/file/createRuleFile.ts

@@ -1,14 +1,13 @@
 import { Controller } from ".."
 import { RuleFileRequest, RuleFile } from "@shared/proto/file"
-import { FileMethodHandler } from "./index"
 import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
 import { createRuleFile as createRuleFileImpl } from "@core/context/instructions/user-instructions/rule-helpers"
 import * as path from "path"
-import { handleFileServiceRequest } from "./index"
 import { refreshWorkflowToggles } from "@/core/context/instructions/user-instructions/workflows"
 import { getCwd, getDesktopDir } from "@/utils/path"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
-import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
+import { openFile } from "./openFile"
 
 /**
  * Creates a rule file in either global or workspace rules directory
@@ -17,7 +16,7 @@ import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
  * @returns Result with file path and display name
  * @throws Error if operation fails
  */
-export const createRuleFile: FileMethodHandler = async (controller: Controller, request: RuleFileRequest): Promise<RuleFile> => {
+export async function createRuleFile(controller: Controller, request: RuleFileRequest): Promise<RuleFile> {
 	if (
 		typeof request.isGlobal !== "boolean" ||
 		!request.filename ||
@@ -44,14 +43,12 @@ export const createRuleFile: FileMethodHandler = async (controller: Controller,
 
 	if (fileExists) {
 		const message = `${fileTypeName} file "${request.filename}" already exists.`
-		getHostBridgeProvider().windowClient.showMessage(
-			ShowMessageRequest.create({
-				type: ShowMessageType.WARNING,
-				message,
-			}),
-		)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.WARNING,
+			message,
+		})
 		// Still open it for editing
-		await handleFileServiceRequest(controller, "openFile", { value: filePath })
+		await openFile(controller, { value: filePath })
 	} else {
 		if (request.type === "workflow") {
 			await refreshWorkflowToggles(controller.context, cwd)
@@ -60,15 +57,13 @@ export const createRuleFile: FileMethodHandler = async (controller: Controller,
 		}
 		await controller.postStateToWebview()
 
-		await handleFileServiceRequest(controller, "openFile", { value: filePath })
+		await openFile(controller, { value: filePath })
 
 		const message = `Created new ${request.isGlobal ? "global" : "workspace"} ${fileTypeName} file: ${request.filename}`
-		getHostBridgeProvider().windowClient.showMessage(
-			ShowMessageRequest.create({
-				type: ShowMessageType.INFORMATION,
-				message,
-			}),
-		)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message,
+		})
 	}
 
 	return RuleFile.create({

src/core/controller/file/deleteRuleFile.ts

@@ -2,9 +2,8 @@ import { deleteRuleFile as deleteRuleFileImpl } from "@core/context/instructions
 import { RuleFile, RuleFileRequest } from "@shared/proto/file"
 import * as path from "path"
 import { Controller } from ".."
-import { FileMethodHandler } from "./index"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
-import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/host/window"
 
 /**
  * Deletes a rule file from either global or workspace rules directory
@@ -13,7 +12,7 @@ import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
  * @returns Result with file path and display name
  * @throws Error if operation fails
  */
-export const deleteRuleFile: FileMethodHandler = async (controller: Controller, request: RuleFileRequest): Promise<RuleFile> => {
+export async function deleteRuleFile(controller: Controller, request: RuleFileRequest): Promise<RuleFile> {
 	if (
 		typeof request.isGlobal !== "boolean" ||
 		typeof request.rulePath !== "string" ||
@@ -46,12 +45,10 @@ export const deleteRuleFile: FileMethodHandler = async (controller: Controller,
 	const fileTypeName = request.type === "workflow" ? "workflow" : "rule"
 
 	const message = `${fileTypeName} file "${fileName}" deleted successfully`
-	getHostBridgeProvider().windowClient.showMessage(
-		ShowMessageRequest.create({
-			type: ShowMessageType.INFORMATION,
-			message,
-		}),
-	)
+	HostProvider.window.showMessage({
+		type: ShowMessageType.INFORMATION,
+		message,
+	})
 
 	return RuleFile.create({
 		filePath: request.rulePath,

src/core/controller/file/getRelativePaths.ts

@@ -3,7 +3,6 @@ import { RelativePaths, RelativePathsRequest } from "@shared/proto/file"
 import * as path from "path"
 import { URI } from "vscode-uri"
 import { Controller } from ".."
-import { FileMethodHandler } from "./index"
 import { isDirectory } from "@/utils/fs"
 
 /**
@@ -12,10 +11,7 @@ import { isDirectory } from "@/utils/fs"
  * @param request The request containing URIs to convert
  * @returns Response with resolved relative paths
  */
-export const getRelativePaths: FileMethodHandler = async (
-	_controller: Controller,
-	request: RelativePathsRequest,
-): Promise<RelativePaths> => {
+export async function getRelativePaths(_controller: Controller, request: RelativePathsRequest): Promise<RelativePaths> {
 	const result = []
 	for (const uriString of request.uris) {
 		try {

src/core/controller/file/openFile.ts

@@ -1,7 +1,6 @@
 import { Controller } from ".."
 import { Empty, StringRequest } from "@shared/proto/common"
 import { openFile as openFileIntegration } from "@integrations/misc/open-file"
-import { FileMethodHandler } from "./index"
 
 /**
  * Opens a file in the editor
@@ -9,7 +8,7 @@ import { FileMethodHandler } from "./index"
  * @param request The request message containing the file path in the 'value' field
  * @returns Empty response
  */
-export const openFile: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<Empty> => {
+export async function openFile(_controller: Controller, request: StringRequest): Promise<Empty> {
 	if (request.value) {
 		openFileIntegration(request.value)
 	}

src/core/controller/file/openImage.ts

@@ -1,7 +1,6 @@
 import { Controller } from ".."
 import { Empty, StringRequest } from "@shared/proto/common"
 import { openImage as openImageIntegration } from "@integrations/misc/open-file"
-import { FileMethodHandler } from "./index"
 
 /**
  * Opens an image in the system viewer
@@ -9,7 +8,7 @@ import { FileMethodHandler } from "./index"
  * @param request The request message containing the image path or data URI in the 'value' field
  * @returns Empty response
  */
-export const openImage: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<Empty> => {
+export async function openImage(_controller: Controller, request: StringRequest): Promise<Empty> {
 	if (request.value) {
 		await openImageIntegration(request.value)
 	}

src/core/controller/file/openTaskHistory.ts

@@ -1,7 +1,6 @@
 import { Controller } from ".."
 import { Empty, StringRequest } from "@shared/proto/common"
 import { openFile as openFileIntegration } from "@integrations/misc/open-file"
-import { FileMethodHandler } from "./index"
 import path from "path"
 /**
  * Opens a file in the editor
@@ -9,7 +8,7 @@ import path from "path"
  * @param request The request message containing the file path in the 'value' field
  * @returns Empty response
  */
-export const openTaskHistory: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<Empty> => {
+export async function openTaskHistory(controller: Controller, request: StringRequest): Promise<Empty> {
 	const globalStoragePath = controller.context.globalStorageUri.fsPath
 	const taskHistoryPath = path.join(globalStoragePath, "tasks", request.value, "api_conversation_history.json")
 	if (request.value) {

src/core/controller/file/searchCommits.ts

@@ -3,7 +3,6 @@ import { GitCommits } from "@shared/proto/file"
 import { StringRequest } from "@shared/proto/common"
 import { searchCommits as searchCommitsUtil } from "@utils/git"
 import { getWorkspacePath } from "@utils/path"
-import { FileMethodHandler } from "./index"
 import { convertGitCommitsToProtoGitCommits } from "@shared/proto-conversions/file/git-commit-conversion"
 
 /**
@@ -12,7 +11,7 @@ import { convertGitCommitsToProtoGitCommits } from "@shared/proto-conversions/fi
  * @param request The request message containing the search query in the 'value' field
  * @returns GitCommits containing the matching commits
  */
-export const searchCommits: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<GitCommits> => {
+export async function searchCommits(_controller: Controller, request: StringRequest): Promise<GitCommits> {
 	const cwd = await getWorkspacePath()
 	if (!cwd) {
 		return GitCommits.create({ commits: [] })

src/core/controller/file/searchFiles.ts

@@ -2,7 +2,6 @@ import { Controller } from ".."
 import { FileSearchRequest, FileSearchResults } from "@shared/proto/file"
 import { searchWorkspaceFiles } from "@services/search/file-search"
 import { getWorkspacePath } from "@utils/path"
-import { FileMethodHandler } from "./index"
 import { convertSearchResultsToProtoFileInfos } from "@shared/proto-conversions/file/search-result-conversion"
 
 /**
@@ -11,10 +10,7 @@ import { convertSearchResultsToProtoFileInfos } from "@shared/proto-conversions/
  * @param request The request containing search query and optionally a mentionsRequestId
  * @returns Results containing matching files/folders
  */
-export const searchFiles: FileMethodHandler = async (
-	_controller: Controller,
-	request: FileSearchRequest,
-): Promise<FileSearchResults> => {
+export async function searchFiles(_controller: Controller, request: FileSearchRequest): Promise<FileSearchResults> {
 	const workspacePath = await getWorkspacePath()
 
 	if (!workspacePath) {

src/core/controller/file/selectFiles.ts

@@ -1,7 +1,6 @@
 import { Controller } from ".."
 import { BooleanRequest, StringArrays } from "@shared/proto/common"
 import { selectFiles as selectFilesIntegration } from "@integrations/misc/process-files"
-import { FileMethodHandler } from "./index"
 
 /**
  * Prompts the user to select images from the file system and returns them as data URLs
@@ -9,7 +8,7 @@ import { FileMethodHandler } from "./index"
  * @param request Boolean request, with the value defining whether this model supports images
  * @returns Two arrays of image data URLs and other file paths
  */
-export const selectFiles: FileMethodHandler = async (controller: Controller, request: BooleanRequest): Promise<StringArrays> => {
+export async function selectFiles(_controller: Controller, request: BooleanRequest): Promise<StringArrays> {
 	try {
 		const { images, files } = await selectFilesIntegration(request.value)
 		return StringArrays.create({ values1: images, values2: files })

src/core/controller/file/subscribeToWorkspaceUpdates.ts

@@ -3,7 +3,7 @@ import { EmptyRequest, StringArray } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active subscriptions
-const activeWorkspaceUpdateSubscriptions = new Set<StreamingResponseHandler>()
+const activeWorkspaceUpdateSubscriptions = new Set<StreamingResponseHandler<StringArray>>()
 
 /**
  * Subscribe to workspace file updates
@@ -13,9 +13,9 @@ const activeWorkspaceUpdateSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToWorkspaceUpdates(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<StringArray>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/controller/grpc-handler.ts

@@ -1,11 +1,15 @@
 import { Controller } from "./index"
-import { serviceHandlers } from "./grpc-service-config"
+import { serviceHandlers } from "@generated/hosts/vscode/protobus-services"
 import { GrpcRequestRegistry } from "./grpc-request-registry"
 
 /**
  * Type definition for a streaming response handler
  */
-export type StreamingResponseHandler = (response: any, isLast?: boolean, sequenceNumber?: number) => Promise<void>
+export type StreamingResponseHandler<TResponse> = (
+	response: TResponse,
+	isLast?: boolean,
+	sequenceNumber?: number,
+) => Promise<void>
 
 /**
  * Handles gRPC requests from the webview
@@ -41,14 +45,11 @@ export class GrpcHandler {
 			}
 
 			// Get the service handler from the config
-			const serviceConfig = serviceHandlers[service]
-			if (!serviceConfig) {
-				throw new Error(`Unknown service: ${service}`)
-			}
+			const handler = getHandler(service, method)
 
 			// Handle unary request
 			return {
-				message: await serviceConfig.requestHandler(this.controller, method, message),
+				message: await handler(this.controller, message),
 				request_id: requestId,
 			}
 		} catch (error) {
@@ -68,7 +69,7 @@ export class GrpcHandler {
 	 */
 	private async handleStreamingRequest(service: string, method: string, message: any, requestId: string): Promise<void> {
 		// Create a response stream function
-		const responseStream: StreamingResponseHandler = async (
+		const responseStream: StreamingResponseHandler<any> = async (
 			response: any,
 			isLast: boolean = false,
 			sequenceNumber?: number,
@@ -86,23 +87,16 @@ export class GrpcHandler {
 
 		try {
 			// Get the service handler from the config
-			const serviceConfig = serviceHandlers[service]
-			if (!serviceConfig) {
-				throw new Error(`Unknown service: ${service}`)
-			}
-
-			// Check if the service supports streaming
-			if (!serviceConfig.streamingHandler) {
-				throw new Error(`Service ${service} does not support streaming`)
-			}
+			const handler = getHandler(service, method)
 
 			// Handle streaming request and pass the requestId to all streaming handlers
-			await serviceConfig.streamingHandler(this.controller, method, message, responseStream, requestId)
+			await handler(this.controller, message, responseStream, requestId)
 
 			// Don't send a final message here - the stream should stay open for future updates
 			// The stream will be closed when the client disconnects or when the service explicitly ends it
 		} catch (error) {
 			// Send error response
+			console.log("Protobus error:", error)
 			await this.controller.postMessageToWebview({
 				type: "grpc_response",
 				grpc_response: {
@@ -167,6 +161,7 @@ export async function handleGrpcRequest(
 		})
 	} catch (error) {
 		// Send error response
+		console.log("Protobus error:", error)
 		await controller.postMessageToWebview({
 			type: "grpc_response",
 			grpc_response: {
@@ -205,6 +200,19 @@ export async function handleGrpcRequestCancel(
 	}
 }
 
+function getHandler(serviceName: string, methodName: string): any {
+	// Get the service handler from the config
+	const serviceConfig = serviceHandlers[serviceName]
+	if (!serviceConfig) {
+		throw new Error(`Unknown service: ${serviceName}`)
+	}
+	const handler = serviceConfig[methodName]
+	if (!handler) {
+		throw new Error(`Unknown rpc: ${serviceName}.${methodName}`)
+	}
+	return handler
+}
+
 /**
  * Get the request registry instance
  * This allows other parts of the code to access the registry

src/core/controller/grpc-request-registry.ts

@@ -22,7 +22,7 @@ export interface RequestInfo {
 	/**
 	 * The streaming response handler for this request
 	 */
-	responseStream?: StreamingResponseHandler
+	responseStream?: StreamingResponseHandler<any>
 }
 
 /**
@@ -46,7 +46,7 @@ export class GrpcRequestRegistry {
 		requestId: string,
 		cleanup: () => void,
 		metadata?: any,
-		responseStream?: StreamingResponseHandler,
+		responseStream?: StreamingResponseHandler<any>,
 	): void {
 		this.activeRequests.set(requestId, {
 			cleanup,

src/core/controller/grpc-service.ts

@@ -12,7 +12,7 @@ export type ServiceMethodHandler = (controller: Controller, message: any) => Pro
 export type StreamingMethodHandler = (
 	controller: Controller,
 	message: any,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<any>,
 	requestId?: string,
 ) => Promise<void>
 
@@ -109,7 +109,7 @@ export class ServiceRegistry {
 		controller: Controller,
 		method: string,
 		message: any,
-		responseStream: StreamingResponseHandler,
+		responseStream: StreamingResponseHandler<any>,
 		requestId?: string,
 	): Promise<void> {
 		const handler = this.streamingMethodRegistry[method]
@@ -144,7 +144,7 @@ export function createServiceRegistry(serviceName: string) {
 			controller: Controller,
 			method: string,
 			message: any,
-			responseStream: StreamingResponseHandler,
+			responseStream: StreamingResponseHandler<any>,
 			requestId?: string,
 		) => registry.handleStreamingRequest(controller, method, message, responseStream, requestId),
 

src/core/controller/index.ts

@@ -1,16 +1,19 @@
+import { clineEnvConfig } from "@/config"
+import { HostProvider } from "@/hosts/host-provider"
+import { AuthService } from "@/services/auth/AuthService"
 import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
+import { ShowMessageType } from "@/shared/proto/host/window"
 import { getCwd, getDesktopDir } from "@/utils/path"
 import { Anthropic } from "@anthropic-ai/sdk"
 import { buildApiHandler } from "@api/index"
 import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
-import { extractCommitMessage } from "@integrations/git/commit-message-generator"
 import { downloadTask } from "@integrations/misc/export-markdown"
 import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
 import { ClineAccountService } from "@services/account/ClineAccountService"
 import { McpHub } from "@services/mcp/McpHub"
 import { ApiProvider, ModelInfo } from "@shared/api"
 import { ChatContent } from "@shared/ChatContent"
-import { ChatSettings, StoredChatSettings } from "@shared/ChatSettings"
+import { ChatSettings, Mode, StoredChatSettings } from "@shared/ChatSettings"
 import { ClineRulesToggles } from "@shared/cline-rules"
 import { ExtensionMessage, ExtensionState, Platform } from "@shared/ExtensionMessage"
 import { HistoryItem } from "@shared/HistoryItem"
@@ -19,7 +22,6 @@ import { TelemetrySetting } from "@shared/TelemetrySetting"
 import { UserInfo } from "@shared/UserInfo"
 import { WebviewMessage } from "@shared/WebviewMessage"
 import { fileExistsAtPath } from "@utils/fs"
-import { getWorkingState } from "@utils/git"
 import axios from "axios"
 import fs from "fs/promises"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
@@ -30,13 +32,9 @@ import { ensureMcpServersDirectoryExists, ensureSettingsDirectoryExists, GlobalF
 import { getAllExtensionState, getGlobalState, getWorkspaceState, storeSecret, updateGlobalState } from "../storage/state"
 import { Task } from "../task"
 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"
-import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
-import { clineEnvConfig } from "@/config"
 
 /*
 https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -50,11 +48,14 @@ export class Controller {
 
 	private disposables: vscode.Disposable[] = []
 	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
+	get latestAnnouncementId(): string {
+		return this.context.extension?.packageJSON?.version?.split(".").slice(0, 2).join(".") ?? ""
+	}
 
 	constructor(
 		readonly context: vscode.ExtensionContext,
@@ -83,8 +84,8 @@ export class Controller {
 		})
 	}
 
-	private async getCurrentMode(): Promise<"plan" | "act"> {
-		return ((await getGlobalState(this.context, "mode")) as "plan" | "act" | undefined) || "act"
+	async getCurrentMode(): Promise<Mode> {
+		return ((await getGlobalState(this.context, "mode")) as Mode | undefined) || "act"
 	}
 
 	/*
@@ -112,21 +113,20 @@ export class Controller {
 			// 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 updateGlobalState(this.context, "apiProvider", "openrouter")
+			await Promise.all([
+				updateGlobalState(this.context, "planModeApiProvider", "openrouter"),
+				updateGlobalState(this.context, "actModeApiProvider", "openrouter"),
+			])
 			await this.postStateToWebview()
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.INFORMATION,
-					message: "Successfully logged out of Cline",
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Successfully logged out of Cline",
+			})
 		} catch (error) {
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.INFORMATION,
-					message: "Logout failed",
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Logout failed",
+			})
 		}
 	}
 
@@ -257,153 +257,10 @@ export class Controller {
 		// Capture mode switch telemetry | Capture regardless of if we know the taskId
 		telemetryService.captureModeSwitch(this.task?.taskId ?? "0", chatSettings.mode)
 
-		// Get previous model info that we will revert to after saving current mode api info
-		const {
-			apiConfiguration,
-			previousModeApiProvider: newApiProvider,
-			previousModeModelId: newModelId,
-			previousModeModelInfo: newModelInfo,
-			previousModeVsCodeLmModelSelector: newVsCodeLmModelSelector,
-			previousModeThinkingBudgetTokens: newThinkingBudgetTokens,
-			previousModeReasoningEffort: newReasoningEffort,
-			previousModeAwsBedrockCustomSelected: newAwsBedrockCustomSelected,
-			previousModeAwsBedrockCustomModelBaseId: newAwsBedrockCustomModelBaseId,
-			previousModeSapAiCoreModelId: newSapAiCoreModelId,
-			planActSeparateModelsSetting,
-		} = await getAllExtensionState(this.context)
-
-		const shouldSwitchModel = planActSeparateModelsSetting === true
-
-		if (shouldSwitchModel) {
-			// Save the last model used in this mode
-			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":
-				case "gemini":
-				case "asksage":
-				case "openai-native":
-				case "qwen":
-				case "deepseek":
-				case "xai":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					break
-				case "bedrock":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateGlobalState(
-						this.context,
-						"previousModeAwsBedrockCustomSelected",
-						apiConfiguration.awsBedrockCustomSelected,
-					)
-					await updateGlobalState(
-						this.context,
-						"previousModeAwsBedrockCustomModelBaseId",
-						apiConfiguration.awsBedrockCustomModelBaseId,
-					)
-					break
-				case "openrouter":
-				case "cline":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
-					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 updateGlobalState(
-						this.context,
-						"previousModeVsCodeLmModelSelector",
-						apiConfiguration.vsCodeLmModelSelector,
-					)
-					break
-				case "openai":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openAiModelId)
-					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.openAiModelInfo)
-					break
-				case "ollama":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.ollamaModelId)
-					break
-				case "lmstudio":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.lmStudioModelId)
-					break
-				case "litellm":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.liteLlmModelId)
-					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.liteLlmModelInfo)
-					break
-				case "requesty":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.requestyModelId)
-					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.requestyModelInfo)
-					break
-				case "sapaicore":
-					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateGlobalState(this.context, "previousModeSapAiCoreModelId", apiConfiguration.sapAiCoreModelId)
-					break
-			}
-
-			// Restore the model used in previous mode
-			if (
-				newApiProvider ||
-				newModelId ||
-				newThinkingBudgetTokens !== undefined ||
-				newReasoningEffort ||
-				newVsCodeLmModelSelector
-			) {
-				await updateGlobalState(this.context, "apiProvider", newApiProvider)
-				await updateGlobalState(this.context, "thinkingBudgetTokens", newThinkingBudgetTokens)
-				await updateGlobalState(this.context, "reasoningEffort", newReasoningEffort)
-				switch (newApiProvider) {
-					case "anthropic":
-					case "vertex":
-					case "gemini":
-					case "asksage":
-					case "openai-native":
-					case "qwen":
-					case "deepseek":
-					case "xai":
-						await updateGlobalState(this.context, "apiModelId", newModelId)
-						break
-					case "bedrock":
-						await updateGlobalState(this.context, "apiModelId", newModelId)
-						await updateGlobalState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
-						await updateGlobalState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
-						break
-					case "openrouter":
-					case "cline":
-						await updateGlobalState(this.context, "openRouterModelId", newModelId)
-						await updateGlobalState(this.context, "openRouterModelInfo", newModelInfo)
-						break
-					case "vscode-lm":
-						await updateGlobalState(this.context, "vsCodeLmModelSelector", newVsCodeLmModelSelector)
-						break
-					case "openai":
-						await updateGlobalState(this.context, "openAiModelId", newModelId)
-						await updateGlobalState(this.context, "openAiModelInfo", newModelInfo)
-						break
-					case "ollama":
-						await updateGlobalState(this.context, "ollamaModelId", newModelId)
-						break
-					case "lmstudio":
-						await updateGlobalState(this.context, "lmStudioModelId", newModelId)
-						break
-					case "litellm":
-						await updateGlobalState(this.context, "liteLlmModelId", newModelId)
-						await updateGlobalState(this.context, "liteLlmModelInfo", newModelInfo)
-						break
-					case "requesty":
-						await updateGlobalState(this.context, "requestyModelId", newModelId)
-						await updateGlobalState(this.context, "requestyModelInfo", newModelInfo)
-						break
-					case "sapaicore":
-						await updateGlobalState(this.context, "apiModelId", newModelId)
-						await updateGlobalState(this.context, "sapAiCoreModelId", newSapAiCoreModelId)
-						break
-				}
-
-				if (this.task) {
-					const { apiConfiguration: updatedApiConfiguration } = await getAllExtensionState(this.context)
-					this.task.api = buildApiHandler(updatedApiConfiguration)
-				}
-			}
+		// Update API handler with new mode (buildApiHandler now selects provider based on mode)
+		if (this.task) {
+			const { apiConfiguration } = await getAllExtensionState(this.context)
+			this.task.api = buildApiHandler({ ...apiConfiguration, taskId: this.task.taskId }, chatSettings.mode)
 		}
 
 		// Save only non-mode properties to global storage
@@ -467,30 +324,47 @@ export class Controller {
 			await this.authService.handleAuthCallback(customToken, provider ? provider : "google")
 
 			const clineProvider: ApiProvider = "cline"
-			await updateGlobalState(this.context, "apiProvider", clineProvider)
 
-			// Mark welcome view as completed since user has successfully logged in
-			await updateGlobalState(this.context, "welcomeViewCompleted", true)
+			// Get current settings to determine how to update providers
+			const { planActSeparateModelsSetting } = await getAllExtensionState(this.context)
+			const currentMode = await this.getCurrentMode()
 
+			if (planActSeparateModelsSetting) {
+				// Only update the current mode's provider
+				if (currentMode === "plan") {
+					await updateGlobalState(this.context, "planModeApiProvider", clineProvider)
+				} else {
+					await updateGlobalState(this.context, "actModeApiProvider", clineProvider)
+				}
+			} else {
+				// Update both modes to keep them in sync
+				await Promise.all([
+					updateGlobalState(this.context, "planModeApiProvider", clineProvider),
+					updateGlobalState(this.context, "actModeApiProvider", clineProvider),
+				])
+			}
+
+			// Get the updated API configuration (now includes the updated providers)
 			const { apiConfiguration } = await getAllExtensionState(this.context)
 			const updatedConfig = {
 				...apiConfiguration,
 				apiProvider: clineProvider,
 			}
 
+			// Mark welcome view as completed since user has successfully logged in
+			await updateGlobalState(this.context, "welcomeViewCompleted", true)
+
 			if (this.task) {
-				this.task.api = buildApiHandler(updatedConfig)
+				this.task.api = buildApiHandler({ ...updatedConfig, taskId: this.task.taskId }, currentMode)
 			}
 
 			await this.postStateToWebview()
 		} catch (error) {
 			console.error("Failed to handle auth callback:", error)
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.ERROR,
-					message: "Failed to log in to Cline",
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: "Failed to log in to Cline",
+			})
 			// Even on login failure, we preserve any existing tokens
 			// Only clear tokens on explicit logout
 		}
@@ -525,12 +399,10 @@ export class Controller {
 			console.error("Failed to fetch MCP marketplace:", error)
 			if (!silent) {
 				const errorMessage = error instanceof Error ? error.message : "Failed to fetch MCP marketplace"
-				getHostBridgeProvider().windowClient.showMessage(
-					ShowMessageRequest.create({
-						type: ShowMessageType.ERROR,
-						message: errorMessage,
-					}),
-				)
+				HostProvider.window.showMessage({
+					type: ShowMessageType.ERROR,
+					message: errorMessage,
+				})
 			}
 			return undefined
 		}
@@ -614,12 +486,10 @@ export class Controller {
 		} catch (error) {
 			console.error("Failed to handle cached MCP marketplace:", error)
 			const errorMessage = error instanceof Error ? error.message : "Failed to handle cached MCP marketplace"
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.ERROR,
-					message: errorMessage,
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: errorMessage,
+			})
 		}
 	}
 
@@ -640,14 +510,22 @@ export class Controller {
 		}
 
 		const openrouter: ApiProvider = "openrouter"
-		await updateGlobalState(this.context, "apiProvider", openrouter)
+		const currentMode = await this.getCurrentMode()
+		await Promise.all([
+			updateGlobalState(this.context, "planModeApiProvider", openrouter),
+			updateGlobalState(this.context, "actModeApiProvider", openrouter),
+		])
 		await storeSecret(this.context, "openRouterApiKey", apiKey)
 		await this.postStateToWebview()
 		if (this.task) {
-			this.task.api = buildApiHandler({
-				apiProvider: openrouter,
+			// Get the updated API configuration (now includes the updated providers)
+			const { apiConfiguration } = await getAllExtensionState(this.context)
+			const updatedConfig = {
+				...apiConfiguration,
 				openRouterApiKey: apiKey,
-			})
+				taskId: this.task.taskId,
+			}
+			this.task.api = buildApiHandler(updatedConfig, currentMode)
 		}
 		// await this.postMessageToWebview({ type: "action", action: "settingsButtonClicked" }) // bad ux if user is on welcome
 	}
@@ -975,150 +853,5 @@ export class Controller {
 
 	// secrets
 
-	// Git commit message generation
-
-	async generateGitCommitMessage() {
-		try {
-			// Check if there's a workspace folder open
-			const cwd = await getCwd()
-			if (!cwd) {
-				getHostBridgeProvider().windowClient.showMessage(
-					ShowMessageRequest.create({
-						type: ShowMessageType.ERROR,
-						message: "No workspace folder open",
-					}),
-				)
-				return
-			}
-
-			// Get the git diff
-			const gitDiff = await getWorkingState(cwd)
-			if (gitDiff === "No changes in working directory") {
-				getHostBridgeProvider().windowClient.showMessage(
-					ShowMessageRequest.create({
-						type: ShowMessageType.INFORMATION,
-						message: "No changes in workspace for commit message",
-					}),
-				)
-				return
-			}
-
-			// Show a progress notification
-			await vscode.window.withProgress(
-				{
-					location: vscode.ProgressLocation.Notification,
-					title: "Generating commit message...",
-					cancellable: false,
-				},
-				async (progress, token) => {
-					try {
-						// Format the git diff into a prompt
-						const prompt = `Based on the following git diff, generate a concise and descriptive commit message:
-
-${gitDiff.length > 5000 ? gitDiff.substring(0, 5000) + "\n\n[Diff truncated due to size]" : gitDiff}
-
-The commit message should:
-1. Start with a short summary (50-72 characters)
-2. Use the imperative mood (e.g., "Add feature" not "Added feature")
-3. Describe what was changed and why
-4. Be clear and descriptive
-
-Commit message:`
-
-						// Get the current API configuration
-						const { apiConfiguration } = await getAllExtensionState(this.context)
-
-						// Build the API handler
-						const apiHandler = buildApiHandler(apiConfiguration)
-
-						// Create a system prompt
-						const systemPrompt =
-							"You are a helpful assistant that generates concise and descriptive git commit messages based on git diffs."
-
-						// Create a message for the API
-						const messages = [
-							{
-								role: "user" as const,
-								content: prompt,
-							},
-						]
-
-						// Call the API directly
-						const stream = apiHandler.createMessage(systemPrompt, messages)
-
-						// Collect the response
-						let response = ""
-						for await (const chunk of stream) {
-							if (chunk.type === "text") {
-								response += chunk.text
-							}
-						}
-
-						// Extract the commit message
-						const commitMessage = extractCommitMessage(response)
-
-						// Apply the commit message to the Git input box
-						if (commitMessage) {
-							// Get the Git extension API
-							const gitExtension = vscode.extensions.getExtension("vscode.git")?.exports
-							if (gitExtension) {
-								const api = gitExtension.getAPI(1)
-								if (api && api.repositories.length > 0) {
-									const repo = api.repositories[0]
-									repo.inputBox.value = commitMessage
-									const message = "Commit message generated and applied"
-									getHostBridgeProvider().windowClient.showMessage(
-										ShowMessageRequest.create({
-											type: ShowMessageType.INFORMATION,
-											message,
-										}),
-									)
-								} else {
-									const message = "No Git repositories found"
-									getHostBridgeProvider().windowClient.showMessage(
-										ShowMessageRequest.create({
-											type: ShowMessageType.ERROR,
-											message,
-										}),
-									)
-								}
-							} else {
-								const message = "Git extension not found"
-								getHostBridgeProvider().windowClient.showMessage(
-									ShowMessageRequest.create({
-										type: ShowMessageType.ERROR,
-										message,
-									}),
-								)
-							}
-						} else {
-							const message = "Failed to generate commit message"
-							getHostBridgeProvider().windowClient.showMessage(
-								ShowMessageRequest.create({
-									type: ShowMessageType.ERROR,
-									message,
-								}),
-							)
-						}
-					} catch (innerError) {
-						const innerErrorMessage = innerError instanceof Error ? innerError.message : String(innerError)
-						getHostBridgeProvider().windowClient.showMessage(
-							ShowMessageRequest.create({
-								type: ShowMessageType.ERROR,
-								message: `Failed to generate commit message: ${innerErrorMessage}`,
-							}),
-						)
-					}
-				},
-			)
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error)
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.ERROR,
-					message: `Failed to generate commit message: ${errorMessage}`,
-				}),
-			)
-		}
-	}
+	// dev
 }

src/core/controller/mcp/subscribeToMcpMarketplaceCatalog.ts

@@ -4,7 +4,7 @@ import { McpMarketplaceCatalog } from "@shared/proto/mcp"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active subscriptions
-const activeMcpMarketplaceSubscriptions = new Set<StreamingResponseHandler>()
+const activeMcpMarketplaceSubscriptions = new Set<StreamingResponseHandler<McpMarketplaceCatalog>>()
 
 /**
  * Subscribe to MCP marketplace catalog updates
@@ -14,9 +14,9 @@ const activeMcpMarketplaceSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToMcpMarketplaceCatalog(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<McpMarketplaceCatalog>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/controller/mcp/subscribeToMcpServers.ts

@@ -5,7 +5,7 @@ import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 import { convertMcpServersToProtoMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
 
 // Keep track of active subscriptions
-const activeMcpServersSubscriptions = new Set<StreamingResponseHandler>()
+const activeMcpServersSubscriptions = new Set<StreamingResponseHandler<McpServers>>()
 
 /**
  * Subscribe to MCP servers events
@@ -16,8 +16,8 @@ const activeMcpServersSubscriptions = new Set<StreamingResponseHandler>()
  */
 export async function subscribeToMcpServers(
 	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<McpServers>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/controller/models/refreshHuggingFaceModels.ts

@@ -0,0 +1,113 @@
+import { Controller } from ".."
+import { EmptyRequest } from "../../../shared/proto/common"
+import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "../../../shared/proto/models"
+import axios from "axios"
+import path from "path"
+import fs from "fs/promises"
+import { fileExistsAtPath } from "@utils/fs"
+import { GlobalFileNames } from "@core/storage/disk"
+import { huggingFaceModels } from "@shared/api"
+
+/**
+ * Ensures the cache directory exists and returns its path
+ */
+async function ensureCacheDirectoryExists(controller: Controller): Promise<string> {
+	const cacheDir = path.join(controller.context.globalStorageUri.fsPath, "cache")
+	try {
+		await fs.mkdir(cacheDir, { recursive: true })
+	} catch (error) {
+		// Directory might already exist
+	}
+	return cacheDir
+}
+
+/**
+ * Refreshes the Hugging Face models and returns the updated model list
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing the Hugging Face models
+ */
+export async function refreshHuggingFaceModels(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const huggingFaceModelsFilePath = path.join(await ensureCacheDirectoryExists(controller), "huggingface_models.json")
+
+	let models: Record<string, OpenRouterModelInfo> = {}
+
+	try {
+		// Fetch models from Hugging Face API
+		const response = await axios.get("https://router.huggingface.co/v1/models", {
+			timeout: 10000,
+		})
+
+		if (response.data?.data) {
+			const rawModels = response.data.data
+
+			// Transform HF models to OpenRouter-compatible format
+			for (const rawModel of rawModels) {
+				const providersList = rawModel.providers?.map((provider: { provider: string }) => provider.provider)?.join(", ")
+				const modelInfo = OpenRouterModelInfo.create({
+					maxTokens: 8192, // HF doesn't provide max_tokens, use default
+					contextWindow: 128_000, // FIXME: HF doesn't provide context window, use default
+					supportsImages: false, // Most models don't support images
+					supportsPromptCache: false,
+					inputPrice: 0, // Will be set based on providers
+					outputPrice: 0, // Will be set based on providers
+					cacheWritesPrice: 0,
+					cacheReadsPrice: 0,
+					description: `Available on providers: ${providersList || "unknown"}`,
+				})
+
+				// Add model-specific configurations if we have them in our static models
+				if (rawModel.id in huggingFaceModels) {
+					const staticModel = huggingFaceModels[rawModel.id as keyof typeof huggingFaceModels]
+					modelInfo.maxTokens = staticModel.maxTokens
+					modelInfo.contextWindow = staticModel.contextWindow
+					modelInfo.supportsImages = staticModel.supportsImages
+					modelInfo.supportsPromptCache = staticModel.supportsPromptCache
+					modelInfo.inputPrice = staticModel.inputPrice
+					modelInfo.outputPrice = staticModel.outputPrice
+					modelInfo.description = staticModel.description || modelInfo.description
+				}
+
+				models[rawModel.id] = modelInfo
+			}
+
+			// Save to cache
+			await fs.writeFile(huggingFaceModelsFilePath, JSON.stringify(models, null, 2))
+		}
+	} catch (error) {
+		console.error("Error fetching Hugging Face models:", error)
+
+		// Try to load from cache
+		try {
+			if (await fileExistsAtPath(huggingFaceModelsFilePath)) {
+				const cachedModels = await fs.readFile(huggingFaceModelsFilePath, "utf-8")
+				const parsedModels = JSON.parse(cachedModels)
+				models = parsedModels
+			}
+		} catch (cacheError) {
+			console.error("Error loading cached Hugging Face models:", cacheError)
+		}
+
+		// If no cache available, use static models as fallback
+		if (Object.keys(models).length === 0) {
+			for (const [modelId, modelInfo] of Object.entries(huggingFaceModels)) {
+				models[modelId] = OpenRouterModelInfo.create({
+					maxTokens: modelInfo.maxTokens,
+					contextWindow: modelInfo.contextWindow,
+					supportsImages: modelInfo.supportsImages,
+					supportsPromptCache: modelInfo.supportsPromptCache,
+					inputPrice: modelInfo.inputPrice,
+					outputPrice: modelInfo.outputPrice,
+					cacheWritesPrice: (modelInfo as any).cacheWritesPrice || 0,
+					cacheReadsPrice: (modelInfo as any).cacheReadsPrice || 0,
+					description: modelInfo.description || "",
+				})
+			}
+		}
+	}
+
+	return OpenRouterCompatibleModelInfo.create({ models })
+}

src/core/controller/models/subscribeToOpenRouterModels.ts

@@ -4,7 +4,7 @@ import { OpenRouterCompatibleModelInfo } from "@shared/proto/models"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active OpenRouter models subscriptions
-const activeOpenRouterModelsSubscriptions = new Set<StreamingResponseHandler>()
+const activeOpenRouterModelsSubscriptions = new Set<StreamingResponseHandler<OpenRouterCompatibleModelInfo>>()
 
 /**
  * Subscribe to OpenRouter models events
@@ -14,9 +14,9 @@ const activeOpenRouterModelsSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToOpenRouterModels(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<OpenRouterCompatibleModelInfo>,
 	requestId?: string,
 ): Promise<void> {
 	console.log("[DEBUG] set up OpenRouter models subscription")

src/core/controller/models/updateApiConfigurationProto.ts

@@ -29,7 +29,8 @@ export async function updateApiConfigurationProto(
 
 		// Update the task's API handler if there's an active task
 		if (controller.task) {
-			controller.task.api = buildApiHandler(appApiConfiguration)
+			const currentMode = await controller.getCurrentMode()
+			controller.task.api = buildApiHandler({ ...appApiConfiguration, taskId: controller.task.taskId }, currentMode)
 		}
 
 		// Post updated state to webview

src/core/controller/state/resetState.ts

@@ -4,7 +4,7 @@ import { ResetStateRequest } from "../../../shared/proto/state"
 import { resetGlobalState, resetWorkspaceState } from "../../../core/storage/state"
 import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
 import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 
 /**
  * Resets the extension state to its defaults
@@ -15,20 +15,16 @@ import { getHostBridgeProvider } from "@/hosts/host-providers"
 export async function resetState(controller: Controller, request: ResetStateRequest): Promise<Empty> {
 	try {
 		if (request.global) {
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.INFORMATION,
-					message: "Resetting global state...",
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Resetting global state...",
+			})
 			await resetGlobalState(controller.context)
 		} else {
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.INFORMATION,
-					message: "Resetting workspace state...",
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message: "Resetting workspace state...",
+			})
 			await resetWorkspaceState(controller.context)
 		}
 
@@ -37,12 +33,10 @@ export async function resetState(controller: Controller, request: ResetStateRequ
 			controller.task = undefined
 		}
 
-		getHostBridgeProvider().windowClient.showMessage(
-			ShowMessageRequest.create({
-				type: ShowMessageType.INFORMATION,
-				message: "State reset",
-			}),
-		)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.INFORMATION,
+			message: "State reset",
+		})
 		await controller.postStateToWebview()
 
 		await sendChatButtonClickedEvent(controller.id)
@@ -50,12 +44,10 @@ export async function resetState(controller: Controller, request: ResetStateRequ
 		return Empty.create()
 	} catch (error) {
 		console.error("Error resetting state:", error)
-		getHostBridgeProvider().windowClient.showMessage(
-			ShowMessageRequest.create({
-				type: ShowMessageType.ERROR,
-				message: `Failed to reset state: ${error instanceof Error ? error.message : String(error)}`,
-			}),
-		)
+		HostProvider.window.showMessage({
+			type: ShowMessageType.ERROR,
+			message: `Failed to reset state: ${error instanceof Error ? error.message : String(error)}`,
+		})
 		throw error
 	}
 }

src/core/controller/state/subscribeToState.ts

@@ -2,9 +2,10 @@ import * as vscode from "vscode"
 import { Controller } from "../index"
 import { EmptyRequest } from "../../../shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
+import { State } from "@/shared/proto/state"
 
 // Keep track of active state subscriptions by controller ID
-const activeStateSubscriptions = new Map<string, StreamingResponseHandler>()
+const activeStateSubscriptions = new Map<string, StreamingResponseHandler<State>>()
 
 /**
  * Subscribe to state updates
@@ -15,8 +16,8 @@ const activeStateSubscriptions = new Map<string, StreamingResponseHandler>()
  */
 export async function subscribeToState(
 	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<State>,
 	requestId?: string,
 ): Promise<void> {
 	const controllerId = controller.id

src/core/controller/state/updateDefaultTerminalProfile.ts

@@ -2,7 +2,7 @@ import { Controller } from "../index"
 import * as proto from "@/shared/proto"
 import { updateGlobalState } from "../../storage/state"
 import { TerminalInfo } from "@/integrations/terminal/TerminalRegistry"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
 
 export async function updateDefaultTerminalProfile(
@@ -27,12 +27,10 @@ export async function updateDefaultTerminalProfile(
 		// Show information message if terminals were closed
 		if (closedCount > 0) {
 			const message = `Closed ${closedCount} ${closedCount === 1 ? "terminal" : "terminals"} with different profile.`
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.INFORMATION,
-					message,
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.INFORMATION,
+				message,
+			})
 		}
 
 		// Show warning if there are busy terminals that couldn't be closed
@@ -40,12 +38,10 @@ export async function updateDefaultTerminalProfile(
 			const message =
 				`${busyTerminals.length} busy ${busyTerminals.length === 1 ? "terminal has" : "terminals have"} a different profile. ` +
 				`Close ${busyTerminals.length === 1 ? "it" : "them"} to use the new profile for all commands.`
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.WARNING,
-					message,
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.WARNING,
+				message,
+			})
 		}
 	}
 

src/core/controller/state/updateSettings.ts

@@ -21,7 +21,8 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			await updateApiConfiguration(controller.context, apiConfiguration)
 
 			if (controller.task) {
-				controller.task.api = buildApiHandler(apiConfiguration)
+				const currentMode = await controller.getCurrentMode()
+				controller.task.api = buildApiHandler({ ...apiConfiguration, taskId: controller.task.taskId }, currentMode)
 			}
 		}
 

src/core/controller/task/deleteAllTaskHistory.ts

@@ -5,7 +5,7 @@ import { DeleteAllTaskHistoryCount } from "../../../shared/proto/task"
 import { getGlobalState, updateGlobalState } from "../../storage/state"
 import { fileExistsAtPath } from "../../../utils/fs"
 import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 
 /**
  * Deletes all task history, with an option to preserve favorites
@@ -23,7 +23,7 @@ export async function deleteAllTaskHistory(controller: Controller): Promise<Dele
 		const totalTasks = taskHistory.length
 
 		const userChoice = (
-			await getHostBridgeProvider().windowClient.showMessage(
+			await HostProvider.window.showMessage(
 				ShowMessageRequest.create({
 					type: ShowMessageType.WARNING,
 					message: "What would you like to delete?",
@@ -33,7 +33,7 @@ export async function deleteAllTaskHistory(controller: Controller): Promise<Dele
 					},
 				}),
 			)
-		)?.selectedOption
+		).selectedOption
 
 		// Default VS Code Cancel button returns `undefined` - don't delete anything
 		if (userChoice === undefined) {
@@ -67,17 +67,15 @@ export async function deleteAllTaskHistory(controller: Controller): Promise<Dele
 			} else {
 				// No favorited tasks found - show warning and ask user what to do
 				const answer = (
-					await getHostBridgeProvider().windowClient.showMessage(
-						ShowMessageRequest.create({
-							type: ShowMessageType.WARNING,
-							message: "No favorited tasks found. Would you like to delete all tasks anyway?",
-							options: {
-								modal: true,
-								items: ["Delete All Tasks"],
-							},
-						}),
-					)
-				)?.selectedOption
+					await HostProvider.window.showMessage({
+						type: ShowMessageType.WARNING,
+						message: "No favorited tasks found. Would you like to delete all tasks anyway?",
+						options: {
+							modal: true,
+							items: ["Delete All Tasks"],
+						},
+					})
+				).selectedOption
 
 				// User cancelled - don't delete anything
 				if (answer === undefined) {
@@ -105,12 +103,10 @@ export async function deleteAllTaskHistory(controller: Controller): Promise<Dele
 				await fs.rm(checkpointsDirPath, { recursive: true, force: true })
 			}
 		} catch (error) {
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.ERROR,
-					message: `Encountered error while deleting task history, there may be some files left behind. Error: ${error instanceof Error ? error.message : String(error)}`,
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Encountered error while deleting task history, there may be some files left behind. Error: ${error instanceof Error ? error.message : String(error)}`,
+			})
 		}
 
 		// Update webview

src/core/controller/task/deleteTasksWithIds.ts

@@ -2,9 +2,8 @@ import path from "path"
 import fs from "fs/promises"
 import { Controller } from ".."
 import { Empty, StringArrayRequest } from "../../../shared/proto/common"
-import { TaskMethodHandler } from "./index"
 import { fileExistsAtPath } from "../../../utils/fs"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
 
 /**
@@ -14,10 +13,7 @@ import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
  * @returns Empty response
  * @throws Error if operation fails
  */
-export const deleteTasksWithIds: TaskMethodHandler = async (
-	controller: Controller,
-	request: StringArrayRequest,
-): Promise<Empty> => {
+export async function deleteTasksWithIds(controller: Controller, request: StringArrayRequest): Promise<Empty> {
 	if (!request.value || request.value.length === 0) {
 		throw new Error("Missing task IDs")
 	}
@@ -28,13 +24,11 @@ export const deleteTasksWithIds: TaskMethodHandler = async (
 			? "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 getHostBridgeProvider().windowClient.showMessage(
-		ShowMessageRequest.create({
-			type: ShowMessageType.WARNING,
-			message,
-			options: { modal: true, items: ["Delete"] },
-		}),
-	)
+	const userChoice = await HostProvider.window.showMessage({
+		type: ShowMessageType.WARNING,
+		message,
+		options: { modal: true, items: ["Delete"] },
+	})
 
 	if (userChoice === undefined) {
 		return Empty.create()
@@ -76,10 +70,7 @@ async function deleteTaskWithId(controller: Controller, id: string): Promise<voi
 			contextHistoryFilePath,
 			taskMetadataFilePath,
 		]) {
-			const fileExists = await fileExistsAtPath(filePath)
-			if (fileExists) {
-				await fs.unlink(filePath)
-			}
+			await fs.rm(filePath, { force: true })
 		}
 
 		// Remove empty task directory

src/core/controller/task/exportTaskWithId.ts

@@ -1,6 +1,5 @@
 import { Controller } from ".."
 import { Empty, StringRequest } from "@shared/proto/common"
-import { TaskMethodHandler } from "./index"
 
 /**
  * Exports a task with the given ID to markdown
@@ -8,7 +7,7 @@ import { TaskMethodHandler } from "./index"
  * @param request The request containing the task ID in the value field
  * @returns Empty response
  */
-export const exportTaskWithId: TaskMethodHandler = async (controller: Controller, request: StringRequest): Promise<Empty> => {
+export async function exportTaskWithId(controller: Controller, request: StringRequest): Promise<Empty> {
 	try {
 		if (request.value) {
 			await controller.exportTaskWithId(request.value)

src/core/controller/ui/getWebviewHtml.ts

@@ -1,6 +1,6 @@
 import type { Controller } from "../index"
-import { EmptyRequest, Empty, String } from "@shared/proto/common"
-import * as hostProviders from "@hosts/host-providers"
+import { EmptyRequest, String } from "@shared/proto/common"
+import { HostProvider } from "@/hosts/host-provider"
 import { WebviewProviderType } from "@/shared/webview/types"
 
 /**
@@ -10,7 +10,7 @@ import { WebviewProviderType } from "@/shared/webview/types"
  * @returns Empty response
  */
 export async function getWebviewHtml(_controller: Controller, _: EmptyRequest): Promise<String> {
-	const webviewProvider = hostProviders.createWebviewProvider(WebviewProviderType.SIDEBAR)
+	const webviewProvider = HostProvider.get().createWebviewProvider(WebviewProviderType.SIDEBAR)
 
 	return Promise.resolve(String.create({ value: webviewProvider.getHtmlContent() }))
 }

src/core/controller/ui/initializeWebview.ts

@@ -1,12 +1,14 @@
 import type { Controller } from "../index"
 import { EmptyRequest, Empty } from "@shared/proto/common"
-import { handleModelsServiceRequest } from "../models"
+
 import { getAllExtensionState, getGlobalState, updateGlobalState } from "../../storage/state"
 import { sendOpenRouterModelsEvent } from "../models/subscribeToOpenRouterModels"
 import { sendMcpMarketplaceCatalogEvent } from "../mcp/subscribeToMcpMarketplaceCatalog"
 import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
 import { OpenRouterCompatibleModelInfo } from "@/shared/proto/models"
 import { McpMarketplaceCatalog } from "@shared/mcp"
+import { refreshOpenRouterModels } from "../models/refreshOpenRouterModels"
+import { refreshGroqModels } from "../models/refreshGroqModels"
 
 /**
  * Initialize webview when it launches
@@ -27,28 +29,80 @@ export async function initializeWebview(controller: Controller, request: EmptyRe
 		})
 
 		// Refresh OpenRouter models from API
-		handleModelsServiceRequest(controller, "refreshOpenRouterModels", EmptyRequest.create()).then(async (response) => {
+		refreshOpenRouterModels(controller, EmptyRequest.create()).then(async (response) => {
 			if (response && response.models) {
 				// 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 updateGlobalState(
-						controller.context,
-						"openRouterModelInfo",
-						response.models[apiConfiguration.openRouterModelId],
-					)
-					await controller.postStateToWebview()
+				const { apiConfiguration, planActSeparateModelsSetting } = await getAllExtensionState(controller.context)
+				const currentMode = await controller.getCurrentMode()
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeOpenRouterModelId" : "actModeOpenRouterModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeOpenRouterModelInfo" : "actModeOpenRouterModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && response.models[modelId]) {
+						await updateGlobalState(controller.context, modelInfoField, response.models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeOpenRouterModelId
+					const actModelId = apiConfiguration.actModeOpenRouterModelId
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && response.models[planModelId]) {
+						await updateGlobalState(controller.context, "planModeOpenRouterModelInfo", response.models[planModelId])
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && response.models[actModelId]) {
+						await updateGlobalState(controller.context, "actModeOpenRouterModelInfo", response.models[actModelId])
+					}
+
+					// Post state update if we updated any model info
+					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
+						await controller.postStateToWebview()
+					}
 				}
 			}
 		})
 
-		handleModelsServiceRequest(controller, "refreshGroqModels", EmptyRequest.create()).then(async (response) => {
+		refreshGroqModels(controller, EmptyRequest.create()).then(async (response) => {
 			if (response && response.models) {
-				// update model info in state for Groq
-				const { apiConfiguration } = await getAllExtensionState(controller.context)
-				if (apiConfiguration.groqModelId && response.models[apiConfiguration.groqModelId]) {
-					await updateGlobalState(controller.context, "groqModelInfo", response.models[apiConfiguration.groqModelId])
-					await controller.postStateToWebview()
+				// Update model info in state for Groq (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, planActSeparateModelsSetting } = await getAllExtensionState(controller.context)
+				const currentMode = await controller.getCurrentMode()
+
+				if (planActSeparateModelsSetting) {
+					// Separate models: update only current mode
+					const modelIdField = currentMode === "plan" ? "planModeGroqModelId" : "actModeGroqModelId"
+					const modelInfoField = currentMode === "plan" ? "planModeGroqModelInfo" : "actModeGroqModelInfo"
+					const modelId = apiConfiguration[modelIdField]
+
+					if (modelId && response.models[modelId]) {
+						await updateGlobalState(controller.context, modelInfoField, response.models[modelId])
+						await controller.postStateToWebview()
+					}
+				} else {
+					// Shared models: update both plan and act modes
+					const planModelId = apiConfiguration.planModeGroqModelId
+					const actModelId = apiConfiguration.actModeGroqModelId
+
+					// Update plan mode model info if we have a model ID
+					if (planModelId && response.models[planModelId]) {
+						await updateGlobalState(controller.context, "planModeGroqModelInfo", response.models[planModelId])
+					}
+
+					// Update act mode model info if we have a model ID
+					if (actModelId && response.models[actModelId]) {
+						await updateGlobalState(controller.context, "actModeGroqModelInfo", response.models[actModelId])
+					}
+
+					// Post state update if we updated any model info
+					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
+						await controller.postStateToWebview()
+					}
 				}
 			}
 		})

src/core/controller/ui/onDidShowAnnouncement.ts

@@ -1,28 +1,20 @@
 import type { EmptyRequest } from "../../../shared/proto/common"
 import { Boolean } from "../../../shared/proto/common"
 import type { Controller } from "../index"
-import { getGlobalState, updateGlobalState } from "../../storage/state"
+import { updateGlobalState } from "../../storage/state"
 
 /**
- * Marks the current announcement as shown and returns the updated shouldShowAnnouncement value
+ * Marks the current announcement as shown
  *
  * @param controller The controller instance
  * @param _request The empty request (not used)
- * @returns Boolean indicating whether an announcement should be shown
+ * @returns Boolean indicating announcement should no longer be shown
  */
 export async function onDidShowAnnouncement(controller: Controller, _request: EmptyRequest): Promise<Boolean> {
 	try {
 		// Update the lastShownAnnouncementId to the current latestAnnouncementId
 		await updateGlobalState(controller.context, "lastShownAnnouncementId", controller.latestAnnouncementId)
-
-		// Get the updated lastShownAnnouncementId value after the update
-		const lastShownAnnouncementId = await getGlobalState(controller.context, "lastShownAnnouncementId")
-
-		// Calculate the new shouldShowAnnouncement value
-		// This replicates the same logic used in getStateToPostToWebview()
-		const shouldShowAnnouncement = lastShownAnnouncementId !== controller.latestAnnouncementId
-
-		return Boolean.create({ value: shouldShowAnnouncement })
+		return Boolean.create({ value: false })
 	} catch (error) {
 		console.error("Failed to acknowledge announcement:", error)
 		return Boolean.create({ value: false })

src/core/controller/ui/openWalkthrough.ts

@@ -0,0 +1,22 @@
+import * as vscode from "vscode"
+import type { Controller } from "../index"
+import type { EmptyRequest } from "../../../shared/proto/common"
+import { Empty } from "../../../shared/proto/common"
+import { telemetryService } from "../../../services/posthog/telemetry/TelemetryService"
+
+/**
+ * Opens the Cline walkthrough in VSCode
+ * @param controller The controller instance
+ * @param request Empty request
+ * @returns Empty response
+ */
+export async function openWalkthrough(controller: Controller, request: EmptyRequest): Promise<Empty> {
+	try {
+		await vscode.commands.executeCommand("workbench.action.openWalkthrough", "saoudrizwan.claude-dev#ClineWalkthrough")
+		telemetryService.captureButtonClick("webview_openWalkthrough")
+		return Empty.create({})
+	} catch (error) {
+		console.error(`Failed to open walkthrough: ${error}`)
+		throw error
+	}
+}

src/core/controller/ui/subscribeToAccountButtonClicked.ts

@@ -3,7 +3,7 @@ import { Empty, EmptyRequest } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Track subscriptions by controller ID
-const activeSubscriptions = new Map<string, StreamingResponseHandler>()
+const activeSubscriptions = new Map<string, StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to account button clicked events
@@ -15,7 +15,7 @@ const activeSubscriptions = new Map<string, StreamingResponseHandler>()
 export async function subscribeToAccountButtonClicked(
 	controller: Controller,
 	_request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const controllerId = controller.id

src/core/controller/ui/subscribeToAddToInput.ts

@@ -1,11 +1,10 @@
-import * as vscode from "vscode"
 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 addToInput subscriptions
-const activeAddToInputSubscriptions = new Set<StreamingResponseHandler>()
+const activeAddToInputSubscriptions = new Set<StreamingResponseHandler<ProtoString>>()
 
 /**
  * Subscribe to addToInput events
@@ -15,9 +14,9 @@ const activeAddToInputSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToAddToInput(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<ProtoString>,
 	requestId?: string,
 ): Promise<void> {
 	console.log("[DEBUG] set up addToInput subscription")

src/core/controller/ui/subscribeToChatButtonClicked.ts

@@ -4,7 +4,7 @@ import { EmptyRequest } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active chatButtonClicked subscriptions by controller ID
-const activeChatButtonClickedSubscriptions = new Map<string, StreamingResponseHandler>()
+const activeChatButtonClickedSubscriptions = new Map<string, StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to chatButtonClicked events
@@ -16,7 +16,7 @@ const activeChatButtonClickedSubscriptions = new Map<string, StreamingResponseHa
 export async function subscribeToChatButtonClicked(
 	controller: Controller,
 	_request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const controllerId = controller.id

src/core/controller/ui/subscribeToDidBecomeVisible.ts

@@ -4,7 +4,7 @@ import { EmptyRequest } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active didBecomeVisible subscriptions by controller ID
-const activeDidBecomeVisibleSubscriptions = new Map<string, StreamingResponseHandler>()
+const activeDidBecomeVisibleSubscriptions = new Map<string, StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to didBecomeVisible events
@@ -15,8 +15,8 @@ const activeDidBecomeVisibleSubscriptions = new Map<string, StreamingResponseHan
  */
 export async function subscribeToDidBecomeVisible(
 	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const controllerId = controller.id

src/core/controller/ui/subscribeToFocusChatInput.ts

@@ -3,7 +3,7 @@ import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 import type { Controller } from "../index"
 
 // Map client IDs to their subscription handlers
-const focusChatInputSubscriptions = new Map<string, StreamingResponseHandler>()
+const focusChatInputSubscriptions = new Map<string, StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to focus chat input events
@@ -13,9 +13,9 @@ const focusChatInputSubscriptions = new Map<string, StreamingResponseHandler>()
  * @param requestId The ID of the request
  */
 export async function subscribeToFocusChatInput(
-	controller: Controller,
+	_controller: Controller,
 	request: StringRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const clientId = request.value

src/core/controller/ui/subscribeToHistoryButtonClicked.ts

@@ -4,7 +4,7 @@ import { WebviewProviderType, WebviewProviderTypeRequest } from "@shared/proto/u
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active subscriptions with their provider type
-const activeHistoryButtonClickedSubscriptions = new Map<StreamingResponseHandler, WebviewProviderType>()
+const activeHistoryButtonClickedSubscriptions = new Map<StreamingResponseHandler<Empty>, WebviewProviderType>()
 
 /**
  * Subscribe to history button clicked events
@@ -16,7 +16,7 @@ const activeHistoryButtonClickedSubscriptions = new Map<StreamingResponseHandler
 export async function subscribeToHistoryButtonClicked(
 	_controller: Controller,
 	request: WebviewProviderTypeRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	// Extract the provider type from the request

src/core/controller/ui/subscribeToMcpButtonClicked.ts

@@ -4,7 +4,7 @@ import { EmptyRequest } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active mcpButtonClicked subscriptions by controller ID
-const activeMcpButtonClickedSubscriptions = new Map<string, StreamingResponseHandler>()
+const activeMcpButtonClickedSubscriptions = new Map<string, StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to mcpButtonClicked events
@@ -16,7 +16,7 @@ const activeMcpButtonClickedSubscriptions = new Map<string, StreamingResponseHan
 export async function subscribeToMcpButtonClicked(
 	controller: Controller,
 	_request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const controllerId = controller.id

src/core/controller/ui/subscribeToPartialMessage.ts

@@ -4,7 +4,7 @@ import { ClineMessage } from "@shared/proto/ui"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active partial message subscriptions
-const activePartialMessageSubscriptions = new Set<StreamingResponseHandler>()
+const activePartialMessageSubscriptions = new Set<StreamingResponseHandler<ClineMessage>>()
 
 /**
  * Subscribe to partial message events
@@ -14,9 +14,9 @@ const activePartialMessageSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToPartialMessage(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<ClineMessage>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/controller/ui/subscribeToRelinquishControl.ts

@@ -3,7 +3,7 @@ import { EmptyRequest, Empty } from "@shared/proto/common"
 import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 
 // Keep track of active subscriptions
-const activeRelinquishControlSubscriptions = new Set<StreamingResponseHandler>()
+const activeRelinquishControlSubscriptions = new Set<StreamingResponseHandler<Empty>>()
 
 /**
  * Subscribe to relinquish control events
@@ -13,9 +13,9 @@ const activeRelinquishControlSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToRelinquishControl(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/controller/ui/subscribeToSettingsButtonClicked.ts

@@ -4,7 +4,7 @@ import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 import type { Controller } from "../index"
 
 // Track subscriptions with their provider type
-const subscriptions = new Map<StreamingResponseHandler, WebviewProviderType>()
+const subscriptions = new Map<StreamingResponseHandler<Empty>, WebviewProviderType>()
 
 /**
  * Subscribe to settings button clicked events
@@ -14,9 +14,9 @@ const subscriptions = new Map<StreamingResponseHandler, WebviewProviderType>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToSettingsButtonClicked(
-	controller: Controller,
+	_controller: Controller,
 	request: WebviewProviderTypeRequest,
-	responseStream: StreamingResponseHandler,
+	responseStream: StreamingResponseHandler<Empty>,
 	requestId?: string,
 ): Promise<void> {
 	const providerType = request.providerType

src/core/controller/ui/subscribeToTheme.ts

@@ -4,7 +4,7 @@ import { StreamingResponseHandler, getRequestRegistry } from "../grpc-handler"
 import { getTheme } from "@integrations/theme/getTheme"
 
 // Keep track of active theme subscriptions
-const activeThemeSubscriptions = new Set<StreamingResponseHandler>()
+const activeThemeSubscriptions = new Set<StreamingResponseHandler<String>>()
 
 /**
  * Subscribe to theme change events
@@ -14,9 +14,9 @@ const activeThemeSubscriptions = new Set<StreamingResponseHandler>()
  * @param requestId The ID of the request (passed by the gRPC handler)
  */
 export async function subscribeToTheme(
-	controller: Controller,
-	request: EmptyRequest,
-	responseStream: StreamingResponseHandler,
+	_controller: Controller,
+	_request: EmptyRequest,
+	responseStream: StreamingResponseHandler<String>,
 	requestId?: string,
 ): Promise<void> {
 	// Add this subscription to the active subscriptions

src/core/mentions/index.ts

@@ -13,7 +13,7 @@ import { getWorkingState } from "@utils/git"
 import { FileContextTracker } from "../context/context-tracking/FileContextTracker"
 import { getCwd } from "@/utils/path"
 import { openExternal } from "@utils/env"
-import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { HostProvider } from "@/hosts/host-provider"
 import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
 
 export async function openMention(mention?: string): Promise<void> {
@@ -78,12 +78,10 @@ export async function parseMentions(
 			await urlContentFetcher.launchBrowser()
 		} catch (error) {
 			launchBrowserError = error
-			getHostBridgeProvider().windowClient.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.ERROR,
-					message: `Error fetching content for ${urlMention}: ${error.message}`,
-				}),
-			)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: `Error fetching content for ${urlMention}: ${error.message}`,
+			})
 		}
 	}
 
@@ -100,12 +98,10 @@ export async function parseMentions(
 					const markdown = await urlContentFetcher.urlToMarkdown(mention)
 					result = markdown
 				} catch (error) {
-					getHostBridgeProvider().windowClient.showMessage(
-						ShowMessageRequest.create({
-							type: ShowMessageType.ERROR,
-							message: `Error fetching content for ${mention}: ${error.message}`,
-						}),
-					)
+					HostProvider.window.showMessage({
+						type: ShowMessageType.ERROR,
+						message: `Error fetching content for ${mention}: ${error.message}`,
+					})
 					result = `Error fetching content: ${error.message}`
 				}
 			}

src/core/prompts/responses.ts

@@ -2,6 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import * as diff from "diff"
 import * as path from "path"
 import { ClineIgnoreController, LOCK_TEXT_SYMBOL } from "../ignore/ClineIgnoreController"
+import { Mode } from "@/shared/ChatSettings"
 
 export const formatResponse = {
 	duplicateFileReadNotice: () =>
@@ -147,7 +148,7 @@ Otherwise, if you have not completed the task and do not need additional informa
 	},
 
 	taskResumption: (
-		mode: "plan" | "act",
+		mode: Mode,
 		agoText: string,
 		cwd: string,
 		wasRecent: boolean | 0 | undefined,

src/core/storage/state-keys.ts

@@ -21,6 +21,7 @@ export type SecretKey =
 	| "asksageApiKey"
 	| "xaiApiKey"
 	| "moonshotApiKey"
+	| "huggingFaceApiKey"
 	| "nebiusApiKey"
 	| "sambanovaApiKey"
 	| "cerebrasApiKey"
@@ -42,12 +43,9 @@ export type GlobalStateKey =
 	| "lastShownAnnouncementId"
 	| "taskHistory"
 	| "openAiBaseUrl"
-	| "openAiModelId"
-	| "openAiModelInfo"
 	| "openAiHeaders"
 	| "ollamaBaseUrl"
 	| "ollamaApiOptionsCtxNum"
-	| "lmStudioModelId"
 	| "lmStudioBaseUrl"
 	| "anthropicBaseUrl"
 	| "geminiBaseUrl"
@@ -87,38 +85,55 @@ export type GlobalStateKey =
 	// Settings around plan/act and ephemeral model configuration
 	| "chatSettings"
 	| "mode"
-	// Current active model configuration (per workspace)
-	| "apiProvider"
-	| "apiModelId"
-	| "thinkingBudgetTokens"
-	| "reasoningEffort"
-	| "vsCodeLmModelSelector"
-	| "awsBedrockCustomSelected"
-	| "awsBedrockCustomModelBaseId"
-	| "openRouterModelId"
-	| "openRouterModelInfo"
-	| "openAiModelId"
-	| "openAiModelInfo"
-	| "ollamaModelId"
-	| "lmStudioModelId"
-	| "liteLlmModelId"
-	| "liteLlmModelInfo"
-	| "requestyModelId"
-	| "requestyModelInfo"
-	| "togetherModelId"
-	| "fireworksModelId"
-	| "sapAiCoreModelId"
-	// Previous mode saved configurations (per workspace)
-	| "previousModeApiProvider"
-	| "previousModeModelId"
-	| "previousModeModelInfo"
-	| "previousModeVsCodeLmModelSelector"
-	| "previousModeThinkingBudgetTokens"
-	| "previousModeReasoningEffort"
-	| "previousModeAwsBedrockCustomSelected"
-	| "previousModeAwsBedrockCustomModelBaseId"
-	| "previousModeSapAiCoreModelId"
-	| "groqModelId"
-	| "groqModelInfo"
+	// Plan mode configurations
+	| "planModeApiProvider"
+	| "planModeApiModelId"
+	| "planModeThinkingBudgetTokens"
+	| "planModeReasoningEffort"
+	| "planModeVsCodeLmModelSelector"
+	| "planModeAwsBedrockCustomSelected"
+	| "planModeAwsBedrockCustomModelBaseId"
+	| "planModeOpenRouterModelId"
+	| "planModeOpenRouterModelInfo"
+	| "planModeOpenAiModelId"
+	| "planModeOpenAiModelInfo"
+	| "planModeOllamaModelId"
+	| "planModeLmStudioModelId"
+	| "planModeLiteLlmModelId"
+	| "planModeLiteLlmModelInfo"
+	| "planModeRequestyModelId"
+	| "planModeRequestyModelInfo"
+	| "planModeTogetherModelId"
+	| "planModeFireworksModelId"
+	| "planModeSapAiCoreModelId"
+	| "planModeGroqModelId"
+	| "planModeGroqModelInfo"
+	| "planModeHuggingFaceModelId"
+	| "planModeHuggingFaceModelInfo"
+	// Act mode configurations
+	| "actModeApiProvider"
+	| "actModeApiModelId"
+	| "actModeThinkingBudgetTokens"
+	| "actModeReasoningEffort"
+	| "actModeVsCodeLmModelSelector"
+	| "actModeAwsBedrockCustomSelected"
+	| "actModeAwsBedrockCustomModelBaseId"
+	| "actModeOpenRouterModelId"
+	| "actModeOpenRouterModelInfo"
+	| "actModeOpenAiModelId"
+	| "actModeOpenAiModelInfo"
+	| "actModeOllamaModelId"
+	| "actModeLmStudioModelId"
+	| "actModeLiteLlmModelId"
+	| "actModeLiteLlmModelInfo"
+	| "actModeRequestyModelId"
+	| "actModeRequestyModelInfo"
+	| "actModeTogetherModelId"
+	| "actModeFireworksModelId"
+	| "actModeSapAiCoreModelId"
+	| "actModeGroqModelId"
+	| "actModeGroqModelInfo"
+	| "actModeHuggingFaceModelId"
+	| "actModeHuggingFaceModelInfo"
 
 export type LocalStateKey = "localClineRulesToggles" | "localCursorRulesToggles" | "localWindsurfRulesToggles" | "workflowToggles"

src/core/storage/state-migrations.ts

@@ -32,6 +32,10 @@ export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionC
 		"togetherModelId",
 		"fireworksModelId",
 		"sapAiCoreModelId",
+		"groqModelId",
+		"groqModelInfo",
+		"huggingFaceModelId",
+		"huggingFaceModelInfo",
 
 		// Previous mode settings
 		"previousModeApiProvider",
@@ -53,8 +57,8 @@ export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionC
 		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)
+			// Move to global storage using raw VSCode method to avoid type errors
+			await context.globalState.update(key, workspaceValue)
 			// Remove from workspace storage
 			await context.workspaceState.update(key, undefined)
 			const newWorkspaceValue = await context.workspaceState.get(key)
@@ -169,6 +173,375 @@ export async function migrateModeFromWorkspaceStorageToControllerState(context:
 	}
 }
 
+export async function migrateLegacyApiConfigurationToModeSpecific(context: vscode.ExtensionContext) {
+	try {
+		// Check if migration is needed - if planModeApiProvider already exists, skip migration
+		const planModeApiProvider = await context.globalState.get("planModeApiProvider")
+		if (planModeApiProvider !== undefined) {
+			console.log("Legacy API configuration migration already completed, skipping...")
+			return
+		}
+
+		console.log("Starting legacy API configuration migration to mode-specific keys...")
+
+		// Get the planActSeparateModelsSetting to determine migration strategy
+		const planActSeparateModelsSetting = (await context.globalState.get("planActSeparateModelsSetting")) as
+			| boolean
+			| undefined
+
+		// Read legacy values directly
+		const apiProvider = await context.globalState.get("apiProvider")
+		const apiModelId = await context.globalState.get("apiModelId")
+		const thinkingBudgetTokens = await context.globalState.get("thinkingBudgetTokens")
+		const reasoningEffort = await context.globalState.get("reasoningEffort")
+		const vsCodeLmModelSelector = await context.globalState.get("vsCodeLmModelSelector")
+		const awsBedrockCustomSelected = await context.globalState.get("awsBedrockCustomSelected")
+		const awsBedrockCustomModelBaseId = await context.globalState.get("awsBedrockCustomModelBaseId")
+		const openRouterModelId = await context.globalState.get("openRouterModelId")
+		const openRouterModelInfo = await context.globalState.get("openRouterModelInfo")
+		const openAiModelId = await context.globalState.get("openAiModelId")
+		const openAiModelInfo = await context.globalState.get("openAiModelInfo")
+		const ollamaModelId = await context.globalState.get("ollamaModelId")
+		const lmStudioModelId = await context.globalState.get("lmStudioModelId")
+		const liteLlmModelId = await context.globalState.get("liteLlmModelId")
+		const liteLlmModelInfo = await context.globalState.get("liteLlmModelInfo")
+		const requestyModelId = await context.globalState.get("requestyModelId")
+		const requestyModelInfo = await context.globalState.get("requestyModelInfo")
+		const togetherModelId = await context.globalState.get("togetherModelId")
+		const fireworksModelId = await context.globalState.get("fireworksModelId")
+		const sapAiCoreModelId = await context.globalState.get("sapAiCoreModelId")
+		const groqModelId = await context.globalState.get("groqModelId")
+		const groqModelInfo = await context.globalState.get("groqModelInfo")
+		const huggingFaceModelId = await context.globalState.get("huggingFaceModelId")
+		const huggingFaceModelInfo = await context.globalState.get("huggingFaceModelInfo")
+
+		// Read previous mode values
+		const previousModeApiProvider = await context.globalState.get("previousModeApiProvider")
+		const previousModeModelId = await context.globalState.get("previousModeModelId")
+		const previousModeModelInfo = await context.globalState.get("previousModeModelInfo")
+		const previousModeVsCodeLmModelSelector = await context.globalState.get("previousModeVsCodeLmModelSelector")
+		const previousModeThinkingBudgetTokens = await context.globalState.get("previousModeThinkingBudgetTokens")
+		const previousModeReasoningEffort = await context.globalState.get("previousModeReasoningEffort")
+		const previousModeAwsBedrockCustomSelected = await context.globalState.get("previousModeAwsBedrockCustomSelected")
+		const previousModeAwsBedrockCustomModelBaseId = await context.globalState.get("previousModeAwsBedrockCustomModelBaseId")
+		const previousModeSapAiCoreModelId = await context.globalState.get("previousModeSapAiCoreModelId")
+
+		// Migrate based on planActSeparateModelsSetting
+		if (planActSeparateModelsSetting === false) {
+			console.log("Migrating with separate models DISABLED - using current values for both modes")
+
+			// Use current values for both plan and act modes
+			if (apiProvider !== undefined) {
+				await context.globalState.update("planModeApiProvider", apiProvider)
+				await context.globalState.update("actModeApiProvider", apiProvider)
+			}
+			if (apiModelId !== undefined) {
+				await context.globalState.update("planModeApiModelId", apiModelId)
+				await context.globalState.update("actModeApiModelId", apiModelId)
+			}
+			if (thinkingBudgetTokens !== undefined) {
+				await context.globalState.update("planModeThinkingBudgetTokens", thinkingBudgetTokens)
+				await context.globalState.update("actModeThinkingBudgetTokens", thinkingBudgetTokens)
+			}
+			if (reasoningEffort !== undefined) {
+				await context.globalState.update("planModeReasoningEffort", reasoningEffort)
+				await context.globalState.update("actModeReasoningEffort", reasoningEffort)
+			}
+			if (vsCodeLmModelSelector !== undefined) {
+				await context.globalState.update("planModeVsCodeLmModelSelector", vsCodeLmModelSelector)
+				await context.globalState.update("actModeVsCodeLmModelSelector", vsCodeLmModelSelector)
+			}
+			if (awsBedrockCustomSelected !== undefined) {
+				await context.globalState.update("planModeAwsBedrockCustomSelected", awsBedrockCustomSelected)
+				await context.globalState.update("actModeAwsBedrockCustomSelected", awsBedrockCustomSelected)
+			}
+			if (awsBedrockCustomModelBaseId !== undefined) {
+				await context.globalState.update("planModeAwsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
+				await context.globalState.update("actModeAwsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
+			}
+			if (openRouterModelId !== undefined) {
+				await context.globalState.update("planModeOpenRouterModelId", openRouterModelId)
+				await context.globalState.update("actModeOpenRouterModelId", openRouterModelId)
+			}
+			if (openRouterModelInfo !== undefined) {
+				await context.globalState.update("planModeOpenRouterModelInfo", openRouterModelInfo)
+				await context.globalState.update("actModeOpenRouterModelInfo", openRouterModelInfo)
+			}
+			if (openAiModelId !== undefined) {
+				await context.globalState.update("planModeOpenAiModelId", openAiModelId)
+				await context.globalState.update("actModeOpenAiModelId", openAiModelId)
+			}
+			if (openAiModelInfo !== undefined) {
+				await context.globalState.update("planModeOpenAiModelInfo", openAiModelInfo)
+				await context.globalState.update("actModeOpenAiModelInfo", openAiModelInfo)
+			}
+			if (ollamaModelId !== undefined) {
+				await context.globalState.update("planModeOllamaModelId", ollamaModelId)
+				await context.globalState.update("actModeOllamaModelId", ollamaModelId)
+			}
+			if (lmStudioModelId !== undefined) {
+				await context.globalState.update("planModeLmStudioModelId", lmStudioModelId)
+				await context.globalState.update("actModeLmStudioModelId", lmStudioModelId)
+			}
+			if (liteLlmModelId !== undefined) {
+				await context.globalState.update("planModeLiteLlmModelId", liteLlmModelId)
+				await context.globalState.update("actModeLiteLlmModelId", liteLlmModelId)
+			}
+			if (liteLlmModelInfo !== undefined) {
+				await context.globalState.update("planModeLiteLlmModelInfo", liteLlmModelInfo)
+				await context.globalState.update("actModeLiteLlmModelInfo", liteLlmModelInfo)
+			}
+			if (requestyModelId !== undefined) {
+				await context.globalState.update("planModeRequestyModelId", requestyModelId)
+				await context.globalState.update("actModeRequestyModelId", requestyModelId)
+			}
+			if (requestyModelInfo !== undefined) {
+				await context.globalState.update("planModeRequestyModelInfo", requestyModelInfo)
+				await context.globalState.update("actModeRequestyModelInfo", requestyModelInfo)
+			}
+			if (togetherModelId !== undefined) {
+				await context.globalState.update("planModeTogetherModelId", togetherModelId)
+				await context.globalState.update("actModeTogetherModelId", togetherModelId)
+			}
+			if (fireworksModelId !== undefined) {
+				await context.globalState.update("planModeFireworksModelId", fireworksModelId)
+				await context.globalState.update("actModeFireworksModelId", fireworksModelId)
+			}
+			if (sapAiCoreModelId !== undefined) {
+				await context.globalState.update("planModeSapAiCoreModelId", sapAiCoreModelId)
+				await context.globalState.update("actModeSapAiCoreModelId", sapAiCoreModelId)
+			}
+			if (groqModelId !== undefined) {
+				await context.globalState.update("planModeGroqModelId", groqModelId)
+				await context.globalState.update("actModeGroqModelId", groqModelId)
+			}
+			if (groqModelInfo !== undefined) {
+				await context.globalState.update("planModeGroqModelInfo", groqModelInfo)
+				await context.globalState.update("actModeGroqModelInfo", groqModelInfo)
+			}
+			if (huggingFaceModelId !== undefined) {
+				await context.globalState.update("planModeHuggingFaceModelId", huggingFaceModelId)
+				await context.globalState.update("actModeHuggingFaceModelId", huggingFaceModelId)
+			}
+			if (huggingFaceModelInfo !== undefined) {
+				await context.globalState.update("planModeHuggingFaceModelInfo", huggingFaceModelInfo)
+				await context.globalState.update("actModeHuggingFaceModelInfo", huggingFaceModelInfo)
+			}
+		} else {
+			console.log("Migrating with separate models ENABLED - using current->plan, previous->act")
+
+			// Use current values for plan mode
+			if (apiProvider !== undefined) {
+				await context.globalState.update("planModeApiProvider", apiProvider)
+			}
+			if (apiModelId !== undefined) {
+				await context.globalState.update("planModeApiModelId", apiModelId)
+			}
+			if (thinkingBudgetTokens !== undefined) {
+				await context.globalState.update("planModeThinkingBudgetTokens", thinkingBudgetTokens)
+			}
+			if (reasoningEffort !== undefined) {
+				await context.globalState.update("planModeReasoningEffort", reasoningEffort)
+			}
+			if (vsCodeLmModelSelector !== undefined) {
+				await context.globalState.update("planModeVsCodeLmModelSelector", vsCodeLmModelSelector)
+			}
+			if (awsBedrockCustomSelected !== undefined) {
+				await context.globalState.update("planModeAwsBedrockCustomSelected", awsBedrockCustomSelected)
+			}
+			if (awsBedrockCustomModelBaseId !== undefined) {
+				await context.globalState.update("planModeAwsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
+			}
+			if (openRouterModelId !== undefined) {
+				await context.globalState.update("planModeOpenRouterModelId", openRouterModelId)
+			}
+			if (openRouterModelInfo !== undefined) {
+				await context.globalState.update("planModeOpenRouterModelInfo", openRouterModelInfo)
+			}
+			if (openAiModelId !== undefined) {
+				await context.globalState.update("planModeOpenAiModelId", openAiModelId)
+			}
+			if (openAiModelInfo !== undefined) {
+				await context.globalState.update("planModeOpenAiModelInfo", openAiModelInfo)
+			}
+			if (ollamaModelId !== undefined) {
+				await context.globalState.update("planModeOllamaModelId", ollamaModelId)
+			}
+			if (lmStudioModelId !== undefined) {
+				await context.globalState.update("planModeLmStudioModelId", lmStudioModelId)
+			}
+			if (liteLlmModelId !== undefined) {
+				await context.globalState.update("planModeLiteLlmModelId", liteLlmModelId)
+			}
+			if (liteLlmModelInfo !== undefined) {
+				await context.globalState.update("planModeLiteLlmModelInfo", liteLlmModelInfo)
+			}
+			if (requestyModelId !== undefined) {
+				await context.globalState.update("planModeRequestyModelId", requestyModelId)
+			}
+			if (requestyModelInfo !== undefined) {
+				await context.globalState.update("planModeRequestyModelInfo", requestyModelInfo)
+			}
+			if (togetherModelId !== undefined) {
+				await context.globalState.update("planModeTogetherModelId", togetherModelId)
+			}
+			if (fireworksModelId !== undefined) {
+				await context.globalState.update("planModeFireworksModelId", fireworksModelId)
+			}
+			if (sapAiCoreModelId !== undefined) {
+				await context.globalState.update("planModeSapAiCoreModelId", sapAiCoreModelId)
+			}
+			if (groqModelId !== undefined) {
+				await context.globalState.update("planModeGroqModelId", groqModelId)
+			}
+			if (groqModelInfo !== undefined) {
+				await context.globalState.update("planModeGroqModelInfo", groqModelInfo)
+			}
+			if (huggingFaceModelId !== undefined) {
+				await context.globalState.update("planModeHuggingFaceModelId", huggingFaceModelId)
+			}
+			if (huggingFaceModelInfo !== undefined) {
+				await context.globalState.update("planModeHuggingFaceModelInfo", huggingFaceModelInfo)
+			}
+
+			// Use previous values for act mode (with fallback to current values)
+			if (previousModeApiProvider !== undefined) {
+				await context.globalState.update("actModeApiProvider", previousModeApiProvider)
+			} else if (apiProvider !== undefined) {
+				await context.globalState.update("actModeApiProvider", apiProvider)
+			}
+			if (previousModeModelId !== undefined) {
+				await context.globalState.update("actModeApiModelId", previousModeModelId)
+			} else if (apiModelId !== undefined) {
+				await context.globalState.update("actModeApiModelId", apiModelId)
+			}
+			if (previousModeThinkingBudgetTokens !== undefined) {
+				await context.globalState.update("actModeThinkingBudgetTokens", previousModeThinkingBudgetTokens)
+			} else if (thinkingBudgetTokens !== undefined) {
+				await context.globalState.update("actModeThinkingBudgetTokens", thinkingBudgetTokens)
+			}
+			if (previousModeReasoningEffort !== undefined) {
+				await context.globalState.update("actModeReasoningEffort", previousModeReasoningEffort)
+			} else if (reasoningEffort !== undefined) {
+				await context.globalState.update("actModeReasoningEffort", reasoningEffort)
+			}
+			if (previousModeVsCodeLmModelSelector !== undefined) {
+				await context.globalState.update("actModeVsCodeLmModelSelector", previousModeVsCodeLmModelSelector)
+			} else if (vsCodeLmModelSelector !== undefined) {
+				await context.globalState.update("actModeVsCodeLmModelSelector", vsCodeLmModelSelector)
+			}
+			if (previousModeAwsBedrockCustomSelected !== undefined) {
+				await context.globalState.update("actModeAwsBedrockCustomSelected", previousModeAwsBedrockCustomSelected)
+			} else if (awsBedrockCustomSelected !== undefined) {
+				await context.globalState.update("actModeAwsBedrockCustomSelected", awsBedrockCustomSelected)
+			}
+			if (previousModeAwsBedrockCustomModelBaseId !== undefined) {
+				await context.globalState.update("actModeAwsBedrockCustomModelBaseId", previousModeAwsBedrockCustomModelBaseId)
+			} else if (awsBedrockCustomModelBaseId !== undefined) {
+				await context.globalState.update("actModeAwsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
+			}
+			if (previousModeSapAiCoreModelId !== undefined) {
+				await context.globalState.update("actModeSapAiCoreModelId", previousModeSapAiCoreModelId)
+			} else if (sapAiCoreModelId !== undefined) {
+				await context.globalState.update("actModeSapAiCoreModelId", sapAiCoreModelId)
+			}
+
+			// For fields without previous variants, use current values for act mode
+			if (previousModeModelInfo !== undefined) {
+				await context.globalState.update("actModeOpenRouterModelInfo", previousModeModelInfo)
+			} else if (openRouterModelInfo !== undefined) {
+				await context.globalState.update("actModeOpenRouterModelInfo", openRouterModelInfo)
+			}
+			if (openRouterModelId !== undefined) {
+				await context.globalState.update("actModeOpenRouterModelId", openRouterModelId)
+			}
+			if (openAiModelId !== undefined) {
+				await context.globalState.update("actModeOpenAiModelId", openAiModelId)
+			}
+			if (openAiModelInfo !== undefined) {
+				await context.globalState.update("actModeOpenAiModelInfo", openAiModelInfo)
+			}
+			if (ollamaModelId !== undefined) {
+				await context.globalState.update("actModeOllamaModelId", ollamaModelId)
+			}
+			if (lmStudioModelId !== undefined) {
+				await context.globalState.update("actModeLmStudioModelId", lmStudioModelId)
+			}
+			if (liteLlmModelId !== undefined) {
+				await context.globalState.update("actModeLiteLlmModelId", liteLlmModelId)
+			}
+			if (liteLlmModelInfo !== undefined) {
+				await context.globalState.update("actModeLiteLlmModelInfo", liteLlmModelInfo)
+			}
+			if (requestyModelId !== undefined) {
+				await context.globalState.update("actModeRequestyModelId", requestyModelId)
+			}
+			if (requestyModelInfo !== undefined) {
+				await context.globalState.update("actModeRequestyModelInfo", requestyModelInfo)
+			}
+			if (togetherModelId !== undefined) {
+				await context.globalState.update("actModeTogetherModelId", togetherModelId)
+			}
+			if (fireworksModelId !== undefined) {
+				await context.globalState.update("actModeFireworksModelId", fireworksModelId)
+			}
+			if (groqModelId !== undefined) {
+				await context.globalState.update("actModeGroqModelId", groqModelId)
+			}
+			if (groqModelInfo !== undefined) {
+				await context.globalState.update("actModeGroqModelInfo", groqModelInfo)
+			}
+			if (huggingFaceModelId !== undefined) {
+				await context.globalState.update("actModeHuggingFaceModelId", huggingFaceModelId)
+			}
+			if (huggingFaceModelInfo !== undefined) {
+				await context.globalState.update("actModeHuggingFaceModelInfo", huggingFaceModelInfo)
+			}
+		}
+
+		// Clean up legacy keys after successful migration
+		console.log("Cleaning up legacy keys...")
+		await context.globalState.update("apiProvider", undefined)
+		await context.globalState.update("apiModelId", undefined)
+		await context.globalState.update("thinkingBudgetTokens", undefined)
+		await context.globalState.update("reasoningEffort", undefined)
+		await context.globalState.update("vsCodeLmModelSelector", undefined)
+		await context.globalState.update("awsBedrockCustomSelected", undefined)
+		await context.globalState.update("awsBedrockCustomModelBaseId", undefined)
+		await context.globalState.update("openRouterModelId", undefined)
+		await context.globalState.update("openRouterModelInfo", undefined)
+		await context.globalState.update("openAiModelId", undefined)
+		await context.globalState.update("openAiModelInfo", undefined)
+		await context.globalState.update("ollamaModelId", undefined)
+		await context.globalState.update("lmStudioModelId", undefined)
+		await context.globalState.update("liteLlmModelId", undefined)
+		await context.globalState.update("liteLlmModelInfo", undefined)
+		await context.globalState.update("requestyModelId", undefined)
+		await context.globalState.update("requestyModelInfo", undefined)
+		await context.globalState.update("togetherModelId", undefined)
+		await context.globalState.update("fireworksModelId", undefined)
+		await context.globalState.update("sapAiCoreModelId", undefined)
+		await context.globalState.update("groqModelId", undefined)
+		await context.globalState.update("groqModelInfo", undefined)
+		await context.globalState.update("huggingFaceModelId", undefined)
+		await context.globalState.update("huggingFaceModelInfo", undefined)
+		await context.globalState.update("previousModeApiProvider", undefined)
+		await context.globalState.update("previousModeModelId", undefined)
+		await context.globalState.update("previousModeModelInfo", undefined)
+		await context.globalState.update("previousModeVsCodeLmModelSelector", undefined)
+		await context.globalState.update("previousModeThinkingBudgetTokens", undefined)
+		await context.globalState.update("previousModeReasoningEffort", undefined)
+		await context.globalState.update("previousModeAwsBedrockCustomSelected", undefined)
+		await context.globalState.update("previousModeAwsBedrockCustomModelBaseId", undefined)
+		await context.globalState.update("previousModeSapAiCoreModelId", undefined)
+
+		console.log("Successfully migrated legacy API configuration to mode-specific keys")
+	} catch (error) {
+		console.error("Failed to migrate legacy API configuration to mode-specific keys:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
 export async function migrateWelcomeViewCompleted(context: vscode.ExtensionContext) {
 	try {
 		// Check if welcomeViewCompleted is already set
@@ -190,8 +563,10 @@ export async function migrateWelcomeViewCompleted(context: vscode.ExtensionConte
 						config.awsRegion,
 						config.vertexProjectId,
 						config.openAiApiKey,
-						config.ollamaModelId,
-						config.lmStudioModelId,
+						config.planModeOllamaModelId,
+						config.planModeLmStudioModelId,
+						config.actModeOllamaModelId,
+						config.actModeLmStudioModelId,
 						config.liteLlmApiKey,
 						config.geminiApiKey,
 						config.openAiNativeApiKey,
@@ -201,7 +576,8 @@ export async function migrateWelcomeViewCompleted(context: vscode.ExtensionConte
 						config.qwenApiKey,
 						config.doubaoApiKey,
 						config.mistralApiKey,
-						config.vsCodeLmModelSelector,
+						config.planModeVsCodeLmModelSelector,
+						config.actModeVsCodeLmModelSelector,
 						config.clineAccountId,
 						config.asksageApiKey,
 						config.xaiApiKey,

src/core/storage/state.ts

@@ -1,5 +1,5 @@
 import * as vscode from "vscode"
-import { DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
+import { DEFAULT_CHAT_SETTINGS, Mode } from "@shared/ChatSettings"
 import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
 import { GlobalStateKey, LocalStateKey, SecretKey } from "./state-keys"
@@ -170,6 +170,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		groqApiKey,
 		moonshotApiKey,
 		nebiusApiKey,
+		huggingFaceApiKey,
 		planActSeparateModelsSettingRaw,
 		favoritedModelIds,
 		globalClineRulesToggles,
@@ -189,8 +190,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		sapAiCoreTokenUrl,
 		sapAiResourceGroup,
 		claudeCodePath,
-		groqModelId,
-		groqModelInfo,
 	] = await Promise.all([
 		getGlobalState(context, "isNewUser") as Promise<boolean | undefined>,
 		getGlobalState(context, "welcomeViewCompleted") as Promise<boolean | undefined>,
@@ -250,6 +249,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getSecret(context, "groqApiKey") as Promise<string | undefined>,
 		getSecret(context, "moonshotApiKey") as Promise<string | undefined>,
 		getSecret(context, "nebiusApiKey") as Promise<string | undefined>,
+		getSecret(context, "huggingFaceApiKey") as Promise<string | undefined>,
 		getGlobalState(context, "planActSeparateModelsSetting") as Promise<boolean | undefined>,
 		getGlobalState(context, "favoritedModelIds") as Promise<string[] | undefined>,
 		getGlobalState(context, "globalClineRulesToggles") as Promise<ClineRulesToggles | undefined>,
@@ -269,8 +269,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getGlobalState(context, "sapAiCoreTokenUrl") as Promise<string | undefined>,
 		getGlobalState(context, "sapAiResourceGroup") as Promise<string | undefined>,
 		getGlobalState(context, "claudeCodePath") as Promise<string | undefined>,
-		getGlobalState(context, "groqModelId") as Promise<string | undefined>,
-		getGlobalState(context, "groqModelInfo") as Promise<ModelInfo | undefined>,
 	])
 
 	const localClineRulesToggles = (await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles
@@ -279,74 +277,115 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 	const [
 		chatSettings,
 		currentMode,
-		storedApiProvider,
-		apiModelId,
-		thinkingBudgetTokens,
-		reasoningEffort,
-		vsCodeLmModelSelector,
-		awsBedrockCustomSelected,
-		awsBedrockCustomModelBaseId,
-		openRouterModelId,
-		openRouterModelInfo,
-		openAiModelId,
-		openAiModelInfo,
-		ollamaModelId,
-		lmStudioModelId,
-		liteLlmModelId,
-		liteLlmModelInfo,
-		requestyModelId,
-		requestyModelInfo,
-		togetherModelId,
-		fireworksModelId,
-		previousModeApiProvider,
-		previousModeModelId,
-		previousModeModelInfo,
-		previousModeVsCodeLmModelSelector,
-		previousModeThinkingBudgetTokens,
-		previousModeReasoningEffort,
-		previousModeAwsBedrockCustomSelected,
-		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreModelId,
-		sapAiCoreModelId,
+		// Plan mode configurations
+		planModeApiProvider,
+		planModeApiModelId,
+		planModeThinkingBudgetTokens,
+		planModeReasoningEffort,
+		planModeVsCodeLmModelSelector,
+		planModeAwsBedrockCustomSelected,
+		planModeAwsBedrockCustomModelBaseId,
+		planModeOpenRouterModelId,
+		planModeOpenRouterModelInfo,
+		planModeOpenAiModelId,
+		planModeOpenAiModelInfo,
+		planModeOllamaModelId,
+		planModeLmStudioModelId,
+		planModeLiteLlmModelId,
+		planModeLiteLlmModelInfo,
+		planModeRequestyModelId,
+		planModeRequestyModelInfo,
+		planModeTogetherModelId,
+		planModeFireworksModelId,
+		planModeSapAiCoreModelId,
+		planModeGroqModelId,
+		planModeGroqModelInfo,
+		planModeHuggingFaceModelId,
+		planModeHuggingFaceModelInfo,
+		// Act mode configurations
+		actModeApiProvider,
+		actModeApiModelId,
+		actModeThinkingBudgetTokens,
+		actModeReasoningEffort,
+		actModeVsCodeLmModelSelector,
+		actModeAwsBedrockCustomSelected,
+		actModeAwsBedrockCustomModelBaseId,
+		actModeOpenRouterModelId,
+		actModeOpenRouterModelInfo,
+		actModeOpenAiModelId,
+		actModeOpenAiModelInfo,
+		actModeOllamaModelId,
+		actModeLmStudioModelId,
+		actModeLiteLlmModelId,
+		actModeLiteLlmModelInfo,
+		actModeRequestyModelId,
+		actModeRequestyModelInfo,
+		actModeTogetherModelId,
+		actModeFireworksModelId,
+		actModeSapAiCoreModelId,
+		actModeGroqModelId,
+		actModeGroqModelInfo,
+		actModeHuggingFaceModelId,
+		actModeHuggingFaceModelInfo,
 	] = await Promise.all([
 		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>,
+		getGlobalState(context, "mode") as Promise<Mode | undefined>,
+		// Plan mode configurations
+		getGlobalState(context, "planModeApiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "planModeApiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeThinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "planModeReasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "planModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "planModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "planModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "planModeOpenRouterModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeOpenRouterModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "planModeOpenAiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeOpenAiModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "planModeOllamaModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeLmStudioModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeLiteLlmModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeLiteLlmModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "planModeRequestyModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeRequestyModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "planModeTogetherModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeFireworksModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeGroqModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeGroqModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "planModeHuggingFaceModelId") as Promise<string | undefined>,
+		getGlobalState(context, "planModeHuggingFaceModelInfo") as Promise<ModelInfo | undefined>,
+		// Act mode configurations
+		getGlobalState(context, "actModeApiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "actModeApiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeThinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "actModeReasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "actModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "actModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "actModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "actModeOpenRouterModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeOpenRouterModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "actModeOpenAiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeOpenAiModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "actModeOllamaModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeLmStudioModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeLiteLlmModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeLiteLlmModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "actModeRequestyModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeRequestyModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "actModeTogetherModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeFireworksModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeGroqModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeGroqModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "actModeHuggingFaceModelId") as Promise<string | undefined>,
+		getGlobalState(context, "actModeHuggingFaceModelInfo") as Promise<ModelInfo | undefined>,
 	])
 
 	const processingStart = performance.now()
 	let apiProvider: ApiProvider
-	if (storedApiProvider) {
-		// Use the explicitly stored provider - this respects user's selection
-		apiProvider = storedApiProvider
+	if (planModeApiProvider) {
+		apiProvider = planModeApiProvider
 	} else {
 		// Either new user or legacy user that doesn't have the apiProvider stored in state
 		// (If they're using OpenRouter or Bedrock, then apiProvider state will exist)
@@ -369,7 +408,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		planActSeparateModelsSetting = planActSeparateModelsSettingRaw
 	} else {
 		// default to true for existing users
-		if (storedApiProvider) {
+		if (planModeApiProvider) {
 			planActSeparateModelsSetting = true
 		} else {
 			// default to false for new users
@@ -382,8 +421,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 
 	return {
 		apiConfiguration: {
-			apiProvider,
-			apiModelId,
 			apiKey,
 			openRouterApiKey,
 			clineAccountId,
@@ -399,19 +436,13 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			awsBedrockApiKey,
 			awsUseProfile,
 			awsAuthentication,
-			awsBedrockCustomSelected,
-			awsBedrockCustomModelBaseId,
 			vertexProjectId,
 			vertexRegion,
 			openAiBaseUrl,
 			openAiApiKey,
-			openAiModelId,
-			openAiModelInfo,
 			openAiHeaders: openAiHeaders || {},
-			ollamaModelId,
 			ollamaBaseUrl,
 			ollamaApiOptionsCtxNum,
-			lmStudioModelId,
 			lmStudioBaseUrl,
 			anthropicBaseUrl,
 			geminiApiKey,
@@ -419,29 +450,18 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			openAiNativeApiKey,
 			deepSeekApiKey,
 			requestyApiKey,
-			requestyModelId,
-			requestyModelInfo,
 			togetherApiKey,
-			togetherModelId,
 			qwenApiKey,
 			qwenApiLine,
 			moonshotApiLine,
 			doubaoApiKey,
 			mistralApiKey,
 			azureApiVersion,
-			openRouterModelId,
-			openRouterModelInfo,
 			openRouterProviderSorting,
-			vsCodeLmModelSelector,
-			thinkingBudgetTokens,
-			reasoningEffort,
 			liteLlmBaseUrl,
-			liteLlmModelId,
-			liteLlmModelInfo,
 			liteLlmApiKey,
 			liteLlmUsePromptCache,
 			fireworksApiKey,
-			fireworksModelId,
 			fireworksModelMaxCompletionTokens,
 			fireworksModelMaxTokens,
 			asksageApiKey,
@@ -450,8 +470,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			sambanovaApiKey,
 			cerebrasApiKey,
 			groqApiKey,
-			groqModelId,
-			groqModelInfo,
 			moonshotApiKey,
 			nebiusApiKey,
 			favoritedModelIds,
@@ -461,7 +479,57 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			sapAiCoreBaseUrl,
 			sapAiCoreTokenUrl,
 			sapAiResourceGroup,
-			sapAiCoreModelId,
+			huggingFaceApiKey,
+			// Plan mode configurations
+			planModeApiProvider: planModeApiProvider || apiProvider,
+			planModeApiModelId,
+			planModeThinkingBudgetTokens,
+			planModeReasoningEffort,
+			planModeVsCodeLmModelSelector,
+			planModeAwsBedrockCustomSelected,
+			planModeAwsBedrockCustomModelBaseId,
+			planModeOpenRouterModelId,
+			planModeOpenRouterModelInfo,
+			planModeOpenAiModelId,
+			planModeOpenAiModelInfo,
+			planModeOllamaModelId,
+			planModeLmStudioModelId,
+			planModeLiteLlmModelId,
+			planModeLiteLlmModelInfo,
+			planModeRequestyModelId,
+			planModeRequestyModelInfo,
+			planModeTogetherModelId,
+			planModeFireworksModelId,
+			planModeSapAiCoreModelId,
+			planModeGroqModelId,
+			planModeGroqModelInfo,
+			planModeHuggingFaceModelId,
+			planModeHuggingFaceModelInfo,
+			// Act mode configurations
+			actModeApiProvider: actModeApiProvider || apiProvider,
+			actModeApiModelId,
+			actModeThinkingBudgetTokens,
+			actModeReasoningEffort,
+			actModeVsCodeLmModelSelector,
+			actModeAwsBedrockCustomSelected,
+			actModeAwsBedrockCustomModelBaseId,
+			actModeOpenRouterModelId,
+			actModeOpenRouterModelInfo,
+			actModeOpenAiModelId,
+			actModeOpenAiModelInfo,
+			actModeOllamaModelId,
+			actModeLmStudioModelId,
+			actModeLiteLlmModelId,
+			actModeLiteLlmModelInfo,
+			actModeRequestyModelId,
+			actModeRequestyModelInfo,
+			actModeTogetherModelId,
+			actModeFireworksModelId,
+			actModeSapAiCoreModelId,
+			actModeGroqModelId,
+			actModeGroqModelInfo,
+			actModeHuggingFaceModelId,
+			actModeHuggingFaceModelInfo,
 		},
 		isNewUser: isNewUser ?? true,
 		welcomeViewCompleted,
@@ -477,15 +545,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			mode: currentMode || "act", // Merge mode from global state
 		},
 		userInfo,
-		previousModeApiProvider,
-		previousModeModelId,
-		previousModeModelInfo,
-		previousModeVsCodeLmModelSelector,
-		previousModeThinkingBudgetTokens,
-		previousModeReasoningEffort,
-		previousModeAwsBedrockCustomSelected,
-		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreModelId,
 		mcpMarketplaceEnabled: mcpMarketplaceEnabled,
 		mcpDisplayMode: mcpDisplayMode ?? DEFAULT_MCP_DISPLAY_MODE,
 		mcpResponsesCollapsed: mcpResponsesCollapsed,
@@ -502,8 +561,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 
 export async function updateApiConfiguration(context: vscode.ExtensionContext, apiConfiguration: ApiConfiguration) {
 	const {
-		apiProvider,
-		apiModelId,
 		apiKey,
 		openRouterApiKey,
 		awsAccessKey,
@@ -517,19 +574,13 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		awsProfile,
 		awsUseProfile,
 		awsAuthentication,
-		awsBedrockCustomSelected,
-		awsBedrockCustomModelBaseId,
 		vertexProjectId,
 		vertexRegion,
 		openAiBaseUrl,
 		openAiApiKey,
-		openAiModelId,
-		openAiModelInfo,
 		openAiHeaders,
-		ollamaModelId,
 		ollamaBaseUrl,
 		ollamaApiOptionsCtxNum,
-		lmStudioModelId,
 		lmStudioBaseUrl,
 		anthropicBaseUrl,
 		geminiApiKey,
@@ -537,21 +588,13 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		openAiNativeApiKey,
 		deepSeekApiKey,
 		requestyApiKey,
-		requestyModelId,
-		requestyModelInfo,
 		togetherApiKey,
-		togetherModelId,
 		qwenApiKey,
 		doubaoApiKey,
 		mistralApiKey,
 		azureApiVersion,
-		openRouterModelId,
-		openRouterModelInfo,
 		openRouterProviderSorting,
-		vsCodeLmModelSelector,
 		liteLlmBaseUrl,
-		liteLlmModelId,
-		liteLlmModelInfo,
 		liteLlmApiKey,
 		liteLlmUsePromptCache,
 		qwenApiLine,
@@ -559,19 +602,14 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		asksageApiKey,
 		asksageApiUrl,
 		xaiApiKey,
-		thinkingBudgetTokens,
-		reasoningEffort,
 		clineAccountId,
 		sambanovaApiKey,
 		cerebrasApiKey,
 		groqApiKey,
-		groqModelId,
-		groqModelInfo,
 		moonshotApiKey,
 		nebiusApiKey,
 		favoritedModelIds,
 		fireworksApiKey,
-		fireworksModelId,
 		fireworksModelMaxCompletionTokens,
 		fireworksModelMaxTokens,
 		sapAiCoreClientId,
@@ -579,35 +617,113 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		sapAiCoreBaseUrl,
 		sapAiCoreTokenUrl,
 		sapAiResourceGroup,
-		sapAiCoreModelId,
 		claudeCodePath,
+		huggingFaceApiKey,
+		// Plan mode configurations
+		planModeApiProvider,
+		planModeApiModelId,
+		planModeThinkingBudgetTokens,
+		planModeReasoningEffort,
+		planModeVsCodeLmModelSelector,
+		planModeAwsBedrockCustomSelected,
+		planModeAwsBedrockCustomModelBaseId,
+		planModeOpenRouterModelId,
+		planModeOpenRouterModelInfo,
+		planModeOpenAiModelId,
+		planModeOpenAiModelInfo,
+		planModeOllamaModelId,
+		planModeLmStudioModelId,
+		planModeLiteLlmModelId,
+		planModeLiteLlmModelInfo,
+		planModeRequestyModelId,
+		planModeRequestyModelInfo,
+		planModeTogetherModelId,
+		planModeFireworksModelId,
+		planModeSapAiCoreModelId,
+		planModeGroqModelId,
+		planModeGroqModelInfo,
+		planModeHuggingFaceModelId,
+		planModeHuggingFaceModelInfo,
+		// Act mode configurations
+		actModeApiProvider,
+		actModeApiModelId,
+		actModeThinkingBudgetTokens,
+		actModeReasoningEffort,
+		actModeVsCodeLmModelSelector,
+		actModeAwsBedrockCustomSelected,
+		actModeAwsBedrockCustomModelBaseId,
+		actModeOpenRouterModelId,
+		actModeOpenRouterModelInfo,
+		actModeOpenAiModelId,
+		actModeOpenAiModelInfo,
+		actModeOllamaModelId,
+		actModeLmStudioModelId,
+		actModeLiteLlmModelId,
+		actModeLiteLlmModelInfo,
+		actModeRequestyModelId,
+		actModeRequestyModelInfo,
+		actModeTogetherModelId,
+		actModeFireworksModelId,
+		actModeSapAiCoreModelId,
+		actModeGroqModelId,
+		actModeGroqModelInfo,
+		actModeHuggingFaceModelId,
+		actModeHuggingFaceModelInfo,
 	} = apiConfiguration
 
 	// 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,
-		groqModelId,
-		groqModelInfo,
-		sapAiCoreModelId,
+		// Plan mode configuration updates
+		planModeApiProvider,
+		planModeApiModelId,
+		planModeThinkingBudgetTokens,
+		planModeReasoningEffort,
+		planModeVsCodeLmModelSelector,
+		planModeAwsBedrockCustomSelected,
+		planModeAwsBedrockCustomModelBaseId,
+		planModeOpenRouterModelId,
+		planModeOpenRouterModelInfo,
+		planModeOpenAiModelId,
+		planModeOpenAiModelInfo,
+		planModeOllamaModelId,
+		planModeLmStudioModelId,
+		planModeLiteLlmModelId,
+		planModeLiteLlmModelInfo,
+		planModeRequestyModelId,
+		planModeRequestyModelInfo,
+		planModeTogetherModelId,
+		planModeFireworksModelId,
+		planModeSapAiCoreModelId,
+		planModeGroqModelId,
+		planModeGroqModelInfo,
+		planModeHuggingFaceModelId,
+		planModeHuggingFaceModelInfo,
+
+		// Act mode configuration updates
+		actModeApiProvider,
+		actModeApiModelId,
+		actModeThinkingBudgetTokens,
+		actModeReasoningEffort,
+		actModeVsCodeLmModelSelector,
+		actModeAwsBedrockCustomSelected,
+		actModeAwsBedrockCustomModelBaseId,
+		actModeOpenRouterModelId,
+		actModeOpenRouterModelInfo,
+		actModeOpenAiModelId,
+		actModeOpenAiModelInfo,
+		actModeOllamaModelId,
+		actModeLmStudioModelId,
+		actModeLiteLlmModelId,
+		actModeLiteLlmModelInfo,
+		actModeRequestyModelId,
+		actModeRequestyModelInfo,
+		actModeTogetherModelId,
+		actModeFireworksModelId,
+		actModeSapAiCoreModelId,
+		actModeGroqModelId,
+		actModeGroqModelInfo,
+		actModeHuggingFaceModelId,
+		actModeHuggingFaceModelInfo,
 
 		// Global state updates (27 keys)
 		awsRegion,
@@ -672,6 +788,7 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		nebiusApiKey,
 		sapAiCoreClientId,
 		sapAiCoreClientSecret,
+		huggingFaceApiKey,
 	}
 
 	// Execute batched operations in parallel for maximum performance
@@ -715,6 +832,7 @@ export async function resetGlobalState(context: vscode.ExtensionContext) {
 		"groqApiKey",
 		"moonshotApiKey",
 		"nebiusApiKey",
+		"huggingFaceApiKey",
 	]
 	for (const key of secretKeys) {
 		await storeSecret(context, key, undefined)

src/core/task/ToolExecutor.ts

@@ -54,6 +54,7 @@ import { TaskState } from "./TaskState"
 import { MessageStateHandler } from "./message-state"
 import { AutoApprove } from "./tools/autoApprove"
 import { showNotificationForApprovalIfAutoApprovalEnabled } from "./utils"
+import { ChatSettings } from "@/shared/ChatSettings"
 
 export class ToolExecutor {
 	private autoApprover: AutoApprove
@@ -90,6 +91,7 @@ export class ToolExecutor {
 		private browserSettings: BrowserSettings,
 		private cwd: string,
 		private taskId: string,
+		private chatSettings: ChatSettings,
 
 		// Callbacks to the Task (Entity)
 		private say: (
@@ -634,7 +636,7 @@ export class ToolExecutor {
 						}
 						await this.diffViewProvider.update(newContent, true)
 						await setTimeoutPromise(300) // wait for diff view to update
-						this.diffViewProvider.scrollToFirstDiff()
+						await this.diffViewProvider.scrollToFirstDiff()
 						// showOmissionWarning(this.diffViewProvider.originalContent || "", newContent)
 
 						const completeMessage = JSON.stringify({
@@ -1917,7 +1919,12 @@ 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 getGlobalState(this.context, "apiProvider")} / ${this.api.getModel().id}`
+						const currentMode = this.chatSettings.mode
+						const apiProvider =
+							currentMode === "plan"
+								? await getGlobalState(this.context, "planModeApiProvider")
+								: await getGlobalState(this.context, "actModeApiProvider")
+						const providerAndModel = `${apiProvider} / ${this.api.getModel().id}`
 
 						// Ask user for confirmation
 						const bugReportData = JSON.stringify({