chore: improve LiteLLM model info parsing and add worktrees to gitignore

- Add worktrees/ directory to .gitignore for git worktree support - Enhance LiteLLM model info type definitions with comprehensive tier and thinking config types - Implement robust number parsing utility to handle both number and string values from API - Add support for parsing context window, max tokens, and pricing from multiple sources - Extract pricing information from tiered pricing structures and thinking configs - Add support for cache creation/read costs and prompt caching detection - Improve fallback logic for model capabilities (images, vision, caching) - Remove trailing newline in main.go for consistency This change improves the reliability of LiteLLM model configuration by handling various API response formats and extracting pricing/capability information from multiple possible locations in the response structure.
Set LiteLLM default temperature to 1.0
2026-09-12 17:19:32 +08:00 · 2025-11-04 14:32:57 -08:00 · 2025-11-01 18:57:24 -07:00 · 2025-11-01 15:39:39 -07:00 · 2025-10-31 01:44:19 -07:00 · 2025-10-29 22:39:51 -06:00
165 changed files with 8734 additions and 1411 deletions
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Telemtry change: collect domain of openai compatible endpoints when telemetry is enabled
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Requesty base URL, and API key fixes
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Delete all Auth Tokens when logging out
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Support for <think> tags for models that prefer that over <thinking>
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+This PR introduces a Python gRPC codegen flow analogous to the existing Go flow
@@ -35,3 +35,5 @@ webview-ui/src/services/grpc-client.ts

 # E2E Tests
 test-results
+
+worktrees/
@@ -345,4 +345,4 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 	}

 	return content.String(), nil
-}
+}
@@ -123,7 +123,10 @@ func setCommand() *cobra.Command {
 		Use:     "set <key=value> [key=value...]",
 		Aliases: []string{"s"},
 		Short:   "Set configuration variables",
-		Long:    `Set one or more global configuration variables using key=value format.`,
+		Long:    `Set one or more global configuration variables using key=value format.
+		
+This command merges the provided settings with existing values, preserving
+unspecified fields. Only the fields you explicitly set will be updated.`,
 		Args:    cobra.MinimumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -139,7 +142,7 @@ func setCommand() *cobra.Command {
 				return err
 			}

-			// Update settings
+			// Update settings (server-side merge handles preserving existing values)
 			return configManager.UpdateSettings(ctx, settings, secrets)
 		},
 	}
@@ -1239,16 +1239,17 @@ func (m *Manager) updateMode(stateJson string) {

 // UpdateTaskAutoApprovalAction enables a specific auto-approval action for the current task
 func (m *Manager) UpdateTaskAutoApprovalAction(ctx context.Context, actionKey string) error {
+	boolPtr := func(b bool) *bool { return &b }
+	
 	settings := &cline.Settings{
 		AutoApprovalSettings: &cline.AutoApprovalSettings{
-			Enabled:     true,
-			MaxRequests: 20, // Important: avoid maxRequests=0 bug
-			Actions:     &cline.AutoApprovalActions{},
+			Enabled: boolPtr(true),
+			Actions: &cline.AutoApprovalActions{},
 		},
 	}

 	// Set the specific action to true based on actionKey
-	truePtr := func() *bool { b := true; return &b }()
+	truePtr := boolPtr(true)
 	
 	switch actionKey {
 	case "read_files":
@@ -421,19 +421,19 @@ func setAutoApprovalSettings(settings *cline.AutoApprovalSettings, fields map[st
 			if err != nil {
 				return err
 			}
-			settings.Enabled = val
+			settings.Enabled = boolPtr(val)
 		case "max_requests":
 			val, err := parseInt32(value)
 			if err != nil {
 				return err
 			}
-			settings.MaxRequests = val
+			settings.MaxRequests = int32Ptr(val)
 		case "enable_notifications":
 			val, err := parseBool(value)
 			if err != nil {
 				return err
 			}
-			settings.EnableNotifications = val
+			settings.EnableNotifications = boolPtr(val)
 		case "actions":
 			return fmt.Errorf("auto_approval_settings.actions requires nested dot notation (e.g., auto-approval-settings.actions.read-files=true)")
 		default:
@@ -42,17 +42,17 @@ To open Cline in the right sidebar:
    4. Set the value to `vertical`
    5. Restart Cursor for the changes to take effect
  </Step>
-  <Step title="Open Agent Panel">
-    Click the Cursor cube icon button that opens Cursor's agent (right side view panel)
+  <Step title="Open the AI Pane">
+    Click the Cursor cube icon button (AI Pane) that opens Cursor's agent (right side view panel)
  </Step>
-  <Step title="Drag to Three Dots">
-    Drag the Cline icon directly onto the three dots button - it doesn't work if you just drag it to the top, it has to be the three dots
+  <Step title="Drag Cline to the AI Pane Sidebar">
+    Drag the Cline icon directly into the AI Pane sidebar.
  </Step>
 </Steps>

 <Frame>
 	<img
-		src="https://storage.googleapis.com/cline_public_images/cursor-side-bar.gif"
+		src="https://storage.googleapis.com/cline_public_images/Cursor-sidebar.gif"
 		alt="Cursor Right Sidebar Setup"
 	/>
 </Frame>
@@ -10,7 +10,7 @@
      "license": "MIT",
      "dependencies": {
        "axios": "^1.12.0",
-        "better-sqlite3": "^11.10.0",
+        "better-sqlite3": "^12.4.1",
        "chalk": "5.6.2",
        "cline": "^1.0.1",
        "commander": "^9.4.1",
@@ -211,6 +211,111 @@
        "proxy-from-env": "^1.1.0"
      }
    },
+    "node_modules/b4a": {
+      "version": "1.7.3",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.7.3.tgz",
+      "integrity": "sha512-5Q2mfq2WfGuFp3uS//0s6baOJLMoVduPYVeNmDYxu5OUA1/cBfvr2RIS7vi62LdNj/urk1hfmj867I3qt6uZ7Q==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "react-native-b4a": "*"
+      },
+      "peerDependenciesMeta": {
+        "react-native-b4a": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-events": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.0.tgz",
+      "integrity": "sha512-AOhh6Bg5QmFIXdViHbMc2tLDsBIRxdkIaIddPslJF9Z5De3APBScuqGP2uThXnIpqFrgoxMNC6km7uXNIMLHXA==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "bare-abort-controller": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-abort-controller": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-fs": {
+      "version": "4.4.11",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.4.11.tgz",
+      "integrity": "sha512-Bejmm9zRMvMTRoHS+2adgmXw1ANZnCNx+B5dgZpGwlP1E3x6Yuxea8RToddHUbWtVV0iUMWqsgZr8+jcgUI2SA==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4",
+        "bare-url": "^2.2.2",
+        "fast-fifo": "^1.3.2"
+      },
+      "engines": {
+        "bare": ">=1.16.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+      "integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-stream": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+      "integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "streamx": "^2.21.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*",
+        "bare-events": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        },
+        "bare-events": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-url": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.1.tgz",
+      "integrity": "sha512-v2yl0TnaZTdEnelkKtXZGnotiV6qATBlnNuUMrHl6v9Lmmrh9mw9RYyImPU7/4RahumSwQS1k2oKXcRfXcbjJw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-path": "^3.0.0"
+      }
+    },
    "node_modules/base64-js": {
      "version": "1.5.1",
      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
@@ -231,13 +336,17 @@
      ]
    },
    "node_modules/better-sqlite3": {
-      "version": "11.10.0",
-      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-11.10.0.tgz",
-      "integrity": "sha512-EwhOpyXiOEL/lKzHz9AW1msWFNzGc/z+LzeB3/jnFJpxu+th2yqvzsSWas1v9jgs9+xiXJcD5A8CJxAG2TaghQ==",
+      "version": "12.4.1",
+      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
+      "integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
      "hasInstallScript": true,
+      "license": "MIT",
      "dependencies": {
        "bindings": "^1.5.0",
        "prebuild-install": "^7.1.1"
+      },
+      "engines": {
+        "node": "20.x || 22.x || 23.x || 24.x"
      }
    },
    "node_modules/bindings": {
@@ -305,11 +414,6 @@
        "url": "https://github.com/chalk/chalk?sponsor=1"
      }
    },
-    "node_modules/chownr": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
-      "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="
-    },
    "node_modules/cli-cursor": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
@@ -1450,6 +1554,15 @@
        "node": ">=6"
      }
    },
+    "node_modules/events-universal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+      "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-events": "^2.7.0"
+      }
+    },
    "node_modules/execa": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
@@ -1480,6 +1593,12 @@
        "node": ">=6"
      }
    },
+    "node_modules/fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+      "license": "MIT"
+    },
    "node_modules/file-uri-to-path": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
@@ -1520,11 +1639,6 @@
        "node": ">= 6"
      }
    },
-    "node_modules/fs-constants": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
-      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="
-    },
    "node_modules/function-bind": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -2131,6 +2245,17 @@
      "resolved": "https://registry.npmjs.org/sqlite/-/sqlite-4.2.1.tgz",
      "integrity": "sha512-Tll0Ndvnwkuv5Hn6WIbh26rZiYQORuH1t5m/or9LUpSmDmmyFG89G9fKrSeugMPxwmEIXoVxqTun4LbizTs4uw=="
    },
+    "node_modules/streamx": {
+      "version": "2.23.0",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
+      "integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+      "license": "MIT",
+      "dependencies": {
+        "events-universal": "^1.0.0",
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      }
+    },
    "node_modules/string_decoder": {
      "version": "1.3.0",
      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -2192,29 +2317,37 @@
      }
    },
    "node_modules/tar-fs": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz",
-      "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
+      "integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
+      "license": "MIT",
      "dependencies": {
-        "chownr": "^1.1.1",
-        "mkdirp-classic": "^0.5.2",
        "pump": "^3.0.0",
-        "tar-stream": "^2.1.4"
+        "tar-stream": "^3.1.5"
+      },
+      "optionalDependencies": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0"
      }
    },
    "node_modules/tar-stream": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
-      "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+      "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+      "license": "MIT",
      "dependencies": {
-        "bl": "^4.0.3",
-        "end-of-stream": "^1.4.1",
-        "fs-constants": "^1.0.0",
-        "inherits": "^2.0.3",
-        "readable-stream": "^3.1.1"
-      },
-      "engines": {
-        "node": ">=6"
+        "b4a": "^1.6.4",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "node_modules/text-decoder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.6.4"
      }
    },
    "node_modules/tiktoken": {
@@ -2577,15 +2710,73 @@
        "proxy-from-env": "^1.1.0"
      }
    },
+    "b4a": {
+      "version": "1.7.3",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.7.3.tgz",
+      "integrity": "sha512-5Q2mfq2WfGuFp3uS//0s6baOJLMoVduPYVeNmDYxu5OUA1/cBfvr2RIS7vi62LdNj/urk1hfmj867I3qt6uZ7Q==",
+      "requires": {}
+    },
+    "bare-events": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.0.tgz",
+      "integrity": "sha512-AOhh6Bg5QmFIXdViHbMc2tLDsBIRxdkIaIddPslJF9Z5De3APBScuqGP2uThXnIpqFrgoxMNC6km7uXNIMLHXA==",
+      "requires": {}
+    },
+    "bare-fs": {
+      "version": "4.4.11",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.4.11.tgz",
+      "integrity": "sha512-Bejmm9zRMvMTRoHS+2adgmXw1ANZnCNx+B5dgZpGwlP1E3x6Yuxea8RToddHUbWtVV0iUMWqsgZr8+jcgUI2SA==",
+      "optional": true,
+      "requires": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4",
+        "bare-url": "^2.2.2",
+        "fast-fifo": "^1.3.2"
+      }
+    },
+    "bare-os": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+      "integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
+      "optional": true
+    },
+    "bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "optional": true,
+      "requires": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "bare-stream": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+      "integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
+      "optional": true,
+      "requires": {
+        "streamx": "^2.21.0"
+      }
+    },
+    "bare-url": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.1.tgz",
+      "integrity": "sha512-v2yl0TnaZTdEnelkKtXZGnotiV6qATBlnNuUMrHl6v9Lmmrh9mw9RYyImPU7/4RahumSwQS1k2oKXcRfXcbjJw==",
+      "optional": true,
+      "requires": {
+        "bare-path": "^3.0.0"
+      }
+    },
    "base64-js": {
      "version": "1.5.1",
      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
    },
    "better-sqlite3": {
-      "version": "11.10.0",
-      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-11.10.0.tgz",
-      "integrity": "sha512-EwhOpyXiOEL/lKzHz9AW1msWFNzGc/z+LzeB3/jnFJpxu+th2yqvzsSWas1v9jgs9+xiXJcD5A8CJxAG2TaghQ==",
+      "version": "12.4.1",
+      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.4.1.tgz",
+      "integrity": "sha512-3yVdyZhklTiNrtg+4WqHpJpFDd+WHTg2oM7UcR80GqL05AOV0xEJzc6qNvFYoEtE+hRp1n9MpN6/+4yhlGkDXQ==",
      "requires": {
        "bindings": "^1.5.0",
        "prebuild-install": "^7.1.1"
@@ -2632,11 +2823,6 @@
      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="
    },
-    "chownr": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
-      "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="
-    },
    "cli-cursor": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
@@ -3328,6 +3514,14 @@
      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="
    },
+    "events-universal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+      "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+      "requires": {
+        "bare-events": "^2.7.0"
+      }
+    },
    "execa": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
@@ -3349,6 +3543,11 @@
      "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
      "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="
    },
+    "fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ=="
+    },
    "file-uri-to-path": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
@@ -3371,11 +3570,6 @@
        "mime-types": "^2.1.12"
      }
    },
-    "fs-constants": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
-      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="
-    },
    "function-bind": {
      "version": "1.1.2",
      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -3659,7 +3853,7 @@
        "pump": "^3.0.0",
        "rc": "^1.2.7",
        "simple-get": "^4.0.0",
-        "tar-fs": "^2.0.0",
+        "tar-fs": "^3.1.1",
        "tunnel-agent": "^0.6.0"
      }
    },
@@ -3760,6 +3954,16 @@
      "resolved": "https://registry.npmjs.org/sqlite/-/sqlite-4.2.1.tgz",
      "integrity": "sha512-Tll0Ndvnwkuv5Hn6WIbh26rZiYQORuH1t5m/or9LUpSmDmmyFG89G9fKrSeugMPxwmEIXoVxqTun4LbizTs4uw=="
    },
+    "streamx": {
+      "version": "2.23.0",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
+      "integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+      "requires": {
+        "events-universal": "^1.0.0",
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      }
+    },
    "string_decoder": {
      "version": "1.3.0",
      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -3805,26 +4009,32 @@
      }
    },
    "tar-fs": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz",
-      "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
+      "integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
      "requires": {
-        "chownr": "^1.1.1",
-        "mkdirp-classic": "^0.5.2",
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0",
        "pump": "^3.0.0",
-        "tar-stream": "^2.1.4"
+        "tar-stream": "^3.1.5"
      }
    },
    "tar-stream": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
-      "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+      "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
      "requires": {
-        "bl": "^4.0.3",
-        "end-of-stream": "^1.4.1",
-        "fs-constants": "^1.0.0",
-        "inherits": "^2.0.3",
-        "readable-stream": "^3.1.1"
+        "b4a": "^1.6.4",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "text-decoder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+      "requires": {
+        "b4a": "^1.6.4"
      }
    },
    "tiktoken": {
@@ -3969,5 +4179,8 @@
      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
      "dev": true
    }
+  },
+  "overrides": {
+    "tar-fs": ">=2.1.4"
  }
 }
@@ -1,45 +1,47 @@
 {
-	"name": "cline-evals",
-	"version": "0.1.0",
-	"description": "Evaluation scripts and tools for Cline",
-	"main": "cli/dist/index.js",
-	"scripts": {
-		"build:cli": "cd cli && tsc",
-		"start:cli": "cd cli && node dist/index.js",
-		"dev:cli": "cd cli && ts-node src/index.ts",
-		"diff-eval": "./diff-edits/run_and_open_dashboard.sh",
-		"test": "echo \"Error: no test specified\" && exit 1"
-	},
-	"keywords": [
-		"cline",
-		"evaluation",
-		"benchmark",
-		"diff-edits"
-	],
-	"author": "",
-	"license": "MIT",
-	"dependencies": {
-		"axios": "^1.12.0",
-		"better-sqlite3": "^11.10.0",
-		"chalk": "5.6.2",
-		"dotenv": "^16.5.0",
-		"commander": "^9.4.1",
-		"execa": "^5.1.1",
-		"node-fetch": "^2.7.0",
-		"ora": "^5.4.1",
-		"sqlite": "^4.1.2",
-		"tiktoken": "^1.0.21",
-		"uuid": "^9.0.0",
-		"yargs": "^17.6.2",
-		"cline": "^1.0.1"
-	},
-	"devDependencies": {
-		"@types/better-sqlite3": "^7.6.3",
-		"@types/node": "^18.11.18",
-		"@types/node-fetch": "^2.6.12",
-		"@types/uuid": "^9.0.0",
-		"@types/yargs": "^17.0.19",
-		"ts-node": "^10.9.1",
-		"typescript": "^4.9.4"
-	}
+  "name": "cline-evals",
+  "version": "0.1.0",
+  "description": "Evaluation scripts and tools for Cline",
+  "main": "cli/dist/index.js",
+  "scripts": {
+    "build:cli": "cd cli && tsc",
+    "start:cli": "cd cli && node dist/index.js",
+    "dev:cli": "cd cli && ts-node src/index.ts",
+    "diff-eval": "./diff-edits/run_and_open_dashboard.sh",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cline",
+    "evaluation",
+    "benchmark",
+    "diff-edits"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.12.0",
+    "better-sqlite3": "^12.4.1",
+    "chalk": "5.6.2",
+    "dotenv": "^16.5.0",
+    "commander": "^9.4.1",
+    "execa": "^5.1.1",
+    "node-fetch": "^2.7.0",
+    "ora": "^5.4.1",
+    "sqlite": "^4.1.2",
+    "tiktoken": "^1.0.21",
+    "uuid": "^9.0.0",
+    "yargs": "^17.6.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.3",
+    "@types/node": "^18.11.18",
+    "@types/node-fetch": "^2.6.12",
+    "@types/uuid": "^9.0.0",
+    "@types/yargs": "^17.0.19",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
+  "overrides": {
+    "tar-fs": "^3.1.1"
+  }
 }
@@ -310,6 +310,7 @@
 		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.mjs --production",
 		"protos": "node scripts/build-proto.mjs",
 		"protos-go": "node scripts/build-go-proto.mjs",
+		"protos-python": "node scripts/build-python-proto.mjs",
 		"cli-providers": "node scripts/cli-providers.mjs",
 		"download-ripgrep": "node scripts/download-ripgrep.mjs",
 		"postprotos": "biome format src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --no-errors-on-unmatched",
@@ -329,7 +330,7 @@
 		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
 		"test": "npm-run-all test:unit test:integration",
 		"test:integration": "vscode-test",
-		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha # Use `npm run test:unit --update-snapshots` to rebuild prompt snapshots",
+		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha",
 		"test:coverage": "vscode-test --coverage",
 		"test:sca-server": "npx tsx watch scripts/test-standalone-core-api-server.ts",
 		"test:tp-orchestrator": "npx tsx scripts/testing-platform-orchestrator.ts",
@@ -40,6 +40,8 @@ service AccountService {

  rpc openrouterAuthClicked(EmptyRequest) returns (Empty);

+  rpc requestyAuthClicked(StringRequest) returns (Empty);
+
  // Returns a link the webview can use to redirect back to the user's IDE.
  rpc getRedirectUrl(EmptyRequest) returns (String);
 }
@@ -29,14 +29,18 @@ service ModelsService {
  rpc refreshRequestyModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
  // Subscribe to OpenRouter models updates
  rpc subscribeToOpenRouterModels(EmptyRequest) returns (stream OpenRouterCompatibleModelInfo);
-  // Updates API configuration
+  // Updates API configuration (legacy - uses combined configuration)
  rpc updateApiConfigurationProto(UpdateApiConfigurationRequest) returns (Empty);
+  // Updates API configuration (new - uses separate options and secrets)
+  rpc updateApiConfiguration(UpdateApiConfigurationRequestNew) returns (Empty);
  // Updates API configuration with partial values (only updates fields that are explicitly set)
  rpc updateApiConfigurationPartial(UpdateApiConfigurationPartialRequest) returns (Empty);
  // Refreshes and returns Groq models
  rpc refreshGroqModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
  // Refreshes and returns Baseten models
  rpc refreshBasetenModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns LiteLLM models
+  rpc refreshLiteLlmModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
  // Fetches available models from SAP AI Core
  rpc getSapAiCoreModels(SapAiCoreModelsRequest) returns (SapAiCoreModelsResponse);
  // Fetches available models from OCA
@@ -128,12 +132,177 @@ message SapAiCoreModelsResponse {
  bool orchestration_available = 2;
 }

-// Request for updating API configuration
+// API secrets (credentials, API keys)
+message ModelsApiSecrets {
+  optional string api_key = 1;
+  optional string cline_api_key = 2;
+  optional string lite_llm_api_key = 3;
+  optional string open_router_api_key = 4;
+  optional string aws_access_key = 5;
+  optional string aws_secret_key = 6;
+  optional string aws_session_token = 7;
+  optional string aws_bedrock_api_key = 8;
+  optional string open_ai_api_key = 9;
+  optional string ollama_api_key = 10;
+  optional string gemini_api_key = 11;
+  optional string open_ai_native_api_key = 12;
+  optional string deep_seek_api_key = 13;
+  optional string requesty_api_key = 14;
+  optional string together_api_key = 15;
+  optional string fireworks_api_key = 16;
+  optional string qwen_api_key = 17;
+  optional string doubao_api_key = 18;
+  optional string mistral_api_key = 19;
+  optional string nebius_api_key = 20;
+  optional string asksage_api_key = 21;
+  optional string xai_api_key = 22;
+  optional string sambanova_api_key = 23;
+  optional string cerebras_api_key = 24;
+  optional string sap_ai_core_client_id = 25;
+  optional string sap_ai_core_client_secret = 26;
+  optional string moonshot_api_key = 27;
+  optional string cline_account_id = 28;
+  optional string groq_api_key = 29;
+  optional string hugging_face_api_key = 30;
+  optional string huawei_cloud_maas_api_key = 31;
+  optional string baseten_api_key = 32;
+  optional string zai_api_key = 33;
+  optional string vercel_ai_gateway_api_key = 34;
+  optional string dify_api_key = 35;
+  optional string oca_api_key = 36;
+  optional string oca_refresh_token = 37;
+  optional string minimax_api_key = 38;
+}
+
+// API configuration options (non-secret settings)
+message ModelsApiOptions {
+  // Global configuration fields (not mode-specific)
+  optional string ulid = 1;
+  optional string lite_llm_base_url = 2;
+  optional bool lite_llm_use_prompt_cache = 3;
+  map<string, string> open_ai_headers = 4;
+  optional string anthropic_base_url = 5;
+  optional string open_router_provider_sorting = 6;
+  optional string aws_region = 7;
+  optional bool aws_use_cross_region_inference = 8;
+  optional bool aws_bedrock_use_prompt_cache = 9;
+  optional bool aws_use_profile = 10;
+  optional string aws_profile = 11;
+  optional string aws_bedrock_endpoint = 12;
+  optional string claude_code_path = 13;
+  optional string vertex_project_id = 14;
+  optional string vertex_region = 15;
+  optional string open_ai_base_url = 16;
+  optional string ollama_base_url = 17;
+  optional string ollama_api_options_ctx_num = 18;
+  optional string lm_studio_base_url = 19;
+  optional string gemini_base_url = 20;
+  optional string requesty_base_url = 21;
+  optional int64 fireworks_model_max_completion_tokens = 22;
+  optional int64 fireworks_model_max_tokens = 23;
+  optional string azure_api_version = 24;
+  optional string qwen_api_line = 25;
+  optional string asksage_api_url = 26;
+  optional int64 request_timeout_ms = 27;
+  optional string sap_ai_resource_group = 28;
+  optional string sap_ai_core_token_url = 29;
+  optional string sap_ai_core_base_url = 30;
+  optional bool sap_ai_core_use_orchestration_mode = 31;
+  optional string moonshot_api_line = 32;
+  optional string aws_authentication = 33;
+  optional string zai_api_line = 34;
+  optional string lm_studio_max_tokens = 35;
+  optional string qwen_code_oauth_path = 36;
+  optional string dify_base_url = 37;
+  optional string oca_base_url = 38;
+  optional string oca_mode = 39;
+  optional bool aws_use_global_inference = 40;
+  optional string minimax_api_line = 41;
+
+  // Plan mode configurations
+  optional ApiProvider 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 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_sap_ai_core_deployment_id = 120;
+  optional string plan_mode_groq_model_id = 121;
+  optional OpenRouterModelInfo plan_mode_groq_model_info = 122;
+  optional string plan_mode_hugging_face_model_id = 123;
+  optional OpenRouterModelInfo plan_mode_hugging_face_model_info = 124;
+  optional string plan_mode_huawei_cloud_maas_model_id = 125;
+  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 126;
+  optional string plan_mode_baseten_model_id = 127;
+  optional OpenRouterModelInfo plan_mode_baseten_model_info = 128;
+  optional string plan_mode_vercel_ai_gateway_model_id = 129;
+  optional OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 130;
+  optional string plan_mode_oca_model_id = 131;
+  optional OcaModelInfo plan_mode_oca_model_info = 132;
+
+  // Act mode configurations
+  optional ApiProvider 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 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_sap_ai_core_deployment_id = 220;
+  optional string act_mode_groq_model_id = 221;
+  optional OpenRouterModelInfo act_mode_groq_model_info = 222;
+  optional string act_mode_hugging_face_model_id = 223;
+  optional OpenRouterModelInfo act_mode_hugging_face_model_info = 224;
+  optional string act_mode_huawei_cloud_maas_model_id = 225;
+  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 226;
+  optional string act_mode_baseten_model_id = 227;
+  optional OpenRouterModelInfo act_mode_baseten_model_info = 228;
+  optional string act_mode_vercel_ai_gateway_model_id = 229;
+  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 230;
+  optional string act_mode_oca_model_id = 231;
+  optional OcaModelInfo act_mode_oca_model_info = 232;
+}
+
+// Request for updating API configuration (legacy - uses combined configuration)
 message UpdateApiConfigurationRequest {
  Metadata metadata = 1;
  ModelsApiConfiguration api_configuration = 2;
 }

+// Request for updating API configuration (new - uses separate options and secrets)
+message UpdateApiConfigurationRequestNew {
+  Metadata metadata = 1;
+  ModelsApiOptions options = 2;
+  ModelsApiSecrets secrets = 3;
+}
+
 // Request for partially updating API configuration using FieldMask
 // Only fields specified in update_mask will be updated from api_configuration
 message UpdateApiConfigurationPartialRequest {
@@ -46,10 +46,10 @@ message AutoApprovalActions {
 // Auto approval settings for task execution
 message AutoApprovalSettings {
  int32 version = 1;
-  bool enabled = 2;
+  optional bool enabled = 2;
  AutoApprovalActions actions = 3;
-  int32 max_requests = 4;
-  bool enable_notifications = 5;
+  optional int32 max_requests = 4;
+  optional bool enable_notifications = 5;
  repeated string favorites = 6;
 }

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+
+import chalk from "chalk"
+import { execSync } from "child_process"
+import * as fs from "fs/promises"
+import { globby } from "globby"
+import * as path from "path"
+import { fileURLToPath } from "url"
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
+const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
+const PROTO_DIR = path.join(ROOT_DIR, "proto")
+const PY_OUT_DIR = path.join(ROOT_DIR, "src", "generated", "grpc-python")
+const PY_CLIENT_DIR = path.join(PY_OUT_DIR, "client")
+
+function hasCommand(cmd) {
+	try {
+		if (process.platform === "win32") {
+			execSync(`where ${cmd}`, { stdio: "pipe" })
+		} else {
+			execSync(`which ${cmd}`, { stdio: "pipe" })
+		}
+		return true
+	} catch {
+		return false
+	}
+}
+
+function resolvePython() {
+	// Allow override via env.PYTHON pointing to a specific interpreter
+	const envPy = process.env.PYTHON
+	if (envPy) {
+		try {
+			execSync(`"${envPy}" --version`, { stdio: "pipe" })
+			return envPy
+		} catch {
+			console.warn(chalk.yellow(`Warning: PYTHON override "${envPy}" is not usable, falling back to discovery.`))
+		}
+	}
+	const candidates = ["python3", "python"]
+	for (const c of candidates) {
+		if (hasCommand(c)) {
+			try {
+				execSync(`${c} --version`, { stdio: "pipe" })
+				return c
+			} catch {
+				// continue
+			}
+		}
+	}
+	return null
+}
+
+function checkGrpcTools(pythonExe) {
+	try {
+		execSync(`"${pythonExe}" -c "import grpc_tools"`, { stdio: "pipe" })
+		return true
+	} catch {
+		return false
+	}
+}
+
+async function ensureDir(dir) {
+	await fs.mkdir(dir, { recursive: true })
+}
+
+async function ensureInitPy(dir) {
+	try {
+		await fs.writeFile(path.join(dir, "__init__.py"), "", { flag: "wx" })
+	} catch {
+		// exists
+	}
+}
+
+/**
+ * Parse proto files to extract service names with their source file and package.
+ * Returns array of:
+ * { serviceName: string, serviceKey: string, protoPackage: "cline"|"host", moduleBase: string }
+ */
+async function parseServicesWithFiles(protoDir, protoFiles) {
+	const services = []
+	for (const relPath of protoFiles) {
+		const full = path.join(protoDir, relPath)
+		const content = await fs.readFile(full, "utf8")
+		const pkg = relPath.startsWith("host/") ? "host" : "cline"
+		const moduleBase = path.basename(relPath, ".proto")
+		const serviceRe = /service\s+(\w+Service)\s*\{([\s\S]*?)\}/g
+		for (const m of content.matchAll(serviceRe)) {
+			const serviceName = m[1] // e.g., TaskService
+			const serviceKey = serviceName.replace(/Service$/, "").toLowerCase() // task
+			const body = m[2]
+			const methodRe = /rpc\s+(\w+)\s*\((stream\s)?([\w.]+)\)\s*returns\s*\((stream\s)?([\w.]+)\)/g
+			const methods = []
+			for (const mm of body.matchAll(methodRe)) {
+				methods.push({
+					name: mm[1],
+					isRequestStreaming: !!mm[2],
+					requestType: mm[3],
+					isResponseStreaming: !!mm[4],
+					responseType: mm[5],
+				})
+			}
+			services.push({ serviceName, serviceKey, protoPackage: pkg, moduleBase, methods })
+		}
+	}
+	return services
+}
+
+function upperFirst(s) {
+	return s.length ? s[0].toUpperCase() + s.slice(1) : s
+}
+
+async function generateConnectionPy(outDir) {
+	const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+import grpc
+import time
+from typing import Optional
+
+class ConnectionManager:
+    def __init__(self, address: str, timeout: float = 30.0):
+        self.address = address
+        self.timeout = timeout
+        self._channel: Optional[grpc.Channel] = None
+
+    def connect(self) -> None:
+        if self._channel is not None:
+            return
+        self._channel = grpc.insecure_channel(self.address)
+        # Wait for channel to be ready within timeout
+        grpc.channel_ready_future(self._channel).result(timeout=self.timeout)
+
+    def disconnect(self) -> None:
+        if self._channel is not None:
+            self._channel.close()
+            self._channel = None
+
+    @property
+    def channel(self) -> Optional[grpc.Channel]:
+        return self._channel
+
+    def is_connected(self) -> bool:
+        return self._channel is not None
+`
+	await fs.mkdir(outDir, { recursive: true })
+	await fs.writeFile(path.join(outDir, "connection.py"), content)
+	await ensureInitPy(outDir)
+}
+
+async function generateClineClientPy(outDir, services) {
+	// Import per-service wrapper clients
+	const importLines = []
+	const seen = new Set()
+	for (const s of services) {
+		const fileBase = `${s.serviceKey}_client`
+		const className = `${s.serviceName.replace(/Service$/, "")}Client`
+		const importKey = `${fileBase}:${className}`
+		if (!seen.has(importKey)) {
+			importLines.push(`from .services.${fileBase} import ${className}`)
+			seen.add(importKey)
+		}
+	}
+
+	// Build wrapper initializations on connect (like Go New<Service>Client)
+	const initLines = services.map((s) => {
+		const shortName = s.serviceName.replace(/Service$/, "") // Task
+		const className = `${shortName}Client`
+		return `        self.${shortName} = ${className}(self._conn.channel)`
+	})
+
+	// Build attribute resets on disconnect
+	const nilLines = services.map((s) => {
+		const shortName = s.serviceName.replace(/Service$/, "")
+		return `        self.${shortName} = None`
+	})
+
+	const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+from typing import Optional
+
+import grpc
+from .connection import ConnectionManager
+${importLines.join("\n")}
+
+class ClineClient:
+    """
+    Unified Python client analogous to src/generated/grpc-go/client/ClineClient.
+
+    Usage:
+        client = ClineClient("localhost:17611")
+        client.connect()
+        # Call wrappers, e.g.: client.Task.SomeRpc(...)
+        client.disconnect()
+    """
+
+    def __init__(self, address: str, timeout: float = 30.0):
+        self._conn = ConnectionManager(address, timeout=timeout)
+        self._connected = False
+
+${services.map((s) => `        self.${s.serviceName.replace(/Service$/, "")}: Optional[object] = None`).join("\n")}
+
+    def connect(self) -> None:
+        if self._connected:
+            return
+        self._conn.connect()
+${initLines.join("\n")}
+        self._connected = True
+
+    def disconnect(self) -> None:
+        if not self._connected:
+            return
+        self._conn.disconnect()
+${nilLines.join("\n")}
+        self._connected = False
+
+    def is_connected(self) -> bool:
+        return self._connected
+
+    @property
+    def channel(self) -> Optional[grpc.Channel]:
+        return self._conn.channel
+`
+	const clientDir = outDir
+	await fs.mkdir(clientDir, { recursive: true })
+	await fs.writeFile(path.join(clientDir, "cline_client.py"), content)
+}
+
+async function generatePythonClient(protoDir, pyOutDir, clientDir, protoFiles) {
+	// Ensure package structure for client
+	await fs.mkdir(clientDir, { recursive: true })
+	await ensureInitPy(pyOutDir)
+	await ensureInitPy(clientDir)
+
+	const services = await parseServicesWithFiles(protoDir, protoFiles)
+
+	// connection.py
+	await generateConnectionPy(clientDir)
+
+	// services/ per-service wrappers (mirror Go client/services)
+	const servicesDir = path.join(clientDir, "services")
+	await fs.mkdir(servicesDir, { recursive: true })
+	await ensureInitPy(servicesDir)
+	await generateServiceClientsPy(servicesDir, services)
+
+	// cline_client.py (unified that composes service wrappers)
+	await generateClineClientPy(clientDir, services)
+}
+
+async function generateServiceClientsPy(outDir, services) {
+	await fs.mkdir(outDir, { recursive: true })
+	await ensureInitPy(outDir)
+
+	for (const s of services) {
+		const shortName = s.serviceName.replace(/Service$/, "") // Task
+		const className = `${shortName}Client`
+		const fileName = `${s.serviceKey}_client.py`
+
+		const aliasPb2 = `${s.protoPackage}_${s.moduleBase}_pb2`
+		const aliasGrpc = `${s.protoPackage}_${s.moduleBase}_pb2_grpc`
+
+		const methodLines = s.methods
+			.map((m) => {
+				const reqTypeName = m.requestType.split(".").pop()
+				const respTypeName = m.responseType.split(".").pop()
+				if (m.isResponseStreaming) {
+					return `
+    def ${m.name}(self, req):
+        """
+        Server-streaming RPC.
+        :param req: ${aliasPb2}.${reqTypeName}
+        :return: iterator of ${aliasPb2}.${respTypeName}
+        """
+        return self._stub.${m.name}(req)`
+				} else {
+					return `
+    def ${m.name}(self, req):
+        """
+        Unary RPC.
+        :param req: ${aliasPb2}.${reqTypeName}
+        :return: ${aliasPb2}.${respTypeName}
+        """
+        return self._stub.${m.name}(req)`
+				}
+			})
+			.join("\n")
+
+		const content = `# AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+# Generated by scripts/build-python-proto.mjs
+
+import grpc
+from ${s.protoPackage} import ${s.moduleBase}_pb2 as ${aliasPb2}
+from ${s.protoPackage} import ${s.moduleBase}_pb2_grpc as ${aliasGrpc}
+
+class ${className}:
+    def __init__(self, channel: grpc.Channel):
+        self._stub = ${aliasGrpc}.${s.serviceName}Stub(channel)
+${methodLines}
+`
+		await fs.writeFile(path.join(outDir, fileName), content)
+	}
+}
+
+async function generatePyproject(outDir) {
+	const content = `[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cline-grpc-python"
+version = "0.1.0"
+description = "Generated Python gRPC stubs and client wrappers for Cline protos"
+license = { text: "Apache-2.0" }
+requires-python = ">=3.9"
+dependencies = [
+  "grpcio>=1.56.0",
+  "protobuf>=4.21.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+`
+	await fs.writeFile(path.join(outDir, "pyproject.toml"), content)
+}
+
+async function main() {
+	console.log(chalk.cyan("Starting Python protobuf code generation..."))
+
+	// Verify proto dir exists
+	try {
+		const stat = await fs.stat(PROTO_DIR)
+		if (!stat.isDirectory()) {
+			console.error(chalk.red(`Proto directory is not a folder: ${PROTO_DIR}`))
+			process.exit(1)
+		}
+	} catch {
+		console.error(chalk.red(`Proto directory not found: ${PROTO_DIR}`))
+		process.exit(1)
+	}
+
+	// Resolve Python
+	const python = resolvePython()
+	if (!python) {
+		console.error(
+			chalk.red("Python not found on PATH. Please install Python 3 and ensure it is available (python3 or python)."),
+		)
+		process.exit(1)
+	}
+	console.log(chalk.green(`✓ Using Python executable: ${python}`))
+
+	// Check grpcio-tools
+	if (!checkGrpcTools(python)) {
+		console.error(chalk.red("Missing dependency: grpcio-tools"))
+		console.log(chalk.yellow("Install with:"))
+		console.log(chalk.yellow(`  ${python} -m pip install grpcio-tools --user --break-system-packages`))
+		process.exit(1)
+	}
+	console.log(chalk.green("✓ grpcio-tools available"))
+
+	// Discover proto files
+	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR })
+	if (!protoFiles.length) {
+		console.error(chalk.red("No .proto files found under ./proto"))
+		process.exit(1)
+	}
+	console.log(chalk.cyan(`Found ${protoFiles.length} proto files`))
+
+	// Ensure output directory
+	await ensureDir(PY_OUT_DIR)
+
+	// Build and run protoc command via grpc_tools
+	const quoted = (s) => `"${s}"`
+	const pythonCmd = quoted(python)
+	const cmd =
+		`${pythonCmd} -m grpc_tools.protoc ` +
+		`-I ${quoted(PROTO_DIR)} ` +
+		`--python_out=${quoted(PY_OUT_DIR)} ` +
+		`--grpc_python_out=${quoted(PY_OUT_DIR)} ` +
+		protoFiles.map((f) => quoted(f)).join(" ")
+
+	try {
+		console.log(chalk.cyan(`Generating Python code into ${PY_OUT_DIR}...`))
+		execSync(cmd, { cwd: ROOT_DIR, stdio: "inherit", env: process.env })
+	} catch (error) {
+		console.error(chalk.red("Error generating Python code:"), error?.message || error)
+		process.exit(1)
+	}
+
+	// Ensure package structure (__init__.py) for imports
+	await ensureInitPy(PY_OUT_DIR)
+	try {
+		const clineDir = path.join(PY_OUT_DIR, "cline")
+		const hostDir = path.join(PY_OUT_DIR, "host")
+		// These may or may not exist depending on which protos are present
+		await fs
+			.stat(clineDir)
+			.then(() => ensureInitPy(clineDir))
+			.catch(() => {})
+		await fs
+			.stat(hostDir)
+			.then(() => ensureInitPy(hostDir))
+			.catch(() => {})
+	} catch {
+		// ignore
+	}
+
+	// Generate Python client structure analogous to src/generated/grpc-go/client
+	await generatePythonClient(PROTO_DIR, PY_OUT_DIR, PY_CLIENT_DIR, protoFiles)
+
+	// Generate a minimal pyproject.toml in the generated output so it can be pip-installed if desired
+	await generatePyproject(PY_OUT_DIR)
+
+	console.log(chalk.green("✓ Python protobuf and client code generation completed successfully!"))
+	console.log(chalk.cyan(`Output directory: ${PY_OUT_DIR}`))
+	console.log(chalk.cyan(`Client directory: ${PY_CLIENT_DIR}`))
+	console.log(chalk.cyan(`PyProject: ${path.join(PY_OUT_DIR, "pyproject.toml")}`))
+	console.log(chalk.gray("Note: To import, add the output dir to your PYTHONPATH or pip install -e src/generated/grpc-python"))
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	main().catch((err) => {
+		console.error(chalk.red("Unexpected error in build-python-proto.mjs:"), err)
+		process.exit(1)
+	})
+}
@@ -14,6 +14,7 @@ import { HostProvider } from "@/hosts/host-provider"
 import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
 import { StateManager } from "./core/storage/StateManager"
 import { ExtensionRegistryInfo } from "./registry"
+import { BannerService } from "./services/banner/BannerService"
 import { audioRecordingService } from "./services/dictation/AudioRecordingService"
 import { ErrorService } from "./services/error"
 import { featureFlagsService } from "./services/feature-flags"
@@ -71,6 +72,20 @@ export async function initialize(context: vscode.ExtensionContext): Promise<Webv

 	await showVersionUpdateAnnouncement(context)

+	// Initialize banner service
+	BannerService.initialize(webview.controller)
+	BannerService.get()
+		.fetchActiveBanners()
+		.then((banners) => {
+			if (banners.length > 0) {
+				Logger.log(`BannerService: ${banners.length} active banner(s) fetched.`)
+				// Banners are now cached and can be accessed by the frontend when needed
+			}
+		})
+		.catch((error) => {
+			Logger.error("BannerService: Failed to fetch banners on startup", error)
+		})
+
 	telemetryService.captureExtensionActivated()

 	return webview
@@ -1,6 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ApiConfiguration, ModelInfo, QwenApiRegions } from "@shared/api"
 import { Mode } from "@shared/storage/types"
+import { ClineTool } from "@/shared/tools"
 import { AnthropicHandler } from "./providers/anthropic"
 import { AskSageHandler } from "./providers/asksage"
 import { BasetenHandler } from "./providers/baseten"
@@ -45,7 +46,7 @@ export type CommonApiHandlerOptions = {
 }

 export interface ApiHandler {
-	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
+	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: ClineTool[]): ApiStream
 	getModel(): ApiHandlerModel
 	getApiStreamUsage?(): Promise<ApiStreamUsageChunk | undefined>
 }
@@ -1,6 +1,8 @@
 import { Anthropic } from "@anthropic-ai/sdk"
+import { Tool as AnthropicTool, MessageParam } from "@anthropic-ai/sdk/resources/index"
 import { Stream as AnthropicStream } from "@anthropic-ai/sdk/streaming"
 import { AnthropicModelId, anthropicDefaultModelId, anthropicModels, CLAUDE_SONNET_1M_SUFFIX, ModelInfo } from "@shared/api"
+import { ClineTool } from "@/shared/tools"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { ApiStream } from "../transform/stream"
@@ -38,7 +40,7 @@ export class AnthropicHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: ClineTool[]): ApiStream {
 		const client = this.ensureClient()

 		const model = this.getModel()
@@ -48,6 +50,9 @@ export class AnthropicHandler implements ApiHandler {
 		const enable1mContextWindow = model.id.endsWith(CLAUDE_SONNET_1M_SUFFIX)

 		const budget_tokens = this.options.thinkingBudgetTokens || 0
+
+		// Tools are available only when native tools are enabled.
+		const nativeToolsOn = tools?.length && tools?.length > 0
 		const reasoningOn = !!(
 			(modelId.includes("3-7") || modelId.includes("4-") || modelId.includes("4-5")) &&
 			budget_tokens !== 0
@@ -68,12 +73,45 @@ export class AnthropicHandler implements ApiHandler {
 				/*
 				The latest message will be the new user message, one before will be the assistant message from a previous request, and the user message before that will be a previously cached user message. So we need to mark the latest user message as ephemeral to cache it for the next request, and mark the second to last user message as ephemeral to let the server know the last message to retrieve from the cache for the current request..
 				*/
-				const userMsgIndices = messages.reduce(
-					(acc, msg, index) => (msg.role === "user" ? [...acc, index] : acc),
-					[] as number[],
-				)
+				const userMsgIndices = messages.reduce((acc, msg, index) => {
+					if (msg.role === "user") {
+						acc.push(index)
+					}
+					return acc
+				}, [] as number[])
 				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
 				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
+
+				const anthropicMessages: Array<MessageParam> = messages.map((message, index) => {
+					if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
+						return {
+							...message,
+							content:
+								typeof message.content === "string"
+									? [
+											{
+												type: "text",
+												text: message.content,
+												cache_control: {
+													type: "ephemeral",
+												},
+											},
+										]
+									: message.content.map((content, contentIndex) =>
+											contentIndex === message.content.length - 1
+												? {
+														...content,
+														cache_control: {
+															type: "ephemeral",
+														},
+													}
+												: content,
+										),
+						}
+					}
+					return message
+				})
+
 				stream = await client.messages.create(
 					{
 						model: modelId,
@@ -89,39 +127,16 @@ export class AnthropicHandler implements ApiHandler {
 								cache_control: { type: "ephemeral" },
 							},
 						], // setting cache breakpoint for system prompt so new tasks can reuse it
-						messages: messages.map((message, index) => {
-							if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
-								return {
-									...message,
-									content:
-										typeof message.content === "string"
-											? [
-													{
-														type: "text",
-														text: message.content,
-														cache_control: {
-															type: "ephemeral",
-														},
-													},
-												]
-											: message.content.map((content, contentIndex) =>
-													contentIndex === message.content.length - 1
-														? {
-																...content,
-																cache_control: {
-																	type: "ephemeral",
-																},
-															}
-														: content,
-												),
-								}
-							}
-							return message
-						}),
+						messages: anthropicMessages,
 						// tools, // cache breakpoints go from tools > system > messages, and since tools dont change, we can just set the breakpoint at the end of system (this avoids having to set a breakpoint at the end of tools which by itself does not meet min requirements for haiku caching)
-						// tool_choice: { type: "auto" },
-						// tools: tools,
 						stream: true,
+						tools: nativeToolsOn ? (tools as AnthropicTool[]) : undefined,
+						// tool_choice options:
+						// - none: disables tool use, even if tools are provided. Claude will not call any tools.
+						// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
+						// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
+						// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
+						tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
 					},
 					(() => {
 						// 1m context window beta header
@@ -154,6 +169,7 @@ export class AnthropicHandler implements ApiHandler {
 		}

 		let thinkingDeltaAccumulator = ""
+		const lastStartedToolCall = { id: "", name: "", arguments: "" }

 		for await (const chunk of stream) {
 			switch (chunk?.type) {
@@ -208,6 +224,14 @@ export class AnthropicHandler implements ApiHandler {
 								data: chunk.content_block.data,
 							}
 							break
+						case "tool_use":
+							if (chunk.content_block.id && chunk.content_block.name) {
+								// Convert Anthropic tool_use to OpenAI-compatible format
+								lastStartedToolCall.id = chunk.content_block.id
+								lastStartedToolCall.name = chunk.content_block.name
+								lastStartedToolCall.arguments = ""
+							}
+							break
 						case "text":
 							// we may receive multiple text blocks, in which case just insert a line break between them
 							if (chunk.index > 0) {
@@ -250,9 +274,30 @@ export class AnthropicHandler implements ApiHandler {
 								text: chunk.delta.text,
 							}
 							break
+						case "input_json_delta":
+							if (lastStartedToolCall.id && lastStartedToolCall.name && chunk.delta.partial_json) {
+								// 	// Convert Anthropic tool_use to OpenAI-compatible format
+								yield {
+									type: "tool_calls",
+									tool_call: {
+										...lastStartedToolCall,
+										function: {
+											...lastStartedToolCall,
+											id: lastStartedToolCall.id,
+											name: lastStartedToolCall.name,
+											arguments: chunk.delta.partial_json,
+										},
+									},
+								}
+							}
+							break
 					}
 					break
+
 				case "content_block_stop":
+					lastStartedToolCall.id = ""
+					lastStartedToolCall.name = ""
+					lastStartedToolCall.arguments = ""
 					break
 			}
 		}
@@ -3,6 +3,7 @@ import { ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from
 import { shouldSkipReasoningForModel } from "@utils/model-utils"
 import axios from "axios"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ClineEnv } from "@/config"
 import { ClineAccountService } from "@/services/account/ClineAccountService"
 import { AuthService } from "@/services/auth/AuthService"
@@ -12,6 +13,7 @@ import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
+import { ToolCallProcessor } from "../transform/tool-call-processor"
 import { OpenRouterErrorResponse } from "./types"

 interface ClineHandlerOptions extends CommonApiHandlerOptions {
@@ -93,7 +95,7 @@ export class ClineHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		try {
 			const client = await this.ensureClient()

@@ -110,8 +112,11 @@ export class ClineHandler implements ApiHandler {
 				this.options.reasoningEffort,
 				this.options.thinkingBudgetTokens,
 				this.options.openRouterProviderSorting,
+				tools,
 			)

+			const toolCallProcessor = new ToolCallProcessor()
+
 			for await (const chunk of stream) {
 				// openrouter returns an error object instead of the openai sdk throwing an error
 				if ("error" in chunk) {
@@ -150,6 +155,10 @@ export class ClineHandler implements ApiHandler {
 					}
 				}

+				if (delta?.tool_calls) {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				}
+
 				// Reasoning tokens are returned separately from the content
 				// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
 				if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
@@ -194,8 +203,7 @@ export class ClineHandler implements ApiHandler {
 						cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
 						inputTokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
 						outputTokens: chunk.usage.completion_tokens || 0,
-						// @ts-ignore-next-line
-						totalCost: totalCost,
+						totalCost,
 					}
 					didOutputUsage = true
 				}
@@ -2,11 +2,13 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { DeepSeekModelId, deepSeekDefaultModelId, deepSeekModels, ModelInfo } from "@shared/api"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface DeepSeekHandlerOptions extends CommonApiHandlerOptions {
 	deepSeekApiKey?: string
@@ -71,7 +73,7 @@ export class DeepSeekHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()

@@ -94,8 +96,11 @@ export class DeepSeekHandler implements ApiHandler {
 			stream_options: { include_usage: true },
 			// Only set temperature for non-reasoner models
 			...(model.id === "deepseek-reasoner" ? {} : { temperature: 0 }),
+			...getOpenAIToolParams(tools),
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -105,6 +110,10 @@ export class DeepSeekHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
@@ -1,6 +1,14 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
 // Restore GenerateContentConfig import and add GenerateContentResponseUsageMetadata
-import { ApiError, type GenerateContentConfig, type GenerateContentResponseUsageMetadata, GoogleGenAI, Part } from "@google/genai"
+import {
+	ApiError,
+	FunctionCallingConfigMode,
+	type GenerateContentConfig,
+	type GenerateContentResponseUsageMetadata,
+	GoogleGenAI,
+	FunctionDeclaration as GoogleTool,
+	Part,
+} from "@google/genai"
 import { GeminiModelId, geminiDefaultModelId, geminiModels, ModelInfo } from "@shared/api"
 import { telemetryService } from "@/services/telemetry"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
@@ -102,7 +110,7 @@ export class GeminiHandler implements ApiHandler {
 		baseDelay: 2000,
 		maxDelay: 15000,
 	})
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: GoogleTool[]): ApiStream {
 		const client = this.ensureClient()
 		const { id: modelId, info } = this.getModel()
 		const contents = messages.map(convertAnthropicMessageToGemini)
@@ -140,6 +148,16 @@ export class GeminiHandler implements ApiHandler {
 		let thoughtsTokenCount = 0 // Initialize thought token counts
 		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined

+		if (tools?.length) {
+			requestConfig.tools = [{ functionDeclarations: tools }]
+			requestConfig.toolConfig = {
+				// Force the model to call 'any' function.
+				functionCallingConfig: {
+					mode: FunctionCallingConfigMode.ANY,
+				},
+			}
+		}
+
 		try {
 			const result = await client.models.generateContentStream({
 				model: modelId,
@@ -189,6 +207,24 @@ export class GeminiHandler implements ApiHandler {
 					}
 				}

+				if (tools && chunk.functionCalls && chunk.functionCalls?.length > 0) {
+					for (const functionCall of chunk.functionCalls) {
+						if (functionCall.args) {
+							console.log("[GeminiHandler] tool call received:", functionCall)
+							yield {
+								type: "tool_calls",
+								tool_call: {
+									function: {
+										id: functionCall.id || functionCall.name,
+										name: functionCall.name,
+										arguments: JSON.stringify(functionCall.args),
+									},
+								},
+							}
+						}
+					}
+				}
+
 				if (chunk.usageMetadata) {
 					lastUsageMetadata = chunk.usageMetadata
 					promptTokens = lastUsageMetadata.promptTokenCount ?? promptTokens
@@ -2,10 +2,12 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { GroqModelId, groqDefaultModelId, groqModels, ModelInfo } from "@shared/api"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface GroqHandlerOptions extends CommonApiHandlerOptions {
 	groqApiKey?: string
@@ -188,7 +190,7 @@ export class GroqHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
 		const modelFamily = this.detectModelFamily(model.id)
@@ -213,6 +215,7 @@ export class GroqHandler implements ApiHandler {
 			stream: true,
 			stream_options: { include_usage: true },
 			temperature,
+			...getOpenAIToolParams(tools),
 		}

 		// Add any special parameters for specific model families
@@ -220,6 +223,7 @@ export class GroqHandler implements ApiHandler {
 			Object.assign(requestParams, modelFamily.specialParams)
 		}

+		const toolCallProcessor = new ToolCallProcessor()
 		const stream = await client.chat.completions.create(requestParams)

 		for await (const chunk of stream) {
@@ -235,6 +239,10 @@ export class GroqHandler implements ApiHandler {
 				continue
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			// Handle content field - trust the parsed output from Groq
 			if (delta?.content) {
 				yield {
@@ -1,10 +1,12 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { HuaweiCloudMaasModelId, huaweiCloudMaasDefaultModelId, huaweiCloudMaasModels, ModelInfo } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from ".."
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface HuaweiCloudMaaSHandlerOptions extends CommonApiHandlerOptions {
 	huaweiCloudMaasApiKey?: string
@@ -58,7 +60,7 @@ export class HuaweiCloudMaaSHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -72,12 +74,15 @@ export class HuaweiCloudMaaSHandler implements ApiHandler {
 			stream: true,
 			stream_options: { include_usage: true },
 			temperature: 0,
+			...getOpenAIToolParams(tools),
 		})

 		let reasoning: string | null = null
 		let didOutputUsage: boolean = false
 		let finalUsage: any = null

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta

@@ -93,6 +98,10 @@ export class HuaweiCloudMaaSHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			// Handle reasoning output
 			if (reasoning || (delta && "reasoning_content" in delta && delta.reasoning_content)) {
 				const reasoningContent = delta?.content || ((delta as any)?.reasoning_content as string | undefined) || ""
@@ -2,10 +2,12 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { HuggingFaceModelId, huggingFaceDefaultModelId, huggingFaceModels, ModelInfo } from "@shared/api"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface HuggingFaceHandlerOptions extends CommonApiHandlerOptions {
 	huggingFaceApiKey?: string
@@ -65,7 +67,7 @@ export class HuggingFaceHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		try {
 			const client = this.ensureClient()
 			const model = this.getModel()
@@ -82,8 +84,10 @@ export class HuggingFaceHandler implements ApiHandler {
 				stream: true,
 				stream_options: { include_usage: true },
 				temperature: 0,
+				...getOpenAIToolParams(tools),
 			}

+			const toolCallProcessor = new ToolCallProcessor()
 			const stream = (await client.chat.completions.create(requestParams)) as any

 			let _chunkCount = 0
@@ -101,6 +105,10 @@ export class HuggingFaceHandler implements ApiHandler {
 					}
 				}

+				if (delta?.tool_calls) {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				}
+
 				if (chunk.usage) {
 					yield* this.yieldUsage(model.info, chunk.usage)
 				}
@@ -1,10 +1,12 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
 import { type ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import type { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import type { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface LmStudioHandlerOptions extends CommonApiHandlerOptions {
 	lmStudioBaseUrl?: string
@@ -36,7 +38,7 @@ export class LmStudioHandler implements ApiHandler {
 	}

 	@withRetry({ retryAllErrors: true })
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },
@@ -50,7 +52,11 @@ export class LmStudioHandler implements ApiHandler {
 				stream: true,
 				stream_options: { include_usage: true },
 				max_completion_tokens: this.options.lmStudioMaxTokens ? Number(this.options.lmStudioMaxTokens) : undefined,
+				...getOpenAIToolParams(tools),
 			})
+
+			const toolCallProcessor = new ToolCallProcessor()
+
 			for await (const chunk of stream) {
 				const choice = chunk.choices[0]
 				const delta = choice?.delta
@@ -66,6 +72,11 @@ export class LmStudioHandler implements ApiHandler {
 						reasoning: (delta.reasoning_content as string | undefined) || "",
 					}
 				}
+
+				if (delta?.tool_calls) {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				}
+
 				if (chunk.usage) {
 					yield {
 						type: "usage",
@@ -1,10 +1,12 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
+import type { ChatCompletionTool } from "openai/resources/chat/completions"
 import { MinimaxModelId, ModelInfo, minimaxDefaultModelId, minimaxModels } from "@/shared/api"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface MinimaxHandlerOptions extends CommonApiHandlerOptions {
 	minimaxApiKey?: string
@@ -36,7 +38,11 @@ export class MinimaxHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		tools?: ChatCompletionTool[],
+	): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()

@@ -51,8 +57,11 @@ export class MinimaxHandler implements ApiHandler {
 			max_tokens: model.info.maxTokens,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -69,6 +78,10 @@ export class MinimaxHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (chunk.usage) {
 				yield {
 					type: "usage",
@@ -1,6 +1,8 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { Mistral } from "@mistralai/mistralai"
+import { Tool as MistralTool } from "@mistralai/mistralai/models/components/tool"
 import { MistralModelId, ModelInfo, mistralDefaultModelId, mistralModels } from "@shared/api"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToMistralMessages } from "../transform/mistral-format"
@@ -36,7 +38,7 @@ export class MistralHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const stream = await client.chat
 			.stream({
@@ -45,6 +47,8 @@ export class MistralHandler implements ApiHandler {
 				temperature: 0,
 				messages: [{ role: "system", content: systemPrompt }, ...convertToMistralMessages(messages)],
 				stream: true,
+				tools: tools?.length ? (tools as MistralTool[]) : undefined,
+				toolChoice: tools?.length ? "any" : undefined,
 			})
 			.catch((err) => {
 				// The Mistal SDK uses statusCode instead of status
@@ -58,7 +62,20 @@ export class MistralHandler implements ApiHandler {

 		for await (const chunk of stream) {
 			const delta = chunk.data.choices[0]?.delta
-			if (delta?.content) {
+			if (delta.toolCalls) {
+				for (const toolCall of delta.toolCalls) {
+					yield {
+						type: "tool_calls",
+						tool_call: {
+							function: {
+								id: toolCall.id,
+								name: toolCall.function.name,
+								arguments: JSON.stringify(toolCall.function.arguments),
+							},
+						},
+					}
+				}
+			} else if (delta?.content) {
 				let content: string = ""
 				if (typeof delta.content === "string") {
 					content = delta.content
@@ -1,10 +1,12 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ModelInfo, MoonshotModelId, moonshotDefaultModelId, moonshotModels } from "@/shared/api"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface MoonshotHandlerOptions extends CommonApiHandlerOptions {
 	moonshotApiKey?: string
@@ -36,7 +38,7 @@ export class MoonshotHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()

@@ -52,7 +54,11 @@ export class MoonshotHandler implements ApiHandler {
 			max_tokens: model.info.maxTokens,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})
+
+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -62,6 +68,10 @@ export class MoonshotHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
@@ -1,11 +1,13 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { type ModelInfo, type NebiusModelId, nebiusDefaultModelId, nebiusModels } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface NebiusHandlerOptions extends CommonApiHandlerOptions {
 	nebiusApiKey?: string
@@ -35,7 +37,7 @@ export class NebiusHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()

@@ -49,7 +51,9 @@ export class NebiusHandler implements ApiHandler {
 			temperature: 0,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})
+		const toolCallProcessor = new ToolCallProcessor()
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -59,6 +63,10 @@ export class NebiusHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
@@ -2,6 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { LiteLLMModelInfo, liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults } from "@shared/api"
 import OpenAI, { APIError, OpenAIError } from "openai"
 import type { FinalRequestOptions, Headers as OpenAIHeaders } from "openai/core"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
 import {
 	DEFAULT_EXTERNAL_OCA_BASE_URL,
@@ -14,6 +15,7 @@ import { ApiHandler, type CommonApiHandlerOptions } from ".."
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 export interface OcaHandlerOptions extends CommonApiHandlerOptions {
 	ocaBaseUrl?: string
@@ -135,7 +137,7 @@ export class OcaHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const formattedMessages = convertToOpenAiMessages(messages)
 		const systemMessage: OpenAI.Chat.ChatCompletionSystemMessageParam = {
@@ -187,6 +189,8 @@ export class OcaHandler implements ApiHandler {
 			return message
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		const stream = await client.chat.completions.create({
 			model: this.options.ocaModelId || liteLlmDefaultModelId,
 			messages: [enhancedSystemMessage, ...enhancedMessages],
@@ -198,6 +202,7 @@ export class OcaHandler implements ApiHandler {
 			...(thinkingConfig && { thinking: thinkingConfig }), // Add thinking configuration when applicable
 			...(this.options.taskId && {
 				litellm_session_id: `cline-${this.options.taskId}`,
+				...getOpenAIToolParams(tools),
 			}), // Add session ID for LiteLLM tracking
 		})

@@ -228,6 +233,10 @@ export class OcaHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			// Handle token usage information
 			if (chunk.usage) {
 				const totalCost =
@@ -2,11 +2,12 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, OpenAiNativeModelId, openAiNativeDefaultModelId, openAiNativeModels } from "@shared/api"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
-import type { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
+import type { ChatCompletionReasoningEffort, ChatCompletionTool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface OpenAiNativeHandlerOptions extends CommonApiHandlerOptions {
 	openAiNativeApiKey?: string
@@ -56,9 +57,14 @@ export class OpenAiNativeHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		tools?: ChatCompletionTool[],
+	): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
+		const toolCallProcessor = new ToolCallProcessor()

 		switch (model.id) {
 			case "o1":
@@ -114,6 +120,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 					stream: true,
 					stream_options: { include_usage: true },
 					reasoning_effort: (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium",
+					...getOpenAIToolParams(tools),
 				})

 				for await (const chunk of stream) {
@@ -124,8 +131,17 @@ export class OpenAiNativeHandler implements ApiHandler {
 							text: delta.content,
 						}
 					}
+
+					if (delta?.tool_calls) {
+						try {
+							yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+						} catch (error) {
+							console.error("Error processing tool call delta:", error, delta.tool_calls)
+						}
+					}
+
 					if (chunk.usage) {
-						// Only last chunk contains usage
+						// Only last chunk contains usage - stream is ending
 						yield* this.yieldUsage(model.info, chunk.usage)
 					}
 				}
@@ -138,6 +154,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 					messages: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 					stream: true,
 					stream_options: { include_usage: true },
+					...getOpenAIToolParams(tools),
 				})

 				for await (const chunk of stream) {
@@ -148,8 +165,13 @@ export class OpenAiNativeHandler implements ApiHandler {
 							text: delta.content,
 						}
 					}
+
+					if (delta?.tool_calls) {
+						yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+					}
+
 					if (chunk.usage) {
-						// Only last chunk contains usage
+						// Only last chunk contains usage - stream is ending
 						yield* this.yieldUsage(model.info, chunk.usage)
 					}
 				}
@@ -1,12 +1,13 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { azureOpenAiDefaultApiVersion, ModelInfo, OpenAiCompatibleModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
 import OpenAI, { AzureOpenAI } from "openai"
-import type { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
+import type { ChatCompletionReasoningEffort, ChatCompletionTool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface OpenAiHandlerOptions extends CommonApiHandlerOptions {
 	openAiApiKey?: string
@@ -61,16 +62,17 @@ export class OpenAiHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		tools?: ChatCompletionTool[],
+	): ApiStream {
 		const client = this.ensureClient()
 		const modelId = this.options.openAiModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
 		const isR1FormatRequired = this.options.openAiModelInfo?.isR1FormatRequired ?? false
 		const isReasoningModelFamily =
-			modelId.includes("o1") ||
-			modelId.includes("o3") ||
-			modelId.includes("o4") ||
-			(modelId.includes("gpt-5") && !modelId.includes("chat"))
+			["o1", "o3", "o4", "gpt-5"].some((prefix) => modelId.includes(prefix)) && !modelId.includes("chat")

 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },
@@ -104,7 +106,11 @@ export class OpenAiHandler implements ApiHandler {
 			reasoning_effort: reasoningEffort,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})
+
+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -121,12 +127,15 @@ export class OpenAiHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (chunk.usage) {
 				yield {
 					type: "usage",
 					inputTokens: chunk.usage.prompt_tokens || 0,
 					outputTokens: chunk.usage.completion_tokens || 0,
-					// @ts-ignore-next-line
 					cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
 					// @ts-ignore-next-line
 					cacheWriteTokens: chunk.usage.prompt_cache_miss_tokens || 0,
@@ -4,10 +4,12 @@ import { ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from
 import { shouldSkipReasoningForModel } from "@utils/model-utils"
 import axios from "axios"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
+import { ToolCallProcessor } from "../transform/tool-call-processor"
 import { OpenRouterErrorResponse } from "./types"

 interface OpenRouterHandlerOptions extends CommonApiHandlerOptions {
@@ -50,7 +52,7 @@ export class OpenRouterHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		this.lastGenerationId = undefined

@@ -62,9 +64,11 @@ export class OpenRouterHandler implements ApiHandler {
 			this.options.reasoningEffort,
 			this.options.thinkingBudgetTokens,
 			this.options.openRouterProviderSorting,
+			tools,
 		)

 		let didOutputUsage: boolean = false
+		const toolCallProcessor = new ToolCallProcessor()

 		for await (const chunk of stream) {
 			// openrouter returns an error object instead of the openai sdk throwing an error
@@ -112,6 +116,10 @@ export class OpenRouterHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			// Reasoning tokens are returned separately from the content
 			// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
 			if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
@@ -2,12 +2,14 @@ import { promises as fs } from "node:fs"
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, QwenCodeModelId, qwenCodeDefaultModelId, qwenCodeModels } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import * as os from "os"
 import * as path from "path"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 // --- Constants for Qwen OAuth2 ---
 const QWEN_OAUTH_BASE_URL = "https://chat.qwen.ai"
@@ -174,7 +176,7 @@ export class QwenCodeHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		await this.ensureAuthenticated()
 		const client = this.ensureClient()
 		const model = this.getModel()
@@ -193,10 +195,12 @@ export class QwenCodeHandler implements ApiHandler {
 			stream: true,
 			stream_options: { include_usage: true },
 			max_completion_tokens: model.info.maxTokens,
+			...getOpenAIToolParams(tools),
 		}

 		const stream = await this.callApiWithRetry(() => client.chat.completions.create(requestOptions))

+		const toolCallProcessor = new ToolCallProcessor()
 		let fullContent = ""

 		for await (const apiChunk of stream) {
@@ -240,6 +244,10 @@ export class QwenCodeHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			// Handle reasoning content (o1-style)
 			if ("reasoning_content" in delta && delta.reasoning_content) {
 				yield {
@@ -10,11 +10,13 @@ import {
 	QwenApiRegions,
 } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface QwenHandlerOptions extends CommonApiHandlerOptions {
 	qwenApiKey?: string
@@ -77,7 +79,7 @@ export class QwenHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
 		const isDeepseekReasoner = model.id.includes("deepseek-r1")
@@ -112,8 +114,11 @@ export class QwenHandler implements ApiHandler {
 			stream_options: { include_usage: true },
 			temperature,
 			...thinkingArgs,
+			...getOpenAIToolParams(tools),
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -123,6 +128,14 @@ export class QwenHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				try {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				} catch (error) {
+					console.error("Error processing tool call delta:", error, delta.tool_calls)
+				}
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
@@ -1,11 +1,13 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, SambanovaModelId, sambanovaDefaultModelId, sambanovaModels } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface SambanovaHandlerOptions extends CommonApiHandlerOptions {
 	sambanovaApiKey?: string
@@ -38,7 +40,7 @@ export class SambanovaHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()

@@ -53,12 +55,14 @@ export class SambanovaHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}

+		const toolCallProcessor = new ToolCallProcessor()
 		const stream = await client.chat.completions.create({
 			model: this.getModel().id,
 			messages: openAiMessages,
 			temperature: 0,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})

 		for await (const chunk of stream) {
@@ -70,6 +74,10 @@ export class SambanovaHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (chunk.usage) {
 				yield {
 					type: "usage",
@@ -0,0 +1,77 @@
+import { ModelInfo } from "@shared/api"
+import axios, { AxiosError } from "axios"
+
+export interface FetchOpenAiCompatibleModelsOptions {
+	baseUrl: string
+	headers?: Record<string, string | undefined>
+	transform?: (model: any) => Partial<ModelInfo>
+}
+
+/**
+ * Normalizes a base URL to ensure it ends with /v1
+ */
+export function normalizeOpenAiCompatibleBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.trim().replace(/\/+$/, "")
+	if (trimmed.endsWith("/v1")) {
+		return trimmed
+	}
+	return `${trimmed}/v1`
+}
+
+/**
+ * Fetches models from an OpenAI-compatible /v1/models endpoint and maps them to ModelInfo objects.
+ */
+export async function fetchOpenAiCompatibleModels({
+	baseUrl,
+	headers = {},
+	transform,
+}: FetchOpenAiCompatibleModelsOptions): Promise<Record<string, ModelInfo>> {
+	const normalizedBaseUrl = normalizeOpenAiCompatibleBaseUrl(baseUrl || "http://localhost:4000")
+	const url = `${normalizedBaseUrl}/models`
+
+	try {
+		const response = await axios.get(url, {
+			headers: Object.fromEntries(Object.entries(headers).filter(([_, value]) => Boolean(value))),
+			timeout: 15000,
+		})
+
+		const rawModels = Array.isArray(response.data?.data) ? response.data.data : []
+
+		const models: Record<string, ModelInfo> = {}
+		for (const rawModel of rawModels) {
+			if (!rawModel || typeof rawModel.id !== "string") {
+				continue
+			}
+
+			const transformed = transform ? transform(rawModel) : {}
+			models[rawModel.id] = {
+				supportsPromptCache: false,
+				description:
+					transformed.description ??
+					rawModel.description ??
+					(rawModel.owned_by ? `Provided by ${rawModel.owned_by}` : undefined),
+				maxTokens: transformed.maxTokens,
+				contextWindow: transformed.contextWindow,
+				supportsImages: transformed.supportsImages,
+				inputPrice: transformed.inputPrice,
+				outputPrice: transformed.outputPrice,
+				cacheWritesPrice: transformed.cacheWritesPrice,
+				cacheReadsPrice: transformed.cacheReadsPrice,
+				thinkingConfig: transformed.thinkingConfig,
+				tiers: transformed.tiers,
+				supportsGlobalEndpoint: transformed.supportsGlobalEndpoint,
+			}
+		}
+
+		return models
+	} catch (error) {
+		if (axios.isAxiosError(error)) {
+			const axiosError = error as AxiosError
+			throw new Error(
+				`Failed to fetch models from ${url}: ${axiosError.response?.status} ${axiosError.response?.statusText || axiosError.message}`,
+			)
+		}
+
+		throw error
+	}
+}
@@ -1,11 +1,13 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToR1Format } from "../transform/r1-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface TogetherHandlerOptions extends CommonApiHandlerOptions {
 	togetherApiKey?: string
@@ -38,7 +40,7 @@ export class TogetherHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const modelId = this.options.togetherModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
@@ -58,7 +60,9 @@ export class TogetherHandler implements ApiHandler {
 			temperature: 0,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})
+		const toolCallProcessor = new ToolCallProcessor()
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -68,6 +72,10 @@ export class TogetherHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				yield {
 					type: "reasoning",
@@ -1,9 +1,11 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, vercelAiGatewayDefaultModelId, vercelAiGatewayDefaultModelInfo } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../index"
 import { withRetry } from "../retry"
 import { ApiStream } from "../transform/stream"
+import { ToolCallProcessor } from "../transform/tool-call-processor"
 import { createVercelAIGatewayStream } from "../transform/vercel-ai-gateway-stream"

 interface VercelAIGatewayHandlerOptions extends CommonApiHandlerOptions {
@@ -42,15 +44,23 @@ export class VercelAIGatewayHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const modelId = this.getModel().id
 		const modelInfo = this.getModel().info

 		try {
-			const stream = await createVercelAIGatewayStream(client, systemPrompt, messages, { id: modelId, info: modelInfo })
+			const stream = await createVercelAIGatewayStream(
+				client,
+				systemPrompt,
+				messages,
+				{ id: modelId, info: modelInfo },
+				tools,
+			)
 			let didOutputUsage: boolean = false

+			const toolCallProcessor = new ToolCallProcessor()
+
 			for await (const chunk of stream) {
 				const delta = chunk.choices[0]?.delta
 				if (delta?.content) {
@@ -60,6 +70,10 @@ export class VercelAIGatewayHandler implements ApiHandler {
 					}
 				}

+				if (delta?.tool_calls) {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				}
+
 				if (!didOutputUsage && chunk.usage) {
 					const inputTokens = chunk.usage.prompt_tokens || 0
 					const outputTokens =
@@ -1,6 +1,9 @@
 import { Anthropic } from "@anthropic-ai/sdk"
+import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk"
+import { FunctionDeclaration as GoogleTool } from "@google/genai"
 import { ModelInfo, VertexModelId, vertexDefaultModelId, vertexModels } from "@shared/api"
+import { ClineTool } from "@/shared/tools"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { ApiStream } from "../transform/stream"
@@ -63,14 +66,14 @@ export class VertexHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: ClineTool[]): ApiStream {
 		const model = this.getModel()
 		const modelId = model.id

 		// For Gemini models, use the GeminiHandler
 		if (!modelId.includes("claude")) {
 			const geminiHandler = this.ensureGeminiHandler()
-			yield* geminiHandler.createMessage(systemPrompt, messages)
+			yield* geminiHandler.createMessage(systemPrompt, messages, tools as GoogleTool[])
 			return
 		}

@@ -160,6 +163,12 @@ export class VertexHandler implements ApiHandler {
 							}
 						}),
 						stream: true,
+						tools: tools?.length ? (tools as AnthropicTool[]) : undefined,
+						// tool_choice options:
+						// - none: disables tool use, even if tools are provided. Claude will not call any tools.
+						// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
+						// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
+						tool_choice: tools ? { type: "any" } : undefined,
 					},
 					{
 						headers: {},
@@ -191,11 +200,19 @@ export class VertexHandler implements ApiHandler {
 								: message.content,
 					})),
 					stream: true,
+					tools: tools?.length ? (tools as AnthropicTool[]) : undefined,
+					// tool_choice options:
+					// - none: disables tool use, even if tools are provided. Claude will not call any tools.
+					// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
+					// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
+					tool_choice: tools ? { type: "any" } : undefined,
 				})
 				break
 			}
 		}

+		const lastStartedToolCall = { id: "", name: "", arguments: "" }
+
 		for await (const chunk of stream) {
 			switch (chunk?.type) {
 				case "message_start":
@@ -233,6 +250,14 @@ export class VertexHandler implements ApiHandler {
 								reasoning: "[Redacted thinking block]",
 							}
 							break
+						case "tool_use":
+							if (chunk.content_block.id && chunk.content_block.name) {
+								// Convert Anthropic tool_use to OpenAI-compatible format
+								lastStartedToolCall.id = chunk.content_block.id
+								lastStartedToolCall.name = chunk.content_block.name
+								lastStartedToolCall.arguments = ""
+							}
+							break
 						case "text":
 							if (chunk.index > 0) {
 								yield {
@@ -255,6 +280,22 @@ export class VertexHandler implements ApiHandler {
 								reasoning: chunk.delta.thinking,
 							}
 							break
+						case "input_json_delta":
+							if (lastStartedToolCall.id && lastStartedToolCall.name && chunk.delta.partial_json) {
+								// 	// Convert Anthropic tool_use to OpenAI-compatible format
+								yield {
+									type: "tool_calls",
+									tool_call: {
+										...lastStartedToolCall,
+										function: {
+											id: lastStartedToolCall.id,
+											name: lastStartedToolCall.name,
+											arguments: chunk.delta.partial_json,
+										},
+									},
+								}
+							}
+							break
 						case "text_delta":
 							yield {
 								type: "text",
@@ -264,6 +305,9 @@ export class VertexHandler implements ApiHandler {
 					}
 					break
 				case "content_block_stop":
+					lastStartedToolCall.id = ""
+					lastStartedToolCall.name = ""
+					lastStartedToolCall.arguments = ""
 					break
 			}
 		}
@@ -2,11 +2,13 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo, XAIModelId, xaiDefaultModelId, xaiModels } from "@shared/api"
 import { shouldSkipReasoningForModel } from "@utils/model-utils"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface XAIHandlerOptions extends CommonApiHandlerOptions {
 	xaiApiKey?: string
@@ -40,7 +42,7 @@ export class XAIHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const modelId = this.getModel().id
 		// ensure reasoning effort is either "low" or "high" for grok-3-mini
@@ -59,8 +61,11 @@ export class XAIHandler implements ApiHandler {
 			stream: true,
 			stream_options: { include_usage: true },
 			reasoning_effort: reasoningEffort,
+			...getOpenAIToolParams(tools),
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -70,6 +75,10 @@ export class XAIHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
 				// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
 				if (!shouldSkipReasoningForModel(modelId)) {
@@ -9,11 +9,13 @@ import {
 	mainlandZAiModels,
 } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { version as extensionVersion } from "../../../../package.json"
 import { ApiHandler, CommonApiHandlerOptions } from ".."
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
+import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"

 interface ZAiHandlerOptions extends CommonApiHandlerOptions {
 	zaiApiLine?: string
@@ -72,7 +74,7 @@ export class ZAiHandler implements ApiHandler {
 	}

 	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[], tools?: OpenAITool[]): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -85,8 +87,11 @@ export class ZAiHandler implements ApiHandler {
 			messages: openAiMessages,
 			stream: true,
 			stream_options: { include_usage: true },
+			...getOpenAIToolParams(tools),
 		})

+		const toolCallProcessor = new ToolCallProcessor()
+
 		for await (const chunk of stream) {
 			const delta = chunk.choices[0]?.delta
 			if (delta?.content) {
@@ -96,6 +101,10 @@ export class ZAiHandler implements ApiHandler {
 				}
 			}

+			if (delta?.tool_calls) {
+				yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+			}
+
 			if (chunk.usage) {
 				yield {
 					type: "usage",
@@ -0,0 +1,19 @@
+import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
+import { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
+
+/**
+ * Converts an OpenAI ChatCompletionTool into an Anthropic Tool definition
+ */
+export function openAIToolToAnthropic(openAITool: OpenAITool): AnthropicTool {
+	const func = openAITool.function
+
+	return {
+		name: func.name,
+		description: func.description || "",
+		input_schema: {
+			type: "object",
+			properties: func.parameters?.properties || {},
+			required: func.parameters?.required || [],
+		},
+	}
+}
@@ -19,6 +19,22 @@ export function convertAnthropicContentToGemini(content: string | Anthropic.Cont
 						mimeType: block.source.media_type,
 					},
 				}
+			case "tool_use":
+				return {
+					functionCall: {
+						name: block.name,
+						args: block.input as Record<string, unknown>,
+					},
+				}
+			case "tool_result":
+				return {
+					functionResponse: {
+						name: block.tool_use_id,
+						response: {
+							result: block.content,
+						},
+					},
+				}
 			default:
 				throw new Error(`Unsupported content block type: ${block.type}`)
 		}
@@ -45,7 +45,7 @@ export function convertToOpenAiMessages(

 					if (typeof toolMessage.content === "string") {
 						content = toolMessage.content
-					} else {
+					} else if (Array.isArray(toolMessage.content)) {
 						content =
 							toolMessage.content
 								?.map((part) => {
@@ -56,6 +56,9 @@ export function convertToOpenAiMessages(
 									return part.text
 								})
 								.join("\n") ?? ""
+					} else {
+						// Handle undefined content
+						content = ""
 					}
 					openAiMessages.push({
 						role: "tool",
@@ -70,15 +73,15 @@ export function convertToOpenAiMessages(
 				// Therefore we need to send these images after the tool result messages
 				// NOTE: it's actually okay to have multiple user messages in a row, the model will treat them as a continuation of the same input (this way works better than combining them into one message, since the tool result specifically mentions (see following user message for image)
 				// UPDATE v2.0: we don't use tools anymore, but if we did it's important to note that the openrouter prompt caching mechanism requires one user message at a time, so we would need to add these images to the user content array instead.
-				// if (toolResultImages.length > 0) {
-				// 	openAiMessages.push({
-				// 		role: "user",
-				// 		content: toolResultImages.map((part) => ({
-				// 			type: "image_url",
-				// 			image_url: { url: `data:${part.source.media_type};base64,${part.source.data}` },
-				// 		})),
-				// 	})
-				// }
+				if (toolResultImages.length > 0) {
+					openAiMessages.push({
+						role: "user",
+						content: toolResultImages.map((part) => ({
+							type: "image_url",
+							image_url: { url: `data:${part.source.media_type};base64,${part.source.data}` },
+						})),
+					})
+				}

 				// Process non-tool messages
 				if (nonToolMessages.length > 0) {
@@ -157,7 +160,7 @@ export function convertToOpenAiMessages(
 					role: "assistant",
 					content,
 					// Cannot be an empty array. API expects an array with minimum length 1, and will respond with an error if it's empty
-					tool_calls: tool_calls.length > 0 ? tool_calls : undefined,
+					tool_calls: tool_calls?.length > 0 ? tool_calls : undefined,
 					// @ts-ignore-next-line
 					reasoning_details: reasoningDetails.length > 0 ? consolidateReasoningDetails(reasoningDetails) : undefined,
 				})
@@ -272,6 +275,9 @@ function consolidateReasoningDetails(reasoningDetails: ReasoningDetail[]): Reaso
 	return consolidated
 }

+// Unique name to use to filter out tool call that cannot be parsed correctly
+const UNIQUE_ERROR_TOOL_NAME = "_cline_error_unknown_function_"
+
 // Convert OpenAI response to Anthropic format
 export function convertToAnthropicMessage(completion: OpenAI.Chat.Completions.ChatCompletion): Anthropic.Messages.Message {
 	const openAiMessage = completion.choices[0].message
@@ -308,24 +314,32 @@ export function convertToAnthropicMessage(completion: OpenAI.Chat.Completions.Ch
 			cache_read_input_tokens: null,
 		},
 	}
-
-	if (openAiMessage.tool_calls && openAiMessage.tool_calls.length > 0) {
-		anthropicMessage.content.push(
-			...openAiMessage.tool_calls.map((toolCall): Anthropic.ToolUseBlock => {
-				let parsedInput = {}
-				try {
-					parsedInput = JSON.parse(toolCall.function.arguments || "{}")
-				} catch (error) {
-					console.error("Failed to parse tool arguments:", error)
-				}
-				return {
-					type: "tool_use",
-					id: toolCall.id,
-					name: toolCall.function.name,
-					input: parsedInput,
-				}
-			}),
-		)
+	try {
+		if (openAiMessage?.tool_calls?.length) {
+			anthropicMessage.content.push(
+				...openAiMessage.tool_calls
+					.map((toolCall): Anthropic.ToolUseBlock => {
+						const parsedName = toolCall.type === "function" && toolCall.function.name
+						let parsedInput = toolCall.function.arguments
+						try {
+							parsedInput = JSON.parse(toolCall.function.arguments || "{}")
+						} catch (error) {
+							console.error("Failed to parse tool arguments:", error)
+						}
+						return {
+							type: "tool_use",
+							id: toolCall.id,
+							name: parsedName || UNIQUE_ERROR_TOOL_NAME,
+							input: parsedInput,
+						}
+					})
+					// Filter out any tool uses with the UNIQUE_ERROR_TOOL_NAME, which indicates a parsing error
+					.filter((toolUse) => toolUse.name !== UNIQUE_ERROR_TOOL_NAME),
+			)
+		}
+	} catch (error) {
+		console.error("Failed to process tool calls:", error)
 	}
+
 	return anthropicMessage
 }
@@ -7,8 +7,10 @@ import {
 	openRouterClaudeSonnet451mModelId,
 } from "@shared/api"
 import OpenAI from "openai"
+import { ChatCompletionTool } from "openai/resources/chat/completions"
 import { convertToOpenAiMessages } from "./openai-format"
 import { convertToR1Format } from "./r1-format"
+import { getOpenAIToolParams } from "./tool-call-processor"

 export async function createOpenRouterStream(
 	client: OpenAI,
@@ -18,6 +20,7 @@ export async function createOpenRouterStream(
 	reasoningEffort?: string,
 	thinkingBudgetTokens?: number,
 	openRouterProviderSorting?: string,
+	tools?: Array<ChatCompletionTool>,
 ) {
 	// Convert Anthropic messages to OpenAI format
 	let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -185,6 +188,7 @@ export async function createOpenRouterStream(
 		...(openRouterProviderSorting && !providerPreferences ? { provider: { sort: openRouterProviderSorting } } : {}),
 		...(providerPreferences ? { provider: providerPreferences } : {}),
 		...(isClaudeSonnet1m ? { provider: { order: ["anthropic", "google-vertex/global"], allow_fallbacks: false } } : {}),
+		...getOpenAIToolParams(tools),
 	})

 	return stream
@@ -6,6 +6,7 @@ export type ApiStreamChunk =
 	| ApiStreamAnthropicThinkingChunk
 	| ApiStreamAnthropicRedactedThinkingChunk
 	| ApiStreamUsageChunk
+	| ApiStreamToolCallsChunk

 export interface ApiStreamTextChunk {
 	type: "text"
@@ -42,3 +43,18 @@ export interface ApiStreamUsageChunk {
 	thoughtsTokenCount?: number // openrouter
 	totalCost?: number // openrouter
 }
+
+export interface ApiStreamToolCallsChunk {
+	type: "tool_calls"
+	tool_call: ApiStreamToolCall
+}
+
+export interface ApiStreamToolCall {
+	call_id?: string // The call / request ID associated with this tool call
+	// Information about the tool being called
+	function: {
+		id?: string // The tool call ID
+		name?: string
+		arguments?: any
+	}
+}
@@ -0,0 +1,87 @@
+import type {
+	ChatCompletionChunk,
+	ChatCompletionToolChoiceOption,
+	ChatCompletionTool as OpenAITool,
+} from "openai/resources/chat/completions"
+import { Logger } from "@/services/logging/Logger"
+import type { ApiStreamToolCallsChunk } from "./stream"
+
+/**
+ * Helper class to process tool call deltas from OpenAI-compatible streaming responses.
+ * Handles accumulating tool call ID and name across multiple delta chunks,
+ * and yields properly formatted tool call chunks when arguments are received.
+ */
+export class ToolCallProcessor {
+	private lastToolCall: { id: string; name: string }
+
+	constructor() {
+		this.lastToolCall = { id: "", name: "" }
+	}
+
+	/**
+	 * Process tool call deltas from a chunk and yield formatted tool call chunks.
+	 * @param toolCallDeltas - Array of tool call deltas from the chunk
+	 * @yields Formatted tool call chunks ready to be yielded in the API stream
+	 */
+	*processToolCallDeltas(
+		toolCallDeltas: ChatCompletionChunk.Choice.Delta.ToolCall[] | undefined,
+	): Generator<ApiStreamToolCallsChunk> {
+		if (!toolCallDeltas) {
+			return
+		}
+
+		for (const toolCallDelta of toolCallDeltas) {
+			// Accumulate the tool call ID if present
+			if (toolCallDelta.id) {
+				this.lastToolCall.id = toolCallDelta.id
+			}
+
+			// Accumulate the function name if present
+			if (toolCallDelta.function?.name) {
+				Logger.debug(`[ToolCallProcessor] Native Tool Called: ${toolCallDelta.function.name}`)
+				this.lastToolCall.name = toolCallDelta.function.name
+			}
+
+			// Only yield when we have all required fields: id, name, and arguments
+			if (this.lastToolCall.id && this.lastToolCall.name && toolCallDelta.function?.arguments) {
+				yield {
+					type: "tool_calls",
+					tool_call: {
+						...toolCallDelta,
+						function: {
+							...toolCallDelta.function,
+							id: this.lastToolCall.id,
+							name: this.lastToolCall.name,
+						},
+					},
+				}
+			}
+		}
+	}
+
+	/**
+	 * Reset the internal state. Call this when starting a new message.
+	 */
+	reset(): void {
+		this.lastToolCall = { id: "", name: "" }
+	}
+
+	/**
+	 * Get the current accumulated tool call state (useful for debugging).
+	 */
+	getState(): { id: string; name: string } {
+		return { ...this.lastToolCall }
+	}
+}
+
+export function getOpenAIToolParams(tools?: OpenAITool[]) {
+	return tools?.length
+		? {
+				tools,
+				tool_choice: tools ? ("auto" as ChatCompletionToolChoiceOption) : undefined,
+				parallel_tool_calls: tools ? true : undefined,
+			}
+		: {
+				tools: undefined,
+			}
+}
@@ -0,0 +1,190 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import type { ToolUse } from "@core/assistant-message"
+import { JSONParser } from "@streamparser/json"
+import { McpHub } from "@/services/mcp/McpHub"
+import { CLINE_MCP_TOOL_IDENTIFIER } from "@/shared/mcp"
+import { ClineDefaultTool } from "@/shared/tools"
+
+export interface PendingToolUse {
+	id: string
+	name: string
+	input: string
+	parsedInput?: unknown
+	jsonParser?: JSONParser
+	call_id?: string
+}
+
+interface ToolUseDeltaBlock {
+	id?: string
+	type?: string
+	name?: string
+	input?: string
+}
+
+const ESCAPE_MAP: Record<string, string> = {
+	"\\n": "\n",
+	"\\t": "\t",
+	"\\r": "\r",
+	'\\"': '"',
+	"\\\\": "\\",
+}
+
+const ESCAPE_PATTERN = /\\[ntr"\\]/g
+
+/**
+ * Handles streaming tool use blocks and converts them to Anthropic.ToolUseBlockParam format
+ */
+export class ToolUseHandler {
+	private pendingToolUses = new Map<string, PendingToolUse>()
+
+	processToolUseDelta(delta: ToolUseDeltaBlock, call_id?: string): void {
+		if (delta.type !== "tool_use" || !delta.id) {
+			return
+		}
+
+		let pending = this.pendingToolUses.get(delta.id)
+		if (!pending) {
+			pending = this.createPendingToolUse(delta.id, delta.name || "", call_id)
+		}
+
+		if (delta.name) {
+			pending.name = delta.name
+		}
+		if (delta.input) {
+			pending.input += delta.input
+			try {
+				pending.jsonParser?.write(delta.input)
+			} catch {
+				// Expected during streaming
+			}
+		}
+	}
+
+	getFinalizedToolUse(id: string): Anthropic.ToolUseBlockParam | undefined {
+		const pending = this.pendingToolUses.get(id)
+		if (!pending?.name) {
+			return undefined
+		}
+
+		let input: unknown = {}
+		if (pending.parsedInput != null) {
+			input = pending.parsedInput
+		} else if (pending.input) {
+			try {
+				input = JSON.parse(pending.input)
+			} catch {
+				input = this.extractPartialJsonFields(pending.input)
+			}
+		}
+
+		return {
+			type: "tool_use",
+			id: pending.id,
+			name: pending.name,
+			input,
+		}
+	}
+
+	getAllFinalizedToolUses(): Anthropic.ToolUseBlockParam[] {
+		const results: Anthropic.ToolUseBlockParam[] = []
+		for (const id of this.pendingToolUses.keys()) {
+			const toolUse = this.getFinalizedToolUse(id)
+			if (toolUse) {
+				results.push(toolUse)
+			}
+		}
+		return results
+	}
+
+	hasToolUse(id: string): boolean {
+		return this.pendingToolUses.has(id)
+	}
+
+	getPartialToolUsesAsContent(): ToolUse[] {
+		const results: ToolUse[] = []
+
+		for (const pending of this.pendingToolUses.values()) {
+			if (!pending.name) {
+				continue
+			}
+
+			let input: any = {}
+			if (pending.parsedInput != null) {
+				input = pending.parsedInput
+			} else if (pending.input) {
+				try {
+					input = JSON.parse(pending.input)
+				} catch {
+					input = this.extractPartialJsonFields(pending.input)
+				}
+			}
+
+			if (pending.name.includes(CLINE_MCP_TOOL_IDENTIFIER)) {
+				const [key, toolName] = pending.name.split(CLINE_MCP_TOOL_IDENTIFIER)
+				results.push({
+					type: "tool_use",
+					name: ClineDefaultTool.MCP_USE,
+					params: {
+						server_name: McpHub.getMcpServerByKey(key),
+						tool_name: toolName,
+						arguments: JSON.stringify(input),
+					},
+					partial: true,
+				})
+			} else {
+				const params: Record<string, string> = {}
+				if (typeof input === "object") {
+					for (const [key, value] of Object.entries(input)) {
+						params[key] = typeof value === "string" ? value : JSON.stringify(value)
+					}
+				}
+				results.push({
+					type: "tool_use",
+					name: pending.name as ClineDefaultTool,
+					params: params as any,
+					partial: true,
+				})
+			}
+		}
+
+		return results
+	}
+
+	reset(): void {
+		this.pendingToolUses.clear()
+	}
+
+	private createPendingToolUse(id: string, name: string, call_id?: string): PendingToolUse {
+		const jsonParser = new JSONParser()
+		const pending: PendingToolUse = {
+			id,
+			name,
+			input: "",
+			parsedInput: undefined,
+			jsonParser,
+			call_id,
+		}
+
+		jsonParser.onValue = (info: any) => {
+			if (info.stack.length === 0 && info.value && typeof info.value === "object") {
+				pending.parsedInput = info.value
+			}
+		}
+
+		jsonParser.onError = () => {}
+
+		this.pendingToolUses.set(id, pending)
+		return pending
+	}
+
+	private extractPartialJsonFields(partialJson: string): Record<string, any> {
+		const result: Record<string, any> = {}
+		const pattern = /"(\w+)":\s*"((?:[^"\\]|\\.)*)(?:")?/g
+
+		for (const match of partialJson.matchAll(pattern)) {
+			result[match[1]] = match[2].replace(ESCAPE_PATTERN, (m) => ESCAPE_MAP[m])
+		}
+
+		return result
+	}
+}
@@ -1,13 +1,16 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ModelInfo } from "@shared/api"
 import OpenAI from "openai"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { convertToOpenAiMessages } from "../transform/openai-format"
+import { getOpenAIToolParams } from "./tool-call-processor"

 export async function createVercelAIGatewayStream(
 	client: OpenAI,
 	systemPrompt: string,
 	messages: Anthropic.Messages.MessageParam[],
 	model: { id: string; info: ModelInfo },
+	tools?: OpenAITool[],
 ) {
 	// Convert Anthropic messages to OpenAI format
 	const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -49,6 +52,7 @@ export async function createVercelAIGatewayStream(
 		temperature: 0.7,
 		messages: openAiMessages,
 		stream: true,
+		...getOpenAIToolParams(tools),
 	})

 	return stream
@@ -13,6 +13,7 @@ export const toolParamNames = [
 	"command",
 	"requires_approval",
 	"path",
+	"absolutePath",
 	"content",
 	"diff",
 	"regex",
@@ -39,6 +40,7 @@ export const toolParamNames = [
 	"needs_more_exploration",
 	"task_progress",
 	"timeout",
+	"input",
 ] as const

 export type ToolParamName = (typeof toolParamNames)[number]
@@ -329,10 +329,128 @@ export class ContextManager {

 		const updatedMessages = this.applyContextHistoryUpdates(messages, deletedRange ? deletedRange[1] + 1 : 2)

+		// Validate and fix tool_use/tool_result pairing
+		this.ensureToolResultsFollowToolUse(updatedMessages)
+
 		// OLD NOTE: if you try to console log these, don't forget that logging a reference to an array may not provide the same result as logging a slice() snapshot of that array at that exact moment. The following DOES in fact include the latest assistant message.
 		return updatedMessages
 	}

+	/**
+	 * Ensures that every tool_use block in assistant messages has a corresponding tool_result in the next user message,
+	 * and that tool_result blocks immediately follow their corresponding tool_use blocks
+	 */
+	private ensureToolResultsFollowToolUse(messages: Anthropic.Messages.MessageParam[]): void {
+		for (let i = 0; i < messages.length - 1; i++) {
+			const message = messages[i]
+
+			// Only process assistant messages with content
+			if (message.role !== "assistant" || !Array.isArray(message.content)) {
+				continue
+			}
+
+			// Extract tool_use IDs in order
+			const toolUseIds: string[] = []
+			for (const block of message.content) {
+				if (block.type === "tool_use" && block.id) {
+					toolUseIds.push(block.id)
+				}
+			}
+
+			// Skip if no tool_use blocks found
+			if (toolUseIds.length === 0) {
+				continue
+			}
+
+			const nextMessage = messages[i + 1]
+
+			// Skip if next message is not a user message
+			if (nextMessage.role !== "user") {
+				continue
+			}
+
+			// Ensure content is an array
+			if (!Array.isArray(nextMessage.content)) {
+				nextMessage.content = []
+			}
+
+			// Separate tool_results from other blocks in a single pass
+			const toolResultMap = new Map<string, Anthropic.Messages.ToolResultBlockParam>()
+			const otherBlocks: Anthropic.Messages.ContentBlockParam[] = []
+			let needsUpdate = false
+
+			for (const block of nextMessage.content) {
+				if (block.type === "tool_result" && block.tool_use_id) {
+					toolResultMap.set(block.tool_use_id, block)
+				} else {
+					otherBlocks.push(block)
+				}
+			}
+
+			// Check if reordering is needed (tool_results not at start in correct order)
+			if (toolResultMap.size > 0) {
+				let expectedIndex = 0
+				for (let j = 0; j < nextMessage.content.length && expectedIndex < toolUseIds.length; j++) {
+					const block = nextMessage.content[j]
+					if (block.type === "tool_result" && block.tool_use_id === toolUseIds[expectedIndex]) {
+						expectedIndex++
+					} else if (block.type === "tool_result" || expectedIndex < toolUseIds.length) {
+						needsUpdate = true
+						break
+					}
+				}
+				if (!needsUpdate && expectedIndex < toolResultMap.size) {
+					needsUpdate = true
+				}
+			}
+
+			// Add missing tool_results
+			for (const toolUseId of toolUseIds) {
+				if (!toolResultMap.has(toolUseId)) {
+					toolResultMap.set(toolUseId, {
+						type: "tool_result",
+						tool_use_id: toolUseId,
+						content: "result missing",
+					})
+					needsUpdate = true
+				}
+			}
+
+			// Only modify if changes are needed
+			if (!needsUpdate) {
+				continue
+			}
+
+			// Build new content: tool_results first (in toolUseIds order), then other blocks
+			const newContent: Anthropic.Messages.ContentBlockParam[] = []
+
+			// Add tool_results in the order of toolUseIds
+			const processedToolResults = new Set<string>()
+			for (const toolUseId of toolUseIds) {
+				const toolResult = toolResultMap.get(toolUseId)
+				if (toolResult) {
+					newContent.push(toolResult)
+					processedToolResults.add(toolUseId)
+				}
+			}
+
+			// Add any orphaned tool_results not in toolUseIds (shouldn't happen, but be safe)
+			for (const [toolUseId, toolResult] of toolResultMap) {
+				if (!processedToolResults.has(toolUseId)) {
+					newContent.push(toolResult)
+				}
+			}
+
+			// Add all other blocks
+			newContent.push(...otherBlocks)
+
+			// Clone and update the message
+			const clonedMessage = cloneDeep(nextMessage)
+			clonedMessage.content = newContent
+			messages[i + 1] = clonedMessage
+		}
+	}
+
 	/**
 	 * applies deletedRange truncation and other alterations based on changes in this.contextHistoryUpdates
 	 */
@@ -0,0 +1,24 @@
+import { Empty, StringRequest } from "@shared/proto/cline/common"
+import { toRequestyServiceUrl } from "@shared/providers/requesty"
+import { HostProvider } from "@/hosts/host-provider"
+import { openExternal } from "@/utils/env"
+import { Controller } from ".."
+
+/**
+ * Initiates Requesty auth with optional custom base URL
+ */
+export async function requestyAuthClicked(_: Controller, req: StringRequest): Promise<Empty> {
+	const customBaseUrl = req.value || undefined
+	const callbackUrl = await HostProvider.get().getCallbackUrl()
+	const baseUrl = toRequestyServiceUrl(customBaseUrl, "app")
+
+	if (!baseUrl) {
+		throw new Error("Invalid Requesty base URL")
+	}
+
+	const authUrl = new URL(`oauth/authorize?callback_url=${callbackUrl}/requesty`, baseUrl)
+
+	await openExternal(authUrl.toString())
+
+	return {}
+}
@@ -597,99 +597,41 @@ export class Controller {
 	}

 	// MCP Marketplace
-	private async fetchMcpMarketplaceFromApi(silent: boolean = false): Promise<McpMarketplaceCatalog | undefined> {
-		try {
-			const response = await axios.get(`${ClineEnv.config().mcpBaseUrl}/marketplace`, {
-				headers: {
-					"Content-Type": "application/json",
-				},
-			})
+	private async fetchMcpMarketplaceFromApi(): Promise<McpMarketplaceCatalog> {
+		const response = await axios.get(`${ClineEnv.config().mcpBaseUrl}/marketplace`, {
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": "cline-vscode-extension",
+			},
+		})

-			if (!response.data) {
-				throw new Error("Invalid response from MCP marketplace API")
-			}
-
-			const catalog: McpMarketplaceCatalog = {
-				items: (response.data || []).map((item: any) => ({
-					...item,
-					githubStars: item.githubStars ?? 0,
-					downloadCount: item.downloadCount ?? 0,
-					tags: item.tags ?? [],
-				})),
-			}
-
-			// Store in cache file
-			await writeMcpMarketplaceCatalogToCache(catalog)
-			return catalog
-		} catch (error) {
-			console.error("Failed to fetch MCP marketplace:", error)
-			if (!silent) {
-				const errorMessage = error instanceof Error ? error.message : "Failed to fetch MCP marketplace"
-				HostProvider.window.showMessage({
-					type: ShowMessageType.ERROR,
-					message: errorMessage,
-				})
-			}
-			return undefined
+		if (!response.data) {
+			throw new Error("Invalid response from MCP marketplace API")
 		}
+
+		const catalog: McpMarketplaceCatalog = {
+			items: (response.data || []).map((item: any) => ({
+				...item,
+				githubStars: item.githubStars ?? 0,
+				downloadCount: item.downloadCount ?? 0,
+				tags: item.tags ?? [],
+			})),
+		}
+
+		// Store in cache file
+		await writeMcpMarketplaceCatalogToCache(catalog)
+		return catalog
 	}

-	private async fetchMcpMarketplaceFromApiRPC(silent: boolean = false): Promise<McpMarketplaceCatalog | undefined> {
+	async refreshMcpMarketplace(sendCatalogEvent: boolean): Promise<McpMarketplaceCatalog | undefined> {
 		try {
-			const response = await axios.get(`${ClineEnv.config().mcpBaseUrl}/marketplace`, {
-				headers: {
-					"Content-Type": "application/json",
-					"User-Agent": "cline-vscode-extension",
-				},
-			})
-
-			if (!response.data) {
-				throw new Error("Invalid response from MCP marketplace API")
-			}
-
-			const catalog: McpMarketplaceCatalog = {
-				items: (response.data || []).map((item: any) => ({
-					...item,
-					githubStars: item.githubStars ?? 0,
-					downloadCount: item.downloadCount ?? 0,
-					tags: item.tags ?? [],
-				})),
-			}
-
-			// Store in cache file
-			await writeMcpMarketplaceCatalogToCache(catalog)
-			return catalog
-		} catch (error) {
-			console.error("Failed to fetch MCP marketplace:", error)
-			if (!silent) {
-				const errorMessage = error instanceof Error ? error.message : "Failed to fetch MCP marketplace"
-				throw new Error(errorMessage)
-			}
-			return undefined
-		}
-	}
-
-	async silentlyRefreshMcpMarketplace() {
-		try {
-			const catalog = await this.fetchMcpMarketplaceFromApi(true)
-			if (catalog) {
+			const catalog = await this.fetchMcpMarketplaceFromApi()
+			if (catalog && sendCatalogEvent) {
 				await sendMcpMarketplaceCatalogEvent(catalog)
 			}
+			return catalog
 		} catch (error) {
-			console.error("Failed to silently refresh MCP marketplace:", error)
-		}
-	}
-
-	/**
-	 * RPC variant that silently refreshes the MCP marketplace catalog and returns the result
-	 * Unlike silentlyRefreshMcpMarketplace, this doesn't send a message to the webview
-	 * @returns MCP marketplace catalog or undefined if refresh failed
-	 */
-	async silentlyRefreshMcpMarketplaceRPC() {
-		try {
-			return await this.fetchMcpMarketplaceFromApiRPC(true)
-		} catch (error) {
-			console.error("Failed to silently refresh MCP marketplace (RPC):", error)
+			console.error("Failed to refresh MCP marketplace:", error)
 			return undefined
 		}
 	}
@@ -730,6 +672,25 @@ export class Controller {
 		// Dont send settingsButtonClicked because its bad ux if user is on welcome
 	}

+	// Requesty
+
+	async handleRequestyCallback(code: string) {
+		const requesty: ApiProvider = "requesty"
+		const currentMode = this.stateManager.getGlobalSettingsKey("mode")
+		const currentApiConfiguration = this.stateManager.getApiConfiguration()
+		const updatedConfig = {
+			...currentApiConfiguration,
+			planModeApiProvider: requesty,
+			actModeApiProvider: requesty,
+			requestyApiKey: code,
+		}
+		this.stateManager.setApiConfiguration(updatedConfig)
+		await this.postStateToWebview()
+		if (this.task) {
+			this.task.api = buildApiHandler({ ...updatedConfig, ulid: this.task.ulid }, currentMode)
+		}
+	}
+
 	// Read OpenRouter models from disk cache
 	async readOpenRouterModels(): Promise<Record<string, ModelInfo> | undefined> {
 		const openRouterModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.openRouterModels)
@@ -11,17 +11,14 @@ import type { Controller } from "../index"
 export async function refreshMcpMarketplace(controller: Controller, _request: EmptyRequest): Promise<McpMarketplaceCatalog> {
 	try {
 		// Call the RPC variant which returns the result directly
-		const catalog = await controller.silentlyRefreshMcpMarketplaceRPC()
-
+		const catalog = await controller.refreshMcpMarketplace(false /* sendCatalogEvent */)
 		if (catalog) {
 			// Types are structurally identical, use direct type assertion
 			return catalog as McpMarketplaceCatalog
 		}
-
-		// Return empty catalog if nothing was fetched
-		return McpMarketplaceCatalog.create({ items: [] })
 	} catch (error) {
 		console.error("Failed to refresh MCP marketplace:", error)
-		return McpMarketplaceCatalog.create({ items: [] })
 	}
+	// Return empty catalog if nothing was fetched
+	return { items: [] }
 }
@@ -0,0 +1,362 @@
+import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
+import { LiteLLMModelInfo, liteLlmModelInfoSaneDefaults, ModelInfo } from "@shared/api"
+import { fileExistsAtPath } from "@utils/fs"
+import fs from "fs/promises"
+import path from "path"
+import {
+	fetchOpenAiCompatibleModels,
+	normalizeOpenAiCompatibleBaseUrl,
+} from "@/core/api/providers/shared/fetchOpenAiCompatibleModels"
+import { Controller } from ".."
+
+type LiteLlmModelResponseEntry = NonNullable<LiteLlmModelInfoResponse["data"]>[number]
+
+type LiteLlmTierInfo = {
+	context_window?: number | string
+	contextWindow?: number | string
+	input_cost_per_token?: number | string
+	output_cost_per_token?: number | string
+	cache_creation_input_token_cost?: number | string
+	cache_read_input_token_cost?: number | string
+	inputPricePerToken?: number | string
+	outputPricePerToken?: number | string
+	cacheCreationCostPerToken?: number | string
+	cacheReadCostPerToken?: number | string
+	cacheWritesPrice?: number | string
+	cacheReadsPrice?: number | string
+	inputPrice?: number | string
+	outputPrice?: number | string
+}
+
+type LiteLlmThinkingTierInfo = LiteLlmTierInfo
+
+type LiteLlmThinkingConfig = {
+	max_budget?: number | string
+	maxBudget?: number | string
+	output_cost_per_token?: number | string
+	output_price_per_token?: number | string
+	output_price?: number | string
+	output_price_tiers?: LiteLlmThinkingTierInfo[]
+}
+
+interface LiteLlmModelInfoResponse {
+	data?: Array<{
+		model_name?: string
+		description?: string
+		context_window?: number
+		max_completion_tokens?: number
+		litellm_params?: {
+			model?: string
+			max_tokens?: number
+			context_window?: number
+			max_input_tokens?: number
+			supports_images?: boolean
+			[key: string]: unknown
+		}
+		model_info?: {
+			input_cost_per_token?: number | string
+			output_cost_per_token?: number | string
+			cache_creation_input_token_cost?: number | string
+			cache_creation_cost_per_token?: number | string
+			cache_read_input_token_cost?: number | string
+			cache_read_cost_per_token?: number | string
+			supports_prompt_caching?: boolean
+			supports_caching?: boolean
+			supports_global_endpoint?: boolean
+			supports_images?: boolean
+			supports_vision?: boolean
+			context_window?: number | string
+			max_input_tokens?: number | string
+			max_output_tokens?: number | string
+			max_tokens?: number | string
+			max_context_length?: number | string
+			description?: string
+			temperature?: number | string
+			thinking_config?: LiteLlmThinkingConfig
+			tiers?: LiteLlmTierInfo[]
+		}
+	}>
+}
+
+/**
+ * Converts LiteLLM cost values (per-token) into price per million tokens.
+ */
+function convertCostToPerMillion(value?: number | string): number | undefined {
+	if (value === undefined || value === null) {
+		return undefined
+	}
+	const numericValue = typeof value === "number" ? value : parseFloat(value)
+	if (Number.isNaN(numericValue)) {
+		return undefined
+	}
+	return numericValue * 1_000_000
+}
+
+/**
+ * Refreshes the LiteLLM models and returns application types.
+ * @param controller The controller instance
+ * @returns Record of model ID to ModelInfo (application types)
+ */
+export async function refreshLiteLlmModels(controller: Controller): Promise<Record<string, ModelInfo>> {
+	const liteLlmModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.liteLlmModels)
+
+	const liteLlmApiKey = controller.stateManager.getSecretKey("liteLlmApiKey")
+	const rawBaseUrl = controller.stateManager.getGlobalSettingsKey("liteLlmBaseUrl")
+	const normalizedBaseUrl = getNormalizedLiteLlmBaseUrl(rawBaseUrl)
+
+	let models: Record<string, ModelInfo> = {}
+
+	try {
+		const headers: Record<string, string | undefined> = {
+			"x-litellm-api-key": liteLlmApiKey,
+			Authorization: liteLlmApiKey ? `Bearer ${liteLlmApiKey}` : undefined,
+			"Content-Type": "application/json",
+			"User-Agent": "Cline-VSCode-Extension",
+		}
+
+		const transformedModels = await fetchOpenAiCompatibleModels({
+			baseUrl: normalizedBaseUrl,
+			headers,
+			transform: (rawModel: LiteLlmModelResponseEntry): Partial<ModelInfo> => {
+				const modelInfo = rawModel.model_info ?? {}
+				const params = rawModel.litellm_params ?? {}
+
+				const parseNumber = (value: unknown): number | undefined => {
+					if (typeof value === "number") {
+						return Number.isFinite(value) ? value : undefined
+					}
+					if (typeof value === "string") {
+						const parsed = Number(value)
+						return Number.isFinite(parsed) ? parsed : undefined
+					}
+					return undefined
+				}
+
+				const partial: Partial<ModelInfo> = {}
+				const liteLlmPartial = partial as Partial<LiteLLMModelInfo>
+
+				const maxTokensFromParams = parseNumber(params.max_tokens)
+				if (maxTokensFromParams !== undefined) {
+					partial.maxTokens = maxTokensFromParams
+				}
+
+				const contextWindowFromParams = parseNumber(params.context_window)
+				if (contextWindowFromParams !== undefined) {
+					partial.contextWindow = contextWindowFromParams
+				}
+
+				if (typeof params.supports_images === "boolean") {
+					partial.supportsImages = params.supports_images
+				}
+
+				const maxTokensFromInfo =
+					parseNumber(modelInfo.max_output_tokens ?? modelInfo.max_tokens) ??
+					parseNumber(rawModel.max_completion_tokens)
+				if (partial.maxTokens === undefined && maxTokensFromInfo !== undefined) {
+					partial.maxTokens = maxTokensFromInfo
+				}
+
+				const contextWindowFromInfo =
+					parseNumber(
+						modelInfo.context_window ??
+							modelInfo.max_input_tokens ??
+							modelInfo.max_tokens ??
+							modelInfo.max_context_length,
+					) ??
+					parseNumber(rawModel.context_window) ??
+					parseNumber(params.max_input_tokens)
+				if (partial.contextWindow === undefined && contextWindowFromInfo !== undefined) {
+					partial.contextWindow = contextWindowFromInfo
+				}
+
+				if (partial.supportsImages === undefined && typeof modelInfo.supports_images === "boolean") {
+					partial.supportsImages = modelInfo.supports_images
+				}
+				if (partial.supportsImages === undefined && typeof modelInfo.supports_vision === "boolean") {
+					partial.supportsImages = modelInfo.supports_vision
+				}
+
+				if (typeof modelInfo.supports_prompt_caching === "boolean") {
+					partial.supportsPromptCache = modelInfo.supports_prompt_caching
+				}
+				if (typeof modelInfo.supports_caching === "boolean") {
+					partial.supportsPromptCache = modelInfo.supports_caching
+				}
+
+				if (typeof modelInfo.supports_global_endpoint === "boolean") {
+					partial.supportsGlobalEndpoint = modelInfo.supports_global_endpoint
+				}
+
+				const inputCost = convertCostToPerMillion(modelInfo.input_cost_per_token)
+				if (inputCost !== undefined) {
+					partial.inputPrice = inputCost
+				}
+
+				const outputCost = convertCostToPerMillion(modelInfo.output_cost_per_token)
+				if (outputCost !== undefined) {
+					partial.outputPrice = outputCost
+				}
+
+				const cacheWriteCost = convertCostToPerMillion(
+					modelInfo.cache_creation_input_token_cost ?? modelInfo.cache_creation_cost_per_token,
+				)
+				if (cacheWriteCost !== undefined) {
+					partial.cacheWritesPrice = cacheWriteCost
+				}
+
+				const cacheReadCost = convertCostToPerMillion(
+					modelInfo.cache_read_input_token_cost ?? modelInfo.cache_read_cost_per_token,
+				)
+				if (cacheReadCost !== undefined) {
+					partial.cacheReadsPrice = cacheReadCost
+				}
+
+				const temperature = parseNumber(modelInfo.temperature)
+				if (temperature !== undefined) {
+					liteLlmPartial.temperature = temperature
+				}
+
+				if (!partial.description) {
+					if (typeof rawModel.description === "string" && rawModel.description.trim().length > 0) {
+						partial.description = rawModel.description
+					} else if (typeof modelInfo.description === "string" && modelInfo.description.trim().length > 0) {
+						partial.description = modelInfo.description
+					}
+				}
+
+				const thinkingConfig = modelInfo.thinking_config as LiteLlmThinkingConfig | undefined
+				if (thinkingConfig && typeof thinkingConfig === "object") {
+					const normalizedThinking: NonNullable<ModelInfo["thinkingConfig"]> = {}
+
+					const maxBudget = parseNumber((thinkingConfig as any).max_budget ?? (thinkingConfig as any).maxBudget)
+					if (maxBudget !== undefined) {
+						normalizedThinking.maxBudget = maxBudget
+					}
+
+					const thinkingOutputPrice = convertCostToPerMillion(
+						(thinkingConfig as any).output_cost_per_token ??
+							(thinkingConfig as any).output_price_per_token ??
+							(thinkingConfig as any).output_price,
+					)
+					if (thinkingOutputPrice !== undefined) {
+						normalizedThinking.outputPrice = thinkingOutputPrice
+					}
+
+					if (Array.isArray(thinkingConfig.output_price_tiers)) {
+						const tiers = thinkingConfig.output_price_tiers
+							.map((tier: LiteLlmThinkingTierInfo) => {
+								const contextWindow = parseNumber(tier.context_window ?? tier.contextWindow)
+								if (contextWindow === undefined) {
+									return undefined
+								}
+								const outputPrice = convertCostToPerMillion(
+									tier.output_cost_per_token ?? tier.outputPricePerToken ?? tier.outputPrice,
+								)
+								if (outputPrice === undefined) {
+									return undefined
+								}
+								return {
+									tokenLimit: contextWindow,
+									price: outputPrice,
+								}
+							})
+							.filter((tier): tier is NonNullable<typeof tier> => Boolean(tier))
+
+						if (tiers.length > 0) {
+							normalizedThinking.outputPriceTiers = tiers
+						}
+					}
+
+					if (Object.keys(normalizedThinking).length > 0) {
+						partial.thinkingConfig = normalizedThinking
+					}
+				}
+
+				if (Array.isArray(modelInfo.tiers)) {
+					const tiers = modelInfo.tiers
+						.map((tier: LiteLlmTierInfo) => {
+							const contextWindow = parseNumber(tier.context_window ?? tier.contextWindow)
+							if (contextWindow === undefined) {
+								return undefined
+							}
+							return {
+								contextWindow,
+								inputPrice: convertCostToPerMillion(
+									tier.input_cost_per_token ?? tier.inputPricePerToken ?? tier.inputPrice,
+								),
+								outputPrice: convertCostToPerMillion(
+									tier.output_cost_per_token ?? tier.outputPricePerToken ?? tier.outputPrice,
+								),
+								cacheWritesPrice: convertCostToPerMillion(
+									tier.cache_creation_input_token_cost ??
+										tier.cacheCreationCostPerToken ??
+										tier.cacheWritesPrice,
+								),
+								cacheReadsPrice: convertCostToPerMillion(
+									tier.cache_read_input_token_cost ?? tier.cacheReadCostPerToken ?? tier.cacheReadsPrice,
+								),
+							}
+						})
+						.filter((tier): tier is NonNullable<typeof tier> => Boolean(tier))
+
+					if (tiers.length > 0) {
+						partial.tiers = tiers
+					}
+				}
+
+				return partial
+			},
+		})
+
+		if (Object.keys(transformedModels).length > 0) {
+			models = Object.fromEntries(
+				Object.entries(transformedModels).map(([modelId, modelInfo]) => [
+					modelId,
+					{
+						...liteLlmModelInfoSaneDefaults,
+						...modelInfo,
+					},
+				]),
+			)
+
+			await fs.writeFile(liteLlmModelsFilePath, JSON.stringify(models))
+		} else {
+			console.warn("LiteLLM model list was empty; retaining previous cache if available.")
+			const cachedModels = await readLiteLlmModels()
+			if (cachedModels) {
+				models = cachedModels
+			}
+		}
+	} catch (error) {
+		console.error("Error fetching LiteLLM models:", error)
+		const cachedModels = await readLiteLlmModels()
+		if (cachedModels) {
+			models = cachedModels
+		}
+	}
+
+	return models
+}
+
+/**
+ * Reads cached LiteLLM models from disk (application types)
+ */
+async function readLiteLlmModels(): Promise<Record<string, ModelInfo> | undefined> {
+	const liteLlmModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.liteLlmModels)
+	if (await fileExistsAtPath(liteLlmModelsFilePath)) {
+		try {
+			const fileContents = await fs.readFile(liteLlmModelsFilePath, "utf8")
+			return JSON.parse(fileContents) as Record<string, ModelInfo>
+		} catch (error) {
+			console.error("Error reading cached LiteLLM models:", error)
+		}
+	}
+	return undefined
+}
+
+/**
+ * Utility to resolve the effective LiteLLM base URL with default normalization.
+ */
+export function getNormalizedLiteLlmBaseUrl(baseUrl: string | undefined): string {
+	return normalizeOpenAiCompatibleBaseUrl(baseUrl || "http://localhost:4000")
+}
@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "@/shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshLiteLlmModels } from "./refreshLiteLlmModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param _request Empty request object
+ * @returns Response containing LiteLLM models (protobuf types)
+ */
+export async function refreshLiteLlmModelsRpc(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshLiteLlmModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}
@@ -0,0 +1,79 @@
+import { Empty } from "@shared/proto/cline/common"
+import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
+import { buildApiHandler } from "@/core/api"
+import { ApiHandlerOptions, ApiHandlerSecrets, ApiProvider } from "@/shared/api"
+import { UpdateApiConfigurationRequestNew } from "@/shared/proto/index.cline"
+import type { Controller } from "../index"
+
+/**
+ * Updates API configuration
+ * @param controller The controller instance
+ * @param request The update API configuration request
+ * @returns Empty response
+ */
+export async function updateApiConfiguration(controller: Controller, request: UpdateApiConfigurationRequestNew): Promise<Empty> {
+	try {
+		const { options: protoOptions, secrets: protoSecrets } = request
+
+		const secrets: Partial<ApiHandlerSecrets> = {}
+		if (protoSecrets) {
+			const filteredSecrets = Object.fromEntries(Object.entries(protoSecrets).filter(([_, value]) => value !== undefined))
+			Object.assign(secrets, filteredSecrets)
+		}
+
+		const options: Partial<ApiHandlerOptions> & { planModeApiProvider?: ApiProvider; actModeApiProvider?: ApiProvider } = {}
+		if (protoOptions) {
+			// Extract fields requiring conversion or special handling
+			const {
+				// Fields requiring enum conversion
+				planModeApiProvider,
+				actModeApiProvider,
+
+				// Fields requiring special handling
+				openAiHeaders,
+				...simpleOptions
+			} = protoOptions
+
+			// Batch update for simple pass-through fields
+			const filteredOptions = Object.fromEntries(Object.entries(simpleOptions).filter(([_, value]) => value !== undefined))
+			Object.assign(options, filteredOptions)
+
+			// Handle openAiHeaders (skip empty objects)
+			if (openAiHeaders && Object.keys(openAiHeaders).length > 0) {
+				options.openAiHeaders = openAiHeaders
+			}
+
+			// Convert proto ApiProvider enums to native string types
+			if (planModeApiProvider !== undefined) {
+				options.planModeApiProvider = convertProtoToApiProvider(planModeApiProvider)
+			}
+			if (actModeApiProvider !== undefined) {
+				options.actModeApiProvider = convertProtoToApiProvider(actModeApiProvider)
+			}
+		}
+
+		// Update storage using batch methods
+		if (Object.keys(secrets).length > 0) {
+			controller.stateManager.setSecretsBatch(secrets)
+		}
+		if (Object.keys(options).length > 0) {
+			controller.stateManager.setGlobalStateBatch(options)
+		}
+
+		// Update the task's API handler if there's an active task
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			// Combine secrets and options for the API handler
+			const apiConfigForHandler = { ...secrets, ...options, ulid: controller.task.ulid }
+			controller.task.api = buildApiHandler(apiConfigForHandler, currentMode)
+		}
+
+		// Post updated state to webview
+		await controller.postStateToWebview()
+
+		return Empty.create()
+	} catch (error) {
+		console.error(`Failed to update API configuration: ${error}`)
+		throw error
+	}
+}
@@ -212,7 +212,7 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 			}

 			// Update default terminal profile (requires terminal manager updates and notifications)
-			if (defaultTerminalProfile !== undefined) {
+			if (defaultTerminalProfile !== undefined && defaultTerminalProfile !== "") {
 				const profileId = defaultTerminalProfile

 				// Update the terminal profile in the state
@@ -223,6 +223,11 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS

 				// Update the terminal manager of the current task if it exists
 				if (controller.task) {
+					// Terminal manager must exist when task is active
+					if (!controller.task.terminalManager) {
+						throw new Error("Cannot update terminal profile: Terminal manager missing from active task")
+					}
+
 					// Call the updated setDefaultTerminalProfile method that returns closed terminal info
 					const result = controller.task.terminalManager.setDefaultTerminalProfile(profileId)
 					closedCount = result.closedCount
@@ -209,7 +209,7 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 		}

 		// Silently refresh MCP marketplace catalog
-		controller.silentlyRefreshMcpMarketplace()
+		controller.refreshMcpMarketplace(true /* sendCatalogEvent */)

 		// Initialize telemetry service with user's current setting
 		controller.getStateToPostToWebview().then((state) => {
@@ -25,8 +25,10 @@ export const formatResponse = {
 	clineIgnoreError: (path: string) =>
 		`Access to ${path} is blocked by the .clineignore file settings. You must try to continue in the task without using this file, or ask the user to update the .clineignore file.`,

-	noToolsUsed: () =>
-		`[ERROR] You did not use a tool in your previous response! Please retry with a tool use.
+	noToolsUsed: (usingNativeToolCalls: boolean) =>
+		usingNativeToolCalls
+			? "[ERROR] You did not use a tool in your previous response! Please retry with a tool use."
+			: `[ERROR] You did not use a tool in your previous response! Please retry with a tool use.

 ${toolUseInstructionsReminder}

@@ -284,21 +286,16 @@ const formatImagesIntoBlocks = (images?: string[]): Anthropic.ImageBlockParam[]
 }

 const toolUseInstructionsReminder = `# Reminder: Instructions for Tool Use
-
 Tool uses are formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
 <tool_name>
 <parameter1_name>value1</parameter1_name>
 <parameter2_name>value2</parameter2_name>
 ...
 </tool_name>
-
 For example:
-
 <attempt_completion>
 <result>
 I have completed the task...
 </result>
 </attempt_completion>
-
 Always adhere to this format for all tool uses to ensure proper parsing and execution.`
@@ -97,7 +97,7 @@ class PromptRegistry {
 		await this.load()

 		// Try model family fallback (e.g., "claude-4" -> "claude")
-		const modelFamily = getModelFamily(context.providerInfo)
+		const modelFamily = this.getModelFamily(context.providerInfo)
 		const variant = this.variants.get(modelFamily ?? ModelFamily.GENERIC)

 		if (!variant) {
@@ -225,7 +225,7 @@ class PromptBuilder {
    // Add standard system placeholders
    placeholders[STANDARD_PLACEHOLDERS.CWD] = this.context.cwd || process.cwd();
    placeholders[STANDARD_PLACEHOLDERS.SUPPORTS_BROWSER] = this.context.supportsBrowserUse || false;
-    placeholders[STANDARD_PLACEHOLDERS.MODEL_FAMILY] = getModelFamily(this.variant.id);
+    placeholders[STANDARD_PLACEHOLDERS.MODEL_FAMILY] = this.variant.family;
    placeholders[STANDARD_PLACEHOLDERS.CURRENT_DATE] = new Date().toISOString().split("T")[0];

    // Add all component sections
@@ -44,6 +44,7 @@ describe("PromptBuilder", () => {
 	const baseVariant: PromptVariant = {
 		id: "test-model",
 		family: ModelFamily.GENERIC,
+		matcher: () => true,
 		version: 1,
 		description: "A test model",
 		tags: ["test"],
@@ -259,6 +260,7 @@ describe("PromptBuilder", () => {
 					SystemPromptSection.CAPABILITIES,
 					SystemPromptSection.RULES,
 				)
+				.matcher(() => true)
 				.build()

 			// Should have auto-generated a baseTemplate
@@ -295,6 +297,7 @@ describe("PromptBuilder", () => {
 				.description("Test variant with explicit template")
 				.version(1)
 				.template(customTemplate)
+				.matcher(() => true)
 				.components(SystemPromptSection.AGENT_ROLE, SystemPromptSection.TOOL_USE)
 				.build()

@@ -307,6 +310,7 @@ describe("PromptBuilder", () => {
 				createVariant(ModelFamily.GENERIC)
 					.description("Test variant with empty components")
 					.version(1)
+					.matcher(() => true)
 					.components() // Empty components
 					.build()
 			}).to.throw("Component order is required")
@@ -1,7 +1,6 @@
 import { expect } from "chai"
 import type { McpHub } from "@/services/mcp/McpHub"
 import { ModelFamily } from "@/shared/prompts"
-import { getModelFamily } from ".."
 import { PromptRegistry } from "../registry/PromptRegistry"
 import type { SystemPromptContext } from "../types"
 import { mockProviderInfo } from "./integration.test"
@@ -49,7 +48,9 @@ describe("PromptRegistry", () => {
 	})

 	describe("getModelFamily", () => {
-		it("should extract correct model families", () => {
+		it("should extract correct model families", async () => {
+			const registry = PromptRegistry.getInstance()
+			await registry.load()
 			const testCases = [
 				{ id: "claude-3-5-sonnet", expected: ModelFamily.GENERIC },
 				{ id: "gpt-4-turbo", expected: ModelFamily.GENERIC },
@@ -59,17 +60,23 @@ describe("PromptRegistry", () => {
 				{ id: "openai/gpt-4", expected: ModelFamily.GENERIC },
 				{ id: "google/gemini", expected: ModelFamily.GENERIC },
 				{ id: "claude-sonnet-4", expected: ModelFamily.NEXT_GEN },
-				{ id: "gpt-5", expected: ModelFamily.GPT_5 },
-				{ id: "openai/gpt-5", expected: ModelFamily.GPT_5 },
+				{ id: "gpt-5", provider: "cline", expected: ModelFamily.NATIVE_GPT_5, useNativeTools: true },
+				{ id: "gpt-5", provider: "openai-native", expected: ModelFamily.NATIVE_GPT_5, useNativeTools: true },
+				{ id: "gpt-5", provider: "cline", expected: ModelFamily.GPT_5, useNativeTools: false },
+				{ id: "openai/gpt-5", expected: ModelFamily.NEXT_GEN },
 				{ id: "unknown-model", expected: ModelFamily.GENERIC },
 			]

-			for (const { id, expected, provider } of testCases) {
+			for (const { id, expected, provider, useNativeTools } of testCases) {
 				const providerId = provider ?? "random"
 				const customPrompt = provider === "lmstudio" ? "compact" : undefined
 				const providerInfo = { ...mockProviderInfo, providerId, model: { ...mockProviderInfo.model, id }, customPrompt }
-				const result = getModelFamily(providerInfo)
-				expect(result).to.equal(expected)
+				const result = registry.getModelFamily({
+					...mockContext,
+					providerInfo,
+					enableNativeToolCalls: useNativeTools ?? false,
+				})
+				expect(result).to.equal(expected, `Failed for model ${id} with provider ${providerId}`)
 			}
 		})
 	})
@@ -0,0 +1,98 @@
+You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+====
+
+AUTOMATIC TODO LIST MANAGEMENT
+
+The system automatically manages todo lists to help track task progress:
+
+- Every 10th API request, you will be prompted to review and update the current todo list if one exists
+- When switching from PLAN MODE to ACT MODE, you should create a comprehensive todo list for the task
+- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
+- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
+- The system will automatically include todo list context in your prompts when appropriate
+- Focus on creating actionable, meaningful steps rather than granular technical details
+
+====
+
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Present the plan to the user using the plan_mode_respond tool.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search, use the browser, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('/test/project') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.
+- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.
+	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser.
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+
+====
+
+FEEDBACK
+
+When user is providing you with feedback on how you could improve, you can let the user know to report new issue using the '/reportbug' slash command.
+
+====
+
+RULES
+
+- The current working directory is `/test/project` - this is the directory where all the tools will be executed from.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: macOS
+IDE: TestIde
+Default Shell: /bin/zsh
+Home Directory: /Users/tester
+Current Working Directory: /Users/tester/dev/project
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. `open index.html` to show the website you've built.
+5. If the task is not actionable, you may use the attempt_completion tool to explain to the user why the task cannot be completed, or provide a simple answer if that is what the user is looking for.
+
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+Prefer TypeScript
+
+Follow global rules
+
+Follow local rules
@@ -0,0 +1,96 @@
+You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+====
+
+AUTOMATIC TODO LIST MANAGEMENT
+
+The system automatically manages todo lists to help track task progress:
+
+- Every 10th API request, you will be prompted to review and update the current todo list if one exists
+- When switching from PLAN MODE to ACT MODE, you should create a comprehensive todo list for the task
+- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
+- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
+- The system will automatically include todo list context in your prompts when appropriate
+- Focus on creating actionable, meaningful steps rather than granular technical details
+
+====
+
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Present the plan to the user using the plan_mode_respond tool.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('/test/project') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+
+====
+
+FEEDBACK
+
+When user is providing you with feedback on how you could improve, you can let the user know to report new issue using the '/reportbug' slash command.
+
+====
+
+RULES
+
+- The current working directory is `/test/project` - this is the directory where all the tools will be executed from.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: macOS
+IDE: TestIde
+Default Shell: /bin/zsh
+Home Directory: /Users/tester
+Current Working Directory: /Users/tester/dev/project
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. `open index.html` to show the website you've built.
+5. If the task is not actionable, you may use the attempt_completion tool to explain to the user why the task cannot be completed, or provide a simple answer if that is what the user is looking for.
+
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+Prefer TypeScript
+
+Follow global rules
+
+Follow local rules
@@ -0,0 +1,79 @@
+You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+====
+
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Present the plan to the user using the plan_mode_respond tool.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search, use the browser, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('/test/project') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.
+- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.
+	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser.
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+
+====
+
+RULES
+
+- The current working directory is `/test/project` - this is the directory where all the tools will be executed from.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: macOS
+IDE: TestIde
+Default Shell: /bin/zsh
+Home Directory: /Users/tester
+Current Working Directory: /Users/tester/dev/project
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. `open index.html` to show the website you've built.
+5. If the task is not actionable, you may use the attempt_completion tool to explain to the user why the task cannot be completed, or provide a simple answer if that is what the user is looking for.
+
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+Prefer TypeScript
+
+Follow global rules
+
+Follow local rules
@@ -0,0 +1,98 @@
+You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+====
+
+AUTOMATIC TODO LIST MANAGEMENT
+
+The system automatically manages todo lists to help track task progress:
+
+- Every 10th API request, you will be prompted to review and update the current todo list if one exists
+- When switching from PLAN MODE to ACT MODE, you should create a comprehensive todo list for the task
+- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
+- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
+- The system will automatically include todo list context in your prompts when appropriate
+- Focus on creating actionable, meaningful steps rather than granular technical details
+
+====
+
+ACT MODE V.S. PLAN MODE
+
+In each user message, the environment_details will specify the current mode. There are two modes:
+
+- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
+ - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
+- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
+ - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
+ - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly.
+
+## What is PLAN MODE?
+
+- While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Present the plan to the user using the plan_mode_respond tool.
+- Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
+- Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
+
+====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search, use the browser, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('/test/project') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
+- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
+    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.
+- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.
+	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser.
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+
+====
+
+FEEDBACK
+
+When user is providing you with feedback on how you could improve, you can let the user know to report new issue using the '/reportbug' slash command.
+
+====
+
+RULES
+
+- The current working directory is `/test/project` - this is the directory where all the tools will be executed from.
+
+====
+
+SYSTEM INFORMATION
+
+Operating System: macOS
+IDE: TestIde
+Default Shell: /bin/zsh
+Home Directory: /Users/tester
+Current Working Directory: /Users/tester/dev/project
+
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. `open index.html` to show the website you've built.
+5. If the task is not actionable, you may use the attempt_completion tool to explain to the user why the task cannot be completed, or provide a simple answer if that is what the user is looking for.
+
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+Prefer TypeScript
+
+Follow global rules
+
+Follow local rules
@@ -164,13 +164,9 @@ const baseContext: SystemPromptContext = {
 	preferredLanguageInstructions: "Prefer TypeScript",
 	isTesting: true,
 	providerInfo: mockProviderInfo,
+	enableNativeToolCalls: false,
 }

-const makeMockContext = (modelId: string, providerId: string = "test"): SystemPromptContext => ({
-	...baseContext,
-	providerInfo: makeMockProviderInfo(modelId, providerId),
-})
-
 describe("Prompt System Integration Tests", () => {
 	beforeEach(() => {
 		// Reset any necessary state before each test
@@ -214,12 +210,6 @@ describe("Prompt System Integration Tests", () => {
 			providerId: "zai",
 			contextVariations,
 		},
-		{
-			modelGroup: ModelFamily.GPT_5,
-			modelIds: ["gpt-5"],
-			providerId: "openai",
-			contextVariations,
-		},
 		{
 			modelGroup: ModelFamily.NEXT_GEN,
 			modelIds: ["claude-sonnet-4"],
@@ -232,6 +222,18 @@ describe("Prompt System Integration Tests", () => {
 			providerId: "lmstudio",
 			contextVariations,
 		},
+		{
+			modelGroup: ModelFamily.NATIVE_NEXT_GEN,
+			modelIds: ["claude-4-5-sonnet"],
+			providerId: "cline",
+			contextVariations,
+		},
+		{
+			modelGroup: ModelFamily.GPT_5,
+			modelIds: ["gpt-5"],
+			providerId: "openai",
+			contextVariations,
+		},
 	]

 	// Generate snapshots for all model/context combinations
@@ -255,17 +257,18 @@ describe("Prompt System Integration Tests", () => {
 							...baseContext,
 							providerInfo: makeMockProviderInfo(modelId, providerId),
 							isTesting: true,
+							enableNativeToolCalls: modelGroup === ModelFamily.NATIVE_NEXT_GEN,
 						}
 						it(`should generate consistent prompt for ${providerId}/${modelId} with ${contextName} context`, async function () {
 							this.timeout(30000) // Allow more time for prompt generation

 							try {
-								const prompt = await getSystemPrompt(context as SystemPromptContext)
+								const { systemPrompt } = await getSystemPrompt(context as SystemPromptContext)

 								// Basic structure assertions
-								expect(prompt).to.be.a("string")
-								expect(prompt.length).to.be.greaterThan(100)
-								expect(prompt).to.not.include("{{TOOL_USE_SECTION}}") // Tools placeholder should be removed
+								expect(systemPrompt).to.be.a("string")
+								expect(systemPrompt.length).to.be.greaterThan(100)
+								expect(systemPrompt).to.not.include("{{TOOL_USE_SECTION}}") // Tools placeholder should be removed

 								// Snapshot testing logic
 								const snapshotName = `${providerId}_${modelId.replace(/[^a-zA-Z0-9]/g, "_")}-${contextName}.snap`
@@ -273,13 +276,13 @@ describe("Prompt System Integration Tests", () => {

 								if (UPDATE_SNAPSHOTS) {
 									// Update mode: write new snapshot
-									await fs.writeFile(snapshotPath, prompt, "utf-8")
-									console.log(`Updated snapshot: ${snapshotName} (${prompt.length} chars)`)
+									await fs.writeFile(snapshotPath, systemPrompt, "utf-8")
+									console.log(`Updated snapshot: ${snapshotName} (${systemPrompt.length} chars)`)
 								} else {
 									// Test mode: compare with existing snapshot
 									try {
 										const existingSnapshot = await fs.readFile(snapshotPath, "utf-8")
-										const differences = compareStrings(existingSnapshot, prompt)
+										const differences = compareStrings(existingSnapshot, systemPrompt)

 										if (differences) {
 											throw new Error(formatSnapshotError(snapshotName, differences))
@@ -325,8 +328,8 @@ describe("Prompt System Integration Tests", () => {
 			const contextWithBrowser = { ...baseContext, supportsBrowserUse: true }

 			try {
-				const prompt = await getSystemPrompt(contextWithBrowser)
-				expect(prompt.toLowerCase()).to.include("browser")
+				const { systemPrompt } = await getSystemPrompt(contextWithBrowser)
+				expect(systemPrompt.toLowerCase()).to.include("browser")
 			} catch (error) {
 				if (error instanceof Error && error.message.includes("No prompt variant found")) {
 					this.skip()
@@ -340,8 +343,8 @@ describe("Prompt System Integration Tests", () => {
 			this.timeout(30000)

 			try {
-				const prompt = await getSystemPrompt(baseContext)
-				expect(prompt).to.include("MCP")
+				const { systemPrompt } = await getSystemPrompt(baseContext)
+				expect(systemPrompt).to.include("MCP")
 			} catch (error) {
 				if (error instanceof Error && error.message.includes("No prompt variant found")) {
 					this.skip()
@@ -355,8 +358,8 @@ describe("Prompt System Integration Tests", () => {
 			this.timeout(30000)

 			try {
-				const prompt = await getSystemPrompt(baseContext)
-				expect(prompt).to.include("TODO")
+				const { systemPrompt } = await getSystemPrompt(baseContext)
+				expect(systemPrompt).to.include("TODO")
 			} catch (error) {
 				if (error instanceof Error && error.message.includes("No prompt variant found")) {
 					this.skip()
@@ -370,8 +373,8 @@ describe("Prompt System Integration Tests", () => {
 			this.timeout(30000)

 			try {
-				const prompt = await getSystemPrompt(baseContext)
-				expect(prompt).to.include("USER'S CUSTOM INSTRUCTIONS")
+				const { systemPrompt } = await getSystemPrompt(baseContext)
+				expect(systemPrompt).to.include("USER'S CUSTOM INSTRUCTIONS")
 			} catch (error) {
 				if (error instanceof Error && error.message.includes("No prompt variant found")) {
 					this.skip()
@@ -410,9 +413,9 @@ describe("Prompt System Integration Tests", () => {
 			}

 			try {
-				const prompt = await getSystemPrompt(contextWithNulls)
-				expect(prompt).to.be.a("string")
-				expect(prompt).to.include("{{TOOL_USE_SECTION}}")
+				const { systemPrompt } = await getSystemPrompt(contextWithNulls)
+				expect(systemPrompt).to.be.a("string")
+				expect(systemPrompt).to.include("{{TOOL_USE_SECTION}}")
 			} catch (error) {
 				// Error is acceptable for invalid context
 				expect(error).to.be.instanceOf(Error)
@@ -0,0 +1,128 @@
+/**
+ * Test to verify the new matcher-based variant selection works correctly
+ */
+
+import { ApiProviderInfo } from "@/core/api"
+import { McpHub } from "@/services/mcp/McpHub"
+import { ModelFamily } from "@/shared/prompts"
+import { SystemPromptContext } from "../types"
+import { VARIANT_CONFIGS } from "../variants"
+
+// Mock provider info objects for testing
+const mockProviderInfos: { name: string; providerInfo: ApiProviderInfo; expectedFamily: ModelFamily }[] = [
+	{
+		name: "GPT-5 model",
+		providerInfo: {
+			providerId: "openai",
+			model: { id: "gpt-5", info: {} as any },
+		},
+		expectedFamily: ModelFamily.GPT_5,
+	},
+	{
+		name: "Next-gen model",
+		providerInfo: {
+			providerId: "anthropic",
+			model: { id: "claude-3.5-sonnet-20241022", info: {} as any },
+		},
+		expectedFamily: ModelFamily.NEXT_GEN,
+	},
+	{
+		name: "Compact local model",
+		providerInfo: {
+			providerId: "ollama",
+			model: { id: "llama-3.2-1b", info: {} as any },
+			customPrompt: "compact",
+		},
+		expectedFamily: ModelFamily.XS,
+	},
+	{
+		name: "Generic model",
+		providerInfo: {
+			providerId: "openai",
+			model: { id: "gpt-3.5-turbo", info: {} as any },
+		},
+		expectedFamily: ModelFamily.GENERIC,
+	},
+]
+
+/**
+ * Test the matcher logic for each variant
+ */
+export function testVariantMatching() {
+	console.log("🧪 Testing variant matching logic...")
+
+	for (const { name, providerInfo, expectedFamily } of mockProviderInfos) {
+		console.log(`\n📝 Testing: ${name}`)
+		console.log(`   Model: ${providerInfo.model.id}`)
+		console.log(`   Provider: ${providerInfo.providerId}`)
+		console.log(`   Custom Prompt: ${providerInfo.customPrompt || "none"}`)
+		console.log(`   Expected Family: ${expectedFamily}`)
+
+		let matchedFamily: ModelFamily | null = null
+
+		// Test each variant's matcher function
+		for (const [familyId, config] of Object.entries(VARIANT_CONFIGS)) {
+			const mockContext = {
+				cwd: "/test/project",
+				ide: "TestIde",
+				supportsBrowserUse: true,
+				mcpHub: {
+					getServers: () => [
+						{
+							name: "test-server",
+							status: "connected",
+							config: '{"command": "test"}',
+							tools: [
+								{
+									name: "test_tool",
+									description: "A test tool",
+									inputSchema: { type: "object", properties: {} },
+								},
+							],
+							resources: [],
+							resourceTemplates: [],
+						},
+					],
+				} as unknown as McpHub,
+				focusChainSettings: {
+					enabled: true,
+					remindClineInterval: 6,
+				},
+				browserSettings: {
+					viewport: {
+						width: 1280,
+						height: 720,
+					},
+				},
+				globalClineRulesFileInstructions: "Follow global rules",
+				localClineRulesFileInstructions: "Follow local rules",
+				preferredLanguageInstructions: "Prefer TypeScript",
+				isTesting: true,
+				enableNativeToolCalls: false,
+				providerInfo,
+			} satisfies SystemPromptContext
+
+			try {
+				if (config.matcher(mockContext)) {
+					matchedFamily = familyId as ModelFamily
+					console.log(`   ✅ Matched: ${familyId}`)
+					break
+				}
+			} catch (error) {
+				console.log(`   ❌ Matcher error for ${familyId}: ${error}`)
+			}
+		}
+
+		// Check if the match is correct
+		if (matchedFamily === expectedFamily) {
+			console.log(`   🎯 PASS: Correctly matched ${expectedFamily}`)
+		} else {
+			console.log(`   🚨 FAIL: Expected ${expectedFamily}, got ${matchedFamily || "null"}`)
+		}
+	}
+
+	console.log("\n✨ Variant matching test completed!")
+}
+
+// Export for potential use in other tests
+export { mockProviderInfos }
@@ -19,7 +19,7 @@ export async function getToolUseSection(variant: PromptVariant, context: SystemP
 	})
 }

-const TOOL_USE_TEMPLATE_TEXT = `TOOL USE
+const TOOL_USE_TEMPLATE_TEXT = (_context: SystemPromptContext) => `TOOL USE

 You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.

@@ -1,6 +1,3 @@
-import { isGLMModelFamily, isGPT5ModelFamily, isLocalModel, isNextGenModelFamily } from "@utils/model-utils"
-import { ApiProviderInfo } from "@/core/api"
-import { ModelFamily } from "@/shared/prompts"
 import { PromptRegistry } from "./registry/PromptRegistry"
 import type { SystemPromptContext } from "./types"

@@ -13,32 +10,12 @@ export * from "./types"
 export { VariantBuilder } from "./variants/variant-builder"
 export { validateVariant } from "./variants/variant-validator"

-/**
- * Extract model family from model ID (e.g., "claude-4" -> "claude")
- */
-export function getModelFamily(providerInfo: ApiProviderInfo): ModelFamily {
-	if (isGPT5ModelFamily(providerInfo.model.id)) {
-		return ModelFamily.GPT_5
-	}
-	// Check for next-gen models first
-	if (isNextGenModelFamily(providerInfo.model.id)) {
-		return ModelFamily.NEXT_GEN
-	}
-	// Check for GLM models
-	if (isGLMModelFamily(providerInfo.model.id)) {
-		return ModelFamily.GLM
-	}
-	if (providerInfo.customPrompt === "compact" && isLocalModel(providerInfo)) {
-		return ModelFamily.XS
-	}
-	// Default fallback
-	return ModelFamily.GENERIC
-}
-
 /**
 * Get the system prompt by id
 */
-export async function getSystemPrompt(context: SystemPromptContext): Promise<string> {
+export async function getSystemPrompt(context: SystemPromptContext) {
 	const registry = PromptRegistry.getInstance()
-	return await registry.get(context)
+	const systemPrompt = await registry.get(context)
+	const tools = registry.nativeTools
+	return { systemPrompt, tools }
 }
@@ -1,5 +1,8 @@
+import { CLINE_MCP_TOOL_IDENTIFIER, McpServer } from "@/shared/mcp"
 import { ModelFamily } from "@/shared/prompts"
-import type { ClineToolSpec } from "../spec"
+import { ClineDefaultTool } from "@/shared/tools"
+import { type ClineToolSpec, toolSpecFunctionDeclarations, toolSpecFunctionDefinition, toolSpecInputSchema } from "../spec"
+import { PromptVariant, SystemPromptContext } from "../types"

 export class ClineToolSet {
 	// A list of tools mapped by model group
@@ -79,4 +82,115 @@ export class ClineToolSet {
 		}
 		return resolved
 	}
+
+	public static getEnabledTools(variant: PromptVariant, context: SystemPromptContext): ClineToolSet[] {
+		const resolved: ClineToolSet[] = []
+		const requestedIds = variant.tools ? [...variant.tools] : []
+		for (const id of requestedIds) {
+			const tool = ClineToolSet.getToolByNameWithFallback(id, variant.family)
+			if (tool) {
+				// Avoid duplicates by id
+				if (!resolved.some((t) => t.config.id === tool.config.id)) {
+					resolved.push(tool)
+				}
+			}
+		}
+
+		// Filter by context requirements
+		const enabledTools = resolved.filter(
+			(tool) => !tool.config.contextRequirements || tool.config.contextRequirements(context),
+		)
+
+		return enabledTools
+	}
+
+	/**
+	 * Get the appropriate native tool converter for the given provider
+	 */
+	public static getNativeConverter(providerId: string) {
+		switch (providerId) {
+			case "anthropic":
+				return toolSpecInputSchema
+			case "gemini":
+				return toolSpecFunctionDeclarations
+			default:
+				return toolSpecFunctionDefinition
+		}
+	}
+
+	public static getNativeTools(variant: PromptVariant, context: SystemPromptContext) {
+		// Only return tool functions if the variant explicitly enables them
+		// via the "use_native_tools" label set to 1
+		// This avoids exposing tools to models that don't support them
+		// or variants that aren't designed for tool use
+		if (variant.labels["use_native_tools"] !== 1 || !context.enableNativeToolCalls) {
+			return undefined
+		}
+
+		// Base set
+		const toolsets = ClineToolSet.getEnabledTools(variant, context)
+		const toolConfigs = toolsets.map((tool) => tool.config)
+
+		// MCP tools
+		const mcpServers = context.mcpHub?.getServers()?.filter((s) => s.disabled !== true) || []
+		const mcpTools = mcpServers?.flatMap((server) => mcpToolToClineToolSpec(variant.family, server))
+
+		const enabledTools = [...toolConfigs, ...mcpTools]
+		const converter = ClineToolSet.getNativeConverter(context.providerInfo.providerId)
+
+		return enabledTools.map((tool) => converter(tool, context))
+	}
+}
+
+/**
+ * Convert an MCP server's tools to ClineToolSpec format
+ */
+export function mcpToolToClineToolSpec(family: ModelFamily, server: McpServer): ClineToolSpec[] {
+	const tools = server.tools || []
+	return tools.map((mcpTool) => {
+		let parameters: any[] = []
+
+		if (mcpTool.inputSchema && "properties" in mcpTool.inputSchema) {
+			const schema = mcpTool.inputSchema as any
+			const requiredFields = new Set(schema.required || [])
+
+			parameters = Object.entries(schema.properties as Record<string, any>).map(([name, propSchema]) => {
+				// Preserve the full schema, not just basic fields
+				const param: any = {
+					name,
+					instruction: propSchema.description || "",
+					type: propSchema.type || "string",
+					required: requiredFields.has(name),
+				}
+
+				// Preserve items for array types
+				if (propSchema.items) {
+					param.items = propSchema.items
+				}
+
+				// Preserve properties for object types
+				if (propSchema.properties) {
+					param.properties = propSchema.properties
+				}
+
+				// Preserve other JSON Schema fields (enum, format, minimum, maximum, etc.)
+				for (const key in propSchema) {
+					if (!["type", "description", "items", "properties"].includes(key)) {
+						param[key] = propSchema[key]
+					}
+				}
+
+				return param
+			})
+		}
+
+		return {
+			variant: family,
+			id: ClineDefaultTool.MCP_USE,
+			// We will use the identifier to reconstruct the MCP server and tool name later
+			name: server.uid + CLINE_MCP_TOOL_IDENTIFIER + mcpTool.name,
+			description: `${server.name}: ${mcpTool.description || mcpTool.name}`,
+			parameters,
+		}
+	})
 }
@@ -1,7 +1,6 @@
 import type { ClineDefaultTool } from "@/shared/tools"
-import { getModelFamily } from "../"
 import { ClineToolSet } from "../registry/ClineToolSet"
-import type { ClineToolSpec } from "../spec"
+import { type ClineToolSpec } from "../spec"
 import { STANDARD_PLACEHOLDERS } from "../templates/placeholders"
 import { TemplateEngine } from "../templates/TemplateEngine"
 import type { ComponentRegistry, PromptVariant, SystemPromptContext } from "../types"
@@ -62,7 +61,7 @@ export class PromptBuilder {
 		// Add standard system placeholders
 		placeholders[STANDARD_PLACEHOLDERS.CWD] = this.context.cwd || process.cwd()
 		placeholders[STANDARD_PLACEHOLDERS.SUPPORTS_BROWSER] = this.context.supportsBrowserUse || false
-		placeholders[STANDARD_PLACEHOLDERS.MODEL_FAMILY] = getModelFamily(this.context.providerInfo)
+		placeholders[STANDARD_PLACEHOLDERS.MODEL_FAMILY] = this.variant.family
 		placeholders[STANDARD_PLACEHOLDERS.CURRENT_DATE] = new Date().toISOString().split("T")[0]

 		// Add all component sections
@@ -97,7 +96,7 @@ export class PromptBuilder {
 			.replace(/====\s*\n\s*====\s*\n/g, "====\n") // Remove consecutive empty sections
 			.replace(/^##\s*$[\r\n]*/gm, "") // Remove empty section headers (## with no content)
 			.replace(/\n##\s*$[\r\n]*/gm, "") // Remove empty section headers that appear mid-document
-			.replace(/====+\n(?!\n)([^\n])/g, (match, nextChar, offset, string) => {
+			.replace(/====+\n(?!\n)([^\n])/g, (match, _nextChar, offset, string) => {
 				// Add extra newline after ====+ if not already followed by a newline
 				// Exception: preserve single newlines when ====+ appears to be part of diff-like content
 				// Look for patterns like "SEARCH\n=======\n" or ";\n=======\n" (diff markers)
@@ -132,7 +131,7 @@ export class PromptBuilder {
 		}
 	}

-	public static async getToolsPrompts(variant: PromptVariant, context: SystemPromptContext) {
+	private static getEnabledTools(variant: PromptVariant, context: SystemPromptContext) {
 		let resolvedTools: ReturnType<typeof ClineToolSet.getTools> = []

 		// If the variant explicitly lists tools, resolve each by id with fallback to GENERIC
@@ -156,6 +155,12 @@ export class PromptBuilder {
 			(tool) => !tool.config.contextRequirements || tool.config.contextRequirements(context),
 		)

+		return enabledTools
+	}
+
+	public static async getToolsPrompts(variant: PromptVariant, context: SystemPromptContext) {
+		const enabledTools = PromptBuilder.getEnabledTools(variant, context)
+
 		const ids = enabledTools.map((tool) => tool.config.id)
 		return Promise.all(enabledTools.map((tool) => PromptBuilder.tool(tool.config, ids, context)))
 	}
@@ -1,5 +1,6 @@
 import { ModelFamily } from "@/shared/prompts"
-import { getModelFamily } from ".."
+import { ClineTool } from "@/shared/tools"
+import { ClineToolSet } from ".."
 import { getSystemPromptComponents } from "../components"
 import { registerClineToolSets } from "../tools"
 import type { ComponentFunction, ComponentRegistry, PromptVariant, SystemPromptContext } from "../types"
@@ -12,6 +13,7 @@ export class PromptRegistry {
 	private variants: Map<string, PromptVariant> = new Map()
 	private components: ComponentRegistry = {}
 	private loaded: boolean = false
+	public nativeTools: ClineTool[] | undefined = undefined

 	private constructor() {
 		registerClineToolSets()
@@ -65,27 +67,39 @@ export class PromptRegistry {
 		)
 	}

+	getModelFamily(context: SystemPromptContext) {
+		// Loop through all registered variants to find the first one that matches
+		for (const [id, v] of this.variants.entries()) {
+			try {
+				if (v.matcher(context)) {
+					return v.family
+				}
+			} catch (error) {
+				console.warn(`Matcher function error for variant '${id}':`, error)
+				// Continue to next variant if matcher throws
+			}
+		}
+
+		return ModelFamily.GENERIC
+	}
 	/**
-	 * Get prompt by model ID with fallback to generic
+	 * Get prompt by matching against all registered variants
 	 */
 	async get(context: SystemPromptContext): Promise<string> {
 		await this.load()

-		// Try model family fallback (e.g., "claude-4" -> "claude")
-		const modelFamily = getModelFamily(context.providerInfo)
-		let variant = this.variants.get(modelFamily ?? ModelFamily.GENERIC)
+		// Loop through all registered variants to find the first one that matches
+		const family = this.getModelFamily(context)

-		// If no variant found for the detected family, explicitly try generic
-		if (!variant && modelFamily !== ModelFamily.GENERIC) {
-			variant = this.variants.get(ModelFamily.GENERIC)
-		}
+		// Fallback to generic variant if no match found
+
+		const variant = this.variants.get(family)

 		if (!variant) {
 			// Enhanced error with debugging information
 			const availableVariants = Array.from(this.variants.keys())
 			const errorDetails = {
 				requestedModel: context.providerInfo.model.id,
-				detectedFamily: modelFamily,
 				availableVariants,
 				variantsCount: this.variants.size,
 				componentsCount: Object.keys(this.components).length,
@@ -95,12 +109,15 @@ export class PromptRegistry {
 			console.error("Prompt variant lookup failed:", errorDetails)

 			throw new Error(
-				`No prompt variant found for model '${context.providerInfo.model.id}' (family: ${modelFamily}) and no generic fallback available. ` +
+				`No prompt variant found for model '${context.providerInfo.model.id}' and no generic fallback available. ` +
 					`Available variants: [${availableVariants.join(", ")}]. ` +
 					`Registry state: loaded=${this.loaded}, variants=${this.variants.size}, components=${Object.keys(this.components).length}`,
 			)
 		}

+		// Hacky way to get native tools for the current variant - it's bad and ugly
+		this.nativeTools = ClineToolSet.getNativeTools(variant, context)
+
 		const builder = new PromptBuilder(variant, context, this.components)
 		return await builder.build()
 	}
@@ -1,4 +1,7 @@
-import type { ModelFamily } from "@/shared/prompts"
+import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
+import { FunctionDeclaration as GoogleTool, Type as GoogleToolParamType } from "@google/genai"
+import { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
+import { ModelFamily } from "@/shared/prompts"
 import type { ClineDefaultTool } from "@/shared/tools"
 import type { SystemPromptContext } from "./types"

@@ -20,4 +23,314 @@ interface ClineToolSpecParameter {
 	dependencies?: ClineDefaultTool[]
 	description?: string
 	contextRequirements?: (context: SystemPromptContext) => boolean
+	// TODO: Confirm if "integer" is actually supported across providers
+	/**
+	 * The type of the parameter. Default to string if not provided.
+	 * Supported types: string, boolean, integer, array, object
+	 */
+	type?: "string" | "boolean" | "integer" | "array" | "object"
+	/**
+	 * For array types, this defines the schema of array items
+	 */
+	items?: any
+	/**
+	 * For object types, this defines the properties
+	 */
+	properties?: Record<string, any>
+	/**
+	 * Additional JSON Schema fields to preserve from MCP tools
+	 */
+	[key: string]: any
+}
+
+/**
+ * Converts a ClineToolSpec into an OpenAI ChatCompletionTool definition
+ * Docs: https://openrouter.ai/docs/features/tool-calling#step-1-inference-request-with-tools
+ */
+export function toolSpecFunctionDefinition(tool: ClineToolSpec, context: SystemPromptContext): OpenAITool {
+	// Check if the tool should be included based on context requirements
+	if (tool.contextRequirements && !tool.contextRequirements(context)) {
+		throw new Error(`Tool ${tool.name} does not meet context requirements`)
+	}
+
+	// Build the properties object for parameters
+	const properties: Record<string, any> = {}
+	const required: string[] = []
+
+	if (tool.parameters) {
+		for (const param of tool.parameters) {
+			// Check if parameter should be included based on context requirements
+			if (param.contextRequirements && !param.contextRequirements(context)) {
+				continue
+			}
+
+			// Add to required array if parameter is required
+			if (param.required) {
+				required.push(param.name)
+			}
+
+			// Determine parameter type - use explicit type if provided.
+			// Default to string
+			const paramType: string = param.type || "string"
+
+			// Build parameter schema
+			const paramSchema: any = {
+				type: paramType,
+				description: replacer(param.instruction, context),
+			}
+
+			// Add items for array types
+			if (paramType === "array" && param.items) {
+				paramSchema.items = param.items
+			}
+
+			// Add properties for object types
+			if (paramType === "object" && param.properties) {
+				paramSchema.properties = param.properties
+			}
+
+			// Preserve any additional JSON Schema fields from MCP tools
+			// (e.g., enum, format, minimum, maximum, etc.)
+			const reservedKeys = new Set([
+				"name",
+				"required",
+				"instruction",
+				"usage",
+				"dependencies",
+				"description",
+				"contextRequirements",
+				"type",
+				"items",
+				"properties",
+			])
+			for (const key in param) {
+				if (!reservedKeys.has(key) && param[key] !== undefined) {
+					paramSchema[key] = param[key]
+				}
+			}
+
+			// Add usage example as part of description if available
+			// if (param.usage) {
+			// 	paramSchema.description += ` Example: ${param.usage}`
+			// }
+
+			properties[param.name] = paramSchema
+		}
+	}
+
+	// Build the ChatCompletionTool object
+	const chatCompletionTool: OpenAITool = {
+		type: "function",
+		function: {
+			name: tool.name,
+			description: replacer(tool.description, context),
+			strict: false,
+			parameters: {
+				type: "object",
+				properties,
+				required,
+				additionalProperties: false,
+			},
+		},
+	}
+
+	return chatCompletionTool
+}
+
+/**
+ * Converts a ClineToolSpec into an Anthropic Tool definition
+ */
+export function toolSpecInputSchema(tool: ClineToolSpec, context: SystemPromptContext): AnthropicTool {
+	// Check if the tool should be included based on context requirements
+	if (tool.contextRequirements && !tool.contextRequirements(context)) {
+		throw new Error(`Tool ${tool.name} does not meet context requirements`)
+	}
+
+	// Build the properties object for parameters
+	const properties: Record<string, any> = {}
+	const required: string[] = []
+
+	if (tool.parameters) {
+		for (const param of tool.parameters) {
+			// Check if parameter should be included based on context requirements
+			if (param.contextRequirements && !param.contextRequirements(context)) {
+				continue
+			}
+
+			// Add to required array if parameter is required
+			if (param.required) {
+				required.push(param.name)
+			}
+
+			// Determine parameter type - use explicit type if provided.
+			// Default to string
+			const paramType: string = param.type || "string"
+
+			// Build parameter schema
+			const paramSchema: any = {
+				type: paramType,
+				description: replacer(param.instruction, context),
+			}
+
+			// Add items for array types
+			if (paramType === "array" && param.items) {
+				paramSchema.items = param.items
+			}
+
+			// Add properties for object types
+			if (paramType === "object" && param.properties) {
+				paramSchema.properties = param.properties
+			}
+
+			// Preserve any additional JSON Schema fields from MCP tools
+			// (e.g., enum, format, minimum, maximum, etc.)
+			const reservedKeys = new Set([
+				"name",
+				"required",
+				"instruction",
+				"usage",
+				"dependencies",
+				"description",
+				"contextRequirements",
+				"type",
+				"items",
+				"properties",
+			])
+			for (const key in param) {
+				if (!reservedKeys.has(key) && param[key] !== undefined) {
+					paramSchema[key] = param[key]
+				}
+			}
+
+			// Add usage example as part of description if available
+			// if (param.usage) {
+			// 	paramSchema.description += ` Example: ${param.usage}`
+			// }
+
+			properties[param.name] = paramSchema
+		}
+	}
+
+	// Build the Tool object
+	const toolInputSchema: AnthropicTool = {
+		name: tool.name,
+		description: replacer(tool.description, context),
+		input_schema: {
+			type: "object",
+			properties,
+			required,
+		},
+	}
+
+	return toolInputSchema
+}
+
+/**
+ * Converts a ClineToolSpec into a Google Gemini function.
+ * Docs: https://ai.google.dev/gemini-api/docs/function-calling
+ */
+export function toolSpecFunctionDeclarations(tool: ClineToolSpec, context: SystemPromptContext): GoogleTool {
+	// Check if the tool should be included based on context requirements
+	if (tool.contextRequirements && !tool.contextRequirements(context)) {
+		throw new Error(`Tool ${tool.name} does not meet context requirements`)
+	}
+
+	// Build the parameters object for parameters
+	const properties: Record<string, any> = {}
+	const required: string[] = []
+
+	if (tool.parameters) {
+		for (const param of tool.parameters) {
+			// Check if parameter should be included based on context requirements
+			if (param.contextRequirements && !param.contextRequirements(context)) {
+				continue
+			}
+
+			// Add to required array if parameter is required
+			if (param.required) {
+				required.push(param.name)
+			}
+
+			// Determine parameter type - use explicit type if provided.
+			// Default to string
+			const paramType: string = param.type || GoogleToolParamType.STRING
+
+			// Build parameter schema
+			const paramSchema: any = {
+				type: paramType,
+				items: paramType === GoogleToolParamType.ARRAY ? { type: GoogleToolParamType.STRING } : undefined,
+				description: replacer(param.instruction, context),
+			}
+			properties[param.name] = paramSchema
+		}
+	}
+
+	const googleTool: GoogleTool = {
+		name: tool.name,
+		description: replacer(tool.description, context),
+		parameters: {
+			type: GoogleToolParamType.OBJECT,
+			properties,
+			required,
+		},
+	}
+
+	return googleTool
+}
+
+/**
+ * Converts an OpenAI ChatCompletionTool into an Anthropic Tool definition
+ */
+export function openAIToolToAnthropic(openAITool: OpenAITool): AnthropicTool {
+	const func = openAITool.function
+
+	return {
+		name: func.name,
+		description: func.description || "",
+		input_schema: {
+			type: "object",
+			properties: func.parameters?.properties || {},
+			required: func.parameters?.required || [],
+		},
+	}
+}
+
+type OpenAIResponseTool = {
+	type: "function"
+	function: {
+		name: string
+		description: string
+		strict: boolean
+		parameters: {
+			type: "object"
+			properties: Record<string, any>
+			required: string[]
+			additionalProperties?: boolean
+		}
+	}
+}
+
+/**
+ * Converts an OpenAI ChatCompletionTool into Response API format.
+ */
+export function toOpenAIResponsesAPITool(openAITool: OpenAITool): OpenAIResponseTool {
+	return {
+		type: "function",
+		function: {
+			name: openAITool.function.name,
+			description: openAITool.function.description || "",
+			strict: openAITool.function.strict || false,
+			parameters: {
+				type: "object",
+				properties: openAITool.function.parameters?.properties || {},
+				required: openAITool.function.parameters?.required ? (openAITool.function.parameters?.required as string[]) : [],
+			},
+		},
+	} satisfies OpenAIResponseTool
+}
+
+function replacer(description: string, context: SystemPromptContext) {
+	return description
+		.replace("{{BROWSER_VIEWPORT_WIDTH}}", `${context.browserSettings?.viewport?.width || 900}`)
+		.replace("{{BROWSER_VIEWPORT_HEIGHT}}", `${context.browserSettings?.viewport?.height || 600}`)
 }
@@ -0,0 +1,96 @@
+import { ModelFamily } from "@/shared/prompts"
+import { ClineDefaultTool } from "@/shared/tools"
+import type { ClineToolSpec } from "../spec"
+import { TASK_PROGRESS_PARAMETER } from "../types"
+
+// {
+//     "name": "apply_patch",
+//     "description": APPLY_PATCH_TOOL_DESC,
+//     "parameters": {
+//         "type": "object",
+//         "properties": {
+//             "input": {
+//                 "type": "string",
+//                 "description": " The apply_patch command that you wish to execute.",
+//             }
+//         },
+//         "required": ["input"],
+//     },
+// }
+
+const APPLY_PATCH_TOOL_DESC = `This is a custom utility that makes it more convenient to add, remove, move, or edit code files. \`apply_patch\` effectively allows you to execute a diff/patch against a file, but the format of the diff specification is unique to this task, so pay careful attention to these instructions. To use the \`apply_patch\` command, you should pass a message of the following structure as "input":
+
+%%bash
+apply_patch <<"EOF"
+*** Begin Patch
+[YOUR_PATCH]
+*** End Patch
+EOF
+
+Where [YOUR_PATCH] is the actual content of your patch, specified in the following V4A diff format.
+
+*** [ACTION] File: [path/to/file] -> ACTION can be one of Add, Update, or Delete.
+For each snippet of code that needs to be changed, repeat the following:
+[context_before] -> See below for further instructions on context.
+- [old_code] -> Precede the old code with a minus sign.
+ [new_code] -> Precede the new, replacement code with a plus sign.
+[context_after] -> See below for further instructions on context.
+
+For instructions on [context_before] and [context_after]:
+- By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change’s [context_after] lines in the second change’s [context_before] lines.
+- If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
+@@ class BaseClass
+[3 lines of pre-context]
+- [old_code]
+ [new_code]
+[3 lines of post-context]
+
+- If a code block is repeated so many times in a class or function such that even a single @@ statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple \`@@\` statements to jump to the right context. For instance:
+
+@@ class BaseClass
+@@ 	def method():
+[3 lines of pre-context]
+- [old_code]
+ [new_code]
+[3 lines of post-context]
+
+Note, then, that we do not use line numbers in this diff format, as the context is enough to uniquely identify code. An example of a message that you might pass as "input" to this function, in order to apply a patch, is shown below.
+
+%%bash
+apply_patch <<"EOF"
+*** Begin Patch
+*** Update File: pygorithm/searching/binary_search.py
+@@ class BaseClass
+@@     def search():
+-          pass
+          raise NotImplementedError()
+
+@@ class Subclass
+@@     def search():
+-          pass
+          raise NotImplementedError()
+
+*** End Patch
+EOF`
+
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
+	id: ClineDefaultTool.APPLY_PATCH,
+	name: "apply_patch",
+	description: APPLY_PATCH_TOOL_DESC,
+	contextRequirements: (context) => context.providerInfo.model.id.includes("gpt-5"),
+	parameters: [
+		{
+			name: "input",
+			required: true,
+			instruction: "The apply_patch command that you wish to execute.",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}
+
+const GPT_5: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.GPT_5,
+}
+export const apply_patch_variants = [NATIVE_GPT_5, GPT_5]
@@ -29,8 +29,32 @@ const generic: ClineToolSpec = {
 	],
 }

-const nextGen = { ...generic, variant: ModelFamily.NEXT_GEN }
-const gpt = { ...generic, variant: ModelFamily.GPT }
-const gemini = { ...generic, variant: ModelFamily.GEMINI }
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id: ClineDefaultTool.ASK,
+	name: "ask_followup_question",
+	description:
+		"Ask user a question for clarifying or gathering information needed to complete the task. For example, ask the user how you can help in response to a simple greeting message.",
+	contextRequirements: (context) => !context.yoloModeToggled,
+	parameters: [
+		{
+			name: "question",
+			required: true,
+			instruction: 'The question to ask the user. E.g. "How can I help you?"',
+		},
+		{
+			name: "options",
+			required: false,
+			instruction:
+				'An array of 2-5 options (e.x: "["Option 1", "Option 2", "Option 3"]") for the user to choose from related to the question. Each option should be a string describing a possible answer. You may not always need to provide options, but it may be helpful in many cases where it can save the user from having to type out a response manually. IMPORTANT: NEVER include an option to toggle to Act mode, as this would be something you need to direct the user to do manually themselves if needed.',
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}

-export const ask_followup_question_variants = [generic, nextGen, gpt, gemini]
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const ask_followup_question_variants = [generic, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -38,7 +38,7 @@ IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user th
 	],
 }

-const gpt5: ClineToolSpec = {
+const GPT_5: ClineToolSpec = {
 	variant: ModelFamily.GPT_5,
 	id,
 	name: "attempt_completion",
@@ -72,4 +72,36 @@ IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user th
 	],
 }

-export const attempt_completion_variants = [generic, gpt5]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id,
+	name: "attempt_completion",
+	description:
+		"Once you've completed the user's task, use this tool to present the final result to the user, including a summary of the task and what was done to resolve it.",
+	parameters: [
+		{
+			name: "result",
+			required: true,
+			instruction: "A clear, specific description of the final result of the task.",
+		},
+		{
+			name: "command",
+			required: false,
+			instruction:
+				"An actionable terminal command that is non-verbose that allows user to review the result of your work. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. Commands like \`echo\` or \`cat\` that merely print text are not allowed. Ensure the command is properly formatted for user's OS and does not contain any harmful instructions",
+		},
+		{
+			name: "task_progress",
+			required: false,
+			dependencies: [ClineDefaultTool.TODO],
+			instruction: "A checklist showing task progress with the latest status of each subtasks included previously if any.",
+		},
+	],
+}
+
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const attempt_completion_variants = [generic, GPT_5, NATIVE_NEXT_GEN, NATIVE_GPT_5]
@@ -4,7 +4,7 @@ import type { ClineToolSpec } from "../spec"

 const id = ClineDefaultTool.BROWSER

-const generic: ClineToolSpec = {
+const GENERIC: ClineToolSpec = {
 	variant: ModelFamily.GENERIC,
 	id,
 	name: "browser_action",
@@ -57,4 +57,50 @@ const generic: ClineToolSpec = {
 	],
 }

-export const browser_action_variants = [generic]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id,
+	name: "browser_action",
+	description: `Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
+- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
+- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
+- The browser window has a resolution of **{{BROWSER_VIEWPORT_WIDTH}}x{{BROWSER_VIEWPORT_HEIGHT}}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
+- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.`,
+	contextRequirements: (context) => context.supportsBrowserUse === true,
+	parameters: [
+		{
+			name: "action",
+			required: true,
+			instruction: `The action to perform. The available actions are: 
+	* launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**. 
+		- Use with the \`url\` parameter to provide the URL. 
+		- Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.) 
+	* click: Click at a specific x,y coordinate. 
+		- Use with the \`coordinate\` parameter to specify the location. 
+		- Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot. 
+	* type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text. 
+		- Use with the \`text\` parameter to provide the string to type. 
+	* scroll_down: Scroll down the page by one page height. 
+	* scroll_up: Scroll up the page by one page height. 
+	* close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**. 
+	    - Example: 'scroll_up'`,
+		},
+		{
+			name: "url",
+			required: false,
+			instruction: `Use this for providing the URL for the \`launch\` action.`,
+		},
+		{
+			name: "coordinate",
+			required: false,
+			instruction: `x,y coordinates - The X and Y coordinates for the \`click\` action. Coordinates should be within the **{{BROWSER_VIEWPORT_WIDTH}}x{{BROWSER_VIEWPORT_HEIGHT}}** resolution. Example: '450,300'`,
+		},
+		{
+			name: "text",
+			required: false,
+			instruction: `Use this for providing the text for the \`type\` action. Example: 'Hello, world!'`,
+		},
+	],
+}
+
+export const browser_action_variants = [GENERIC, NATIVE_NEXT_GEN]
@@ -1,9 +1,8 @@
 import { ModelFamily } from "@/shared/prompts"
 import { ClineDefaultTool } from "@/shared/tools"
 import type { ClineToolSpec } from "../spec"
-import { TASK_PROGRESS_PARAMETER } from "../types"

-const generic: ClineToolSpec = {
+const GENERIC: ClineToolSpec = {
 	variant: ModelFamily.GENERIC,
 	id: ClineDefaultTool.BASH,
 	name: "execute_command",
@@ -21,10 +20,12 @@ const generic: ClineToolSpec = {
 			instruction:
 				"A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.",
 			usage: "true or false",
+			type: "boolean",
 		},
 		{
 			name: "timeout",
 			required: false,
+			type: "integer",
 			contextRequirements: (context) => context.yoloModeToggled === true,
 			instruction:
 				"Integer representing the timeout in seconds for how long to run the terminal command, before timing out and continuing the task.",
@@ -33,34 +34,32 @@ const generic: ClineToolSpec = {
 	],
 }

-const gpt: ClineToolSpec = {
-	variant: ModelFamily.GPT,
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
 	id: ClineDefaultTool.BASH,
-	name: "bash",
+	name: ClineDefaultTool.BASH,
 	description:
-		"Run an arbitrary terminal command at the root of the users project. E.g. `ls -la` for listing files, or `find` for searching latest version of the codebase files locally.",
+		"Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task.",
 	parameters: [
 		{
 			name: "command",
 			required: true,
-			instruction: "The command to run in the root of the users project. Must be shell escaped.",
-			usage: "Your command here",
+			instruction:
+				"The CLI command to execute. This should be valid for the current operating system. Do not use the ~ character or $HOME to refer to the home directory. Always use absolute paths.",
 		},
 		{
 			name: "requires_approval",
-			required: false,
-			instruction: "Whether the command is dangerous. If true, user will be asked to confirm.",
-		},
-		{
-			name: "timeout",
-			required: false,
-			contextRequirements: (context) => context.yoloModeToggled === true,
+			required: true,
 			instruction:
-				"Integer representing the timeout in seconds for how long to run the terminal command, before timing out and continuing the task.",
-			usage: "30",
+				"To indicate whether this command requires explicit user approval or interaction before it should be executed. For system/file altering operations like installing/uninstalling packages, removing/overwriting files, system configuration changes, network operations, or any commands that are considered potentially dangerous must be set to true. False for safe operations like running development servers, building projects, and other non-destructive operations.",
+			type: "boolean",
 		},
-		TASK_PROGRESS_PARAMETER,
 	],
 }

-export const execute_command_variants = [generic, gpt]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+}
+
+export const execute_command_variants: ClineToolSpec[] = [GENERIC, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -11,8 +11,4 @@ const generic: ClineToolSpec = {
 	contextRequirements: (context) => context.focusChainSettings?.enabled === true,
 }

-const nextGen = { ...generic, variant: ModelFamily.NEXT_GEN }
-const gpt = { ...generic, variant: ModelFamily.GPT }
-const gemini = { ...generic, variant: ModelFamily.GEMINI }
-
-export const focus_chain_variants = [generic, nextGen, gpt, gemini]
+export const focus_chain_variants = [generic]
@@ -1,4 +1,5 @@
 export * from "./access_mcp_resource"
+export * from "./apply_patch"
 export * from "./ask_followup_question"
 export * from "./attempt_completion"
 export * from "./browser_action"
@@ -1,6 +1,7 @@
 // Import all tool variants
 import { ClineToolSet } from "../registry/ClineToolSet"
 import { access_mcp_resource_variants } from "./access_mcp_resource"
+import { apply_patch_variants } from "./apply_patch"
 import { ask_followup_question_variants } from "./ask_followup_question"
 import { attempt_completion_variants } from "./attempt_completion"
 import { browser_action_variants } from "./browser_action"
@@ -43,6 +44,7 @@ export function registerClineToolSets(): void {
 		...use_mcp_tool_variants,
 		...web_fetch_variants,
 		...write_to_file_variants,
+		...apply_patch_variants,
 	]

 	// Register each variant
@@ -22,4 +22,25 @@ const generic: ClineToolSpec = {
 	],
 }

-export const list_code_definition_names_variants = [generic]
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
+	id,
+	name: "list_code_definition_names",
+	description:
+		"Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.",
+	parameters: [
+		{
+			name: "path",
+			required: true,
+			instruction: `The path of the directory (relative to the current working directory {{CWD}}){{MULTI_ROOT_HINT}} to list top level source code definitions for.`,
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}
+
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+}
+
+export const list_code_definition_names_variants = [generic, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -24,9 +24,37 @@ const generic: ClineToolSpec = {
 			required: false,
 			instruction: "Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.",
 			usage: "true or false (optional)",
+			type: "boolean",
 		},
 		TASK_PROGRESS_PARAMETER,
 	],
 }

-export const list_files_variants = [generic]
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
+	id,
+	name: "list_files",
+	description:
+		"Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.",
+	parameters: [
+		{
+			name: "path",
+			required: true,
+			instruction: "The path of the directory to list contents for.",
+		},
+		{
+			name: "recursive",
+			required: false,
+			instruction: "Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.",
+			type: "boolean",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}
+
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+}
+
+export const list_files_variants = [generic, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -41,6 +41,7 @@ However, if while writing your response you realize you actually need to do more
 			instruction:
 				"Set to true if while formulating your response that you found you need to do more exploration with tools, for example reading files. (Remember, you can explore the project with tools like read_file in PLAN MODE without the user having to toggle to ACT MODE.) Defaults to false if not specified.",
 			usage: "true or false (optional, but you MUST set to true if in <response> you need to read files or use other exploration tools)",
+			type: "boolean",
 		},
 		// Different than the vanilla TASK_PROGRESS_PARAMETER
 		{
@@ -54,4 +55,30 @@ However, if while writing your response you realize you actually need to do more
 	],
 }

-export const plan_mode_respond_variants = [generic]
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
+	id,
+	name: "plan_mode_respond",
+	description: `Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should ONLY be used when you have already explored the relevant files and are ready to present a concrete plan. DO NOT use this tool to announce what files you're going to read - just read them first. This tool is only available in PLAN MODE. The environment_details will specify the current mode; if it is not PLAN_MODE then you should not use this tool.
+However, if while writing your response you realize you actually need to do more exploration before providing a complete plan, you can add the optional needs_more_exploration parameter to indicate this. This allows you to acknowledge that you should have done more exploration first, and signals that your next message will use exploration tools instead.`,
+	parameters: [
+		{
+			name: "response",
+			required: true,
+			instruction: `The response to provide to the user. Do not try to use tools in this parameter, this is simply a chat response. (You MUST use the response parameter, do not simply place the response text directly within <plan_mode_respond> tags.)`,
+			usage: "Your response here",
+		},
+		{
+			name: "task_progress",
+			required: false,
+			instruction: "A checklist showing task progress with the latest status of each subtasks included previously if any.",
+		},
+	],
+}
+
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+}
+
+export const plan_mode_respond_variants = [generic, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -22,8 +22,26 @@ const generic: ClineToolSpec = {
 	],
 }

-const nextGen = { ...generic, variant: ModelFamily.NEXT_GEN }
-const gpt = { ...generic, variant: ModelFamily.GPT }
-const gemini = { ...generic, variant: ModelFamily.GEMINI }
+const NATIVE_GPT_5: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_GPT_5,
+	id,
+	name: "read_file",
+	description:
+		"Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string. Do NOT use this tool to list the contents of a directory. Only use this tool on files.",
+	parameters: [
+		{
+			name: "path",
+			required: true,
+			instruction: `The path of the file to read (relative to the current working directory {{CWD}}){{MULTI_ROOT_HINT}}`,
+			usage: "File path here",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}

-export const read_file_variants = [generic, nextGen, gpt, gemini]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	...NATIVE_GPT_5,
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+}
+
+export const read_file_variants = [generic, NATIVE_NEXT_GEN, NATIVE_GPT_5]
@@ -51,8 +51,53 @@ const generic: ClineToolSpec = {
 	],
 }

-const nextGen = { ...generic, variant: ModelFamily.NEXT_GEN }
-const gpt = { ...generic, variant: ModelFamily.GPT }
-const gemini = { ...generic, variant: ModelFamily.GEMINI }
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id,
+	name: "replace_in_file",
+	description:
+		"[IMPORTANT: Always output the absolutePath first] Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+	parameters: [
+		{
+			name: "absolutePath",
+			required: true,
+			instruction: "The absolute path to the file to write to.",
+		},
+		{
+			name: "diff",
+			required: true,
+			instruction: `One or more SEARCH/REPLACE blocks following this exact format:
+  \`\`\`
+  ------- SEARCH
+  [exact content to find]
+  =======
+  [new content to replace with]
+  +++++++ REPLACE
+  \`\`\`
+  Critical rules:
+  1. SEARCH content must match the associated file section to find EXACTLY:
+	 * Match character-for-character including whitespace, indentation, line endings
+	 * Include all comments, docstrings, etc.
+  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
+	 * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
+	 * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+	 * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
+  3. Keep SEARCH/REPLACE blocks concise:
+	 * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
+	 * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+	 * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
+	 * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
+  4. Special operations:
+	 * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
+	 * To delete code: Use empty REPLACE section`,
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}

-export const replace_in_file_variants = [generic, nextGen, gpt, gemini]
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const replace_in_file_variants = [generic, NATIVE_NEXT_GEN, NATIVE_GPT_5]
@@ -50,4 +50,39 @@ const generic: ClineToolSpec = {
 	],
 }

-export const search_files_variants = [generic]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id,
+	name: "search_files",
+	description:
+		"Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.",
+	parameters: [
+		{
+			name: "path",
+			required: true,
+			instruction: `The path of the directory to search in (relative to the current working directory {{CWD}}){{MULTI_ROOT_HINT}}. This directory will be recursively searched.`,
+			usage: "Directory path here",
+		},
+		{
+			name: "regex",
+			required: true,
+			instruction: "The regular expression pattern to search for. Uses Rust regex syntax.",
+			usage: "Your regex pattern here",
+		},
+		{
+			name: "file_pattern",
+			required: false,
+			instruction:
+				"Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).",
+			usage: "file pattern here (optional)",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}
+
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const search_files_variants = [generic, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -66,8 +66,4 @@ const generic: ClineToolSpec = {
 	],
 }

-const nextGen = { ...generic, variant: ModelFamily.NEXT_GEN }
-const gpt = { ...generic, variant: ModelFamily.GPT }
-const gemini = { ...generic, variant: ModelFamily.GEMINI }
-
-export const use_mcp_tool_variants = [generic, nextGen, gpt, gemini]
+export const use_mcp_tool_variants = [generic]
@@ -26,6 +26,24 @@ const nextGen: ClineToolSpec = {
 	],
 }

-const gpt = { ...nextGen, variant: ModelFamily.GPT }
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id: ClineDefaultTool.WEB_FETCH,
+	name: "web_fetch",
+	description: "Fetches content from a specified URL. Only used for gathering needed information relevant to the task.",
+	parameters: [
+		{
+			name: "url",
+			required: true,
+			instruction: "The URL to fetch content from",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}

-export const web_fetch_variants = [nextGen, gpt]
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const web_fetch_variants = [nextGen, NATIVE_GPT_5, NATIVE_NEXT_GEN]
@@ -24,7 +24,7 @@ Checklist here (optional)

 const id = ClineDefaultTool.FILE_NEW

-const generic: ClineToolSpec = {
+const GENERIC: ClineToolSpec = {
 	variant: ModelFamily.GENERIC,
 	id,
 	name: "write_to_file",
@@ -48,4 +48,31 @@ const generic: ClineToolSpec = {
 	],
 }

-export const write_to_file_variants = [generic]
+const NATIVE_NEXT_GEN: ClineToolSpec = {
+	variant: ModelFamily.NATIVE_NEXT_GEN,
+	id,
+	name: "write_to_file",
+	description:
+		"[IMPORTANT: Always output the absolutePath first] Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.",
+	parameters: [
+		{
+			name: "absolutePath",
+			required: true,
+			instruction: "The absolute path to the file to write to.",
+		},
+		{
+			name: "content",
+			required: true,
+			instruction:
+				"After providing the path so a file can be created, then use this to provide the content to write to the file.",
+		},
+		TASK_PROGRESS_PARAMETER,
+	],
+}
+
+const NATIVE_GPT_5: ClineToolSpec = {
+	...NATIVE_NEXT_GEN,
+	variant: ModelFamily.NATIVE_GPT_5,
+}
+
+export const write_to_file_variants = [GENERIC, NATIVE_NEXT_GEN, NATIVE_GPT_5]
@@ -30,6 +30,7 @@ export interface PromptVariant {
 	readonly labels: Readonly<Record<string, number>> // Immutable labels mapping
 	readonly family: ModelFamily // Model family enum
 	readonly description: string // Brief description of the variant
+	readonly matcher: (context: SystemPromptContext) => boolean // Function to determine if this variant should be used for the given providerInfo

 	// Prompt configuration
 	readonly config: PromptConfig // Model-specific config
@@ -53,6 +54,7 @@ export interface MutablePromptVariant {
 	labels: Record<string, number>
 	family: ModelFamily
 	description?: string
+	matcher?: (providerInfo: ApiProviderInfo) => boolean
 	config: PromptConfig
 	baseTemplate?: string
 	componentOrder: SystemPromptSection[]
@@ -110,6 +112,7 @@ export interface SystemPromptContext {
 	readonly workspaceRoots?: Array<{ path: string; name: string; vcs?: string }>
 	readonly isSubagentsEnabledAndCliInstalled?: boolean
 	readonly isCliSubagent?: boolean
+	readonly enableNativeToolCalls?: boolean
 }

 /**
@@ -182,6 +185,7 @@ export interface VariantBuilder {
 	version(version: number): this
 	tags(...tags: string[]): this
 	labels(labels: Record<string, number>): this
+	matcher(matcherFn: (providerInfo: ApiProviderInfo) => boolean): this
 	template(baseTemplate: string): this
 	components(...sections: SystemPromptSection[]): this
 	overrideComponent(section: SystemPromptSection, override: ConfigOverride): this
@@ -1,3 +1,4 @@
+import { isGLMModelFamily, isLocalModel, isNextGenModelFamily, isNextGenModelProvider } from "@utils/model-utils"
 import { ModelFamily } from "@/shared/prompts"
 import { ClineDefaultTool } from "@/shared/tools"
 import { SystemPromptSection } from "../../templates/placeholders"
@@ -13,6 +14,23 @@ export const config = createVariant(ModelFamily.GENERIC)
 		stable: 1,
 		fallback: 1,
 	})
+	// Generic matcher - fallback for everything that doesn't match other variants
+	// This will match anything that doesn't match the other specific variants
+	.matcher((context) => {
+		const providerInfo = context.providerInfo
+		if (!providerInfo.providerId || !providerInfo.model.id) {
+			return true
+		}
+		const modelId = providerInfo.model.id.toLowerCase()
+		return (
+			// Not a local model with compact prompt enabled
+			!(providerInfo.customPrompt === "compact" && isLocalModel(providerInfo)) &&
+			// Not a next-gen model
+			!(isNextGenModelProvider(providerInfo) && isNextGenModelFamily(modelId)) &&
+			// Not a GLM model
+			!isGLMModelFamily(modelId)
+		)
+	})
 	.template(baseTemplate)
 	.components(
 		SystemPromptSection.AGENT_ROLE,
@@ -1,5 +1,6 @@
 import { ModelFamily } from "@/shared/prompts"
 import { ClineDefaultTool } from "@/shared/tools"
+import { isGLMModelFamily } from "@/utils/model-utils"
 import { SystemPromptSection } from "../../templates/placeholders"
 import { createVariant } from "../variant-builder"
 import { validateVariant } from "../variant-validator"
@@ -14,6 +15,9 @@ export const config = createVariant(ModelFamily.GLM)
 		stable: 1,
 		production: 1,
 	})
+	.matcher((context) => {
+		return isGLMModelFamily(context.providerInfo.model.id)
+	})
 	.template(baseTemplate)
 	.components(
 		SystemPromptSection.AGENT_ROLE,
@@ -49,7 +53,7 @@ export const config = createVariant(ModelFamily.GLM)
 		ClineDefaultTool.TODO,
 	)
 	.placeholders({
-		MODEL_FAMILY: "glm",
+		MODEL_FAMILY: ModelFamily.GLM,
 	})
 	.config({})
 	// Apply GLM-specific component overrides
@@ -1,13 +1,14 @@
+import { isGPT5ModelFamily, isNextGenModelProvider } from "@utils/model-utils"
 import { ModelFamily } from "@/shared/prompts"
 import { ClineDefaultTool } from "@/shared/tools"
 import { SystemPromptSection } from "../../templates/placeholders"
 import { createVariant } from "../variant-builder"
 import { validateVariant } from "../variant-validator"
-import { baseTemplate, rules_template } from "./template"
+import { GPT_5_TEMPLATE_OVERRIDES } from "./template"

 // Type-safe variant configuration using the builder pattern
 export const config = createVariant(ModelFamily.GPT_5)
-	.description("Prompt tailored to GPT-5")
+	.description("Prompt tailored to GPT-5 with text-based tools")
 	.version(1)
 	.tags("gpt", "gpt-5", "advanced", "production")
 	.labels({
@@ -15,7 +16,18 @@ export const config = createVariant(ModelFamily.GPT_5)
 		production: 1,
 		advanced: 1,
 	})
-	.template(baseTemplate)
+	// Match GPT-5 models from providers that support native tools
+	.matcher((context) => {
+		const providerInfo = context.providerInfo
+		const modelId = providerInfo.model.id
+		return (
+			isGPT5ModelFamily(modelId) &&
+			!modelId.includes("chat") &&
+			isNextGenModelProvider(providerInfo) &&
+			!context.enableNativeToolCalls
+		)
+	})
+	.template(GPT_5_TEMPLATE_OVERRIDES.BASE)
 	.components(
 		SystemPromptSection.AGENT_ROLE,
 		SystemPromptSection.TOOL_USE,
@@ -57,12 +69,12 @@ export const config = createVariant(ModelFamily.GPT_5)
 	.config({})
 	// Override the RULES component with custom template
 	.overrideComponent(SystemPromptSection.RULES, {
-		template: rules_template,
+		template: GPT_5_TEMPLATE_OVERRIDES.RULES,
 	})
 	.build()

 // Compile-time validation
-const validationResult = validateVariant({ ...config, id: "gpt-5" }, { strict: true })
+const validationResult = validateVariant({ ...config, id: ModelFamily.GPT_5 }, { strict: true })
 if (!validationResult.isValid) {
 	console.error("GPT-5 variant configuration validation failed:", validationResult.errors)
 	throw new Error(`Invalid GPT-5 variant configuration: ${validationResult.errors.join(", ")}`)
--- a/Show More
+++ b/Show More