fix(context): require a context-specific message for Anthropic overflow (#12876)

checkIsAnthropicContextWindowError matched every nested Anthropic
invalid_request_error, but Anthropic uses that type for many conditions
unrelated to context size — invalid tool schema, oversized image, unknown
model id, out-of-range max_tokens, malformed messages.

Every sibling detector in this file gates on a status/type *and* a
context-specific message pattern; the Anthropic branch was the only one
that did not. Add the same message gate, reusing the overflow patterns
the Vercel and Bedrock branches already use for these Anthropic-authored
wire messages.

Both the provider message (error.error.message) and the SDK's own
message are checked, since the Anthropic SDK JSON-stringifies the
response body into APIError.message when that body has no top-level
message.

This changes recovery behavior, not just classification: an unrelated
invalid request no longer triggers handleContextWindowExceededError(),
which was truncating conversation history and retrying a request that
then failed again for the original reason.

The Anthropic branch had no test coverage, so the fixtures are net-new:
positive cases for each real overflow message shape (including one error
built by the Anthropic SDK itself) and negative cases for the unrelated
invalid_request_error payloads that previously matched.

.claude/hooks/claude-code-for-web-setup.sh

@@ -41,11 +41,11 @@ fi
 
 # Install project dependencies
 echo "Installing dependencies..."
-bun run install:all
+npm run install:all
 
 # Generate gRPC/protobuf types (required for TypeScript)
 echo "Generating proto types..."
-bun run protos
+npm run protos
 
 echo ""
 echo "Session setup complete!"

.clinerules/bun-and-node.md

@@ -1,55 +0,0 @@
-# Bun (tooling) and Node (runtime)
-
-This repo uses **bun** for package management and task running, and **Node** as
-the execution runtime. Both are correct at the same time; the distinction is the
-source of most confusion, so keep it straight before editing scripts, configs,
-docs, or comments.
-
-## Use bun for tooling
-
-- `bun install` (never `npm install` / `npm ci`)
-- `bun run <script>` (never `npm run <script>`)
-- `bunx <bin>` (never `npx <bin>`)
-- `bun <file>.ts` to run a TS entrypoint directly (no `ts-node` / `tsx`)
-- `bun esbuild.mjs` to drive the build (esbuild/vite are still the bundlers)
-- `bun run --parallel ...` for parallel tasks
-
-The root `bun.lock` is the single lockfile for the whole workspace, including
-`apps/vscode`, `webview-ui`, and `testing-platform`. There are no per-package npm
-lockfiles.
-
-## Node is the runtime — do NOT rewrite these to bun
-
-The build product runs on Node: the VS Code extension host loads
-`dist/extension.js` as CommonJS under Node, and the standalone `cline-core` is a
-Node process. The following are Node runtime/ABI references and are correct as-is:
-
-| Reference | Why it is Node |
-|-----------|----------------|
-| esbuild `platform: "node"` / `target: "node..."` | The bundle targets the Node runtime (extension host, standalone core). |
-| `TARGET_NODE_VERSION` (`scripts/package-standalone.mjs`) | Pins the Node ABI of the bundled standalone runtime (matches the JetBrains-packaged Node). |
-| `prebuild-install --target=<node version>` | Downloads native `.node` binaries for that Node ABI. |
-| `NODE_PATH=... node cline-core.js` | The standalone core is launched by Node, not bun. |
-| `node:` import specifiers (e.g. `node:fs`) | Node builtin module scheme; unrelated to tooling. |
-| `process.versions.node`, `engines.node`, `@types/node` | Runtime version probe / declared runtime / its types. |
-| `ELECTRON_RUN_AS_NODE` | VS Code/Electron runs the extension host as Node. |
-
-When a file legitimately uses both bun and node (e.g. `package-standalone.mjs`
-does `bun install` but `prebuild-install --target=<node>`), the `node` token is
-the runtime/ABI target, not tooling. If unsure, leave it.
-
-## Tests: bun vs the VS Code host
-
-A test file's runner is decided by its import:
-
-- **`import ... from "bun:test"`** → runs under `bun test` (the node-side unit
-  suites + the SDK/model-catalog suites). `scripts/run-bun-unit-tests.ts`
-  discovers these by the `bun:test` import and runs one isolated bun process per
-  file. `build-tests.js` excludes them from the integration compile so the
-  `bun:test` builtin never reaches Node.
-- **`import ... from "mocha"`** → runs under `@vscode/test-cli` in a real VS Code
-  extension host (Node). These exercise the live `vscode` API and cannot run
-  under bun.
-
-So a file imports `bun:test` XOR `mocha`. Don't add `bun:test` to a test that
-needs the real extension host.

.clinerules/debug-harness.md

@@ -1,128 +0,0 @@
-# Debug Harness
-
-HTTP-controlled debugger for the VSCode extension at `src/dev/debug-harness/server.ts`.
-
-## Quick start
-
-```bash
-# Build extension first if needed (protos + esbuild):
-bun run protos && IS_DEV=true bun esbuild.mjs
-
-# Launch (skip-build if already built):
-bun src/dev/debug-harness/server.ts --skip-build --auto-launch
-
-# In another terminal:
-curl localhost:19229/api -d '{"method":"status"}'
-```
-
-## Data Isolation
-
-The debugee runs with `CLINE_DIR=~/.cline2` by default, separate from your real `~/.cline`.
-This prevents the debugee's logout from logging out the debugger, and vice versa.
-Override with `--cline-dir /tmp/test-dir`. Check with `status()` → `clineDir`.
-
-## Browser Capture & OAuth
-
-The debugee runs with `CLINE_CAPTURE_BROWSER=1`, which intercepts `openExternal()` in
-`src/utils/env.ts`. URLs are captured instead of opening a real browser:
-
-- Logged to `$CLINE_DIR/data/debug-captured-urls.jsonl`
-- POSTed in real-time to `/captured-url` on the harness server
-- Queryable via `oauth.captured_urls`
-
-### OAuth API
-
-- **`oauth.captured_urls`** `{clear?}` — URLs the debugee tried to open
-- **`oauth.read_stored_token`** — Check auth token presence in secrets.json
-- **`oauth.simulate_callback`** `{path, code?, state?, provider?, token?}` — Build vscode:// callback URI
-- **`oauth.read_captured_urls_file`** — Read on-disk JSONL of captured URLs
-
-### OAuth testing flow
-
-For **Cline OAuth** (SDK local callback): The SDK starts a local HTTP server, the auth URL
-is captured. To complete: open the captured URL in a real browser (it redirects back to the
-SDK's callback server), OR extract the callback port and `curl http://127.0.0.1:PORT/callback?code=...`.
-
-For **MCP/Provider OAuth** (vscode:// URI): The redirect goes to a vscode:// URI.
-`oauth.simulate_callback` only *builds* the URI — it does not deliver it, and the ESM
-extension host can't `require()` the handler. To actually deliver the callback, call the
-debug-only hook via `ext.evaluate` (with `awaitPromise: true`):
-`globalThis.__clineHandleUri("vscode://saoudrizwan.claude-dev/...?code=...&state=...")`.
-It runs the same `SharedUriHandler.handleUri` as VSCode's real URI handler and exists only
-when `CLINE_CAPTURE_BROWSER` is set (the harness always sets it; never ships in prod).
-For end-to-end MCP OAuth, get a real `code` from the local MCP OAuth test server
-(`bun run dev:mcp-oauth-test-server`).
-
-## Navigating Views — Use Commands, Not Clicks
-
-Don't try to find/click small sidebar icons. Use VSCode commands via command palette.
-Registered in `src/registry.ts`:
-
-| Command | View |
-|---------|------|
-| `cline.accountButtonClicked` | Account / sign-in |
-| `cline.historyButtonClicked` | Task history |
-| `cline.settingsButtonClicked` | Settings |
-| `cline.mcpButtonClicked` | MCP servers |
-| `cline.plusButtonClicked` | New task (chat) |
-| `cline.worktreesButtonClicked` | Worktrees |
-
-```bash
-curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
-```
-
-## Key commands
-
-All via `POST localhost:19229/api` with `{"method":"...", "params":{...}}`:
-
-- **`launch`** / **`shutdown`** — lifecycle
-- **`ui.screenshot`** — screenshot to `/tmp/cline-debug/`; returns `{path}` — **use `read_file` on the path to examine, do NOT `open` the file** (Preview.app covers the VSCode window)
-- **`ui.open_sidebar`** — open the Cline sidebar
-- **`ext.set_breakpoint`** `{file, line, condition?}` — breakpoint by source file (sourcemap-resolved)
-- **`ext.evaluate`** `{expression, callFrameId?}` — eval in extension host
-- **`ext.resume`** / **`ext.step_over`** / **`ext.step_into`** — stepping
-- **`ext.call_stack`** — inspect when paused
-- **`web.evaluate`** `{expression}` — eval in webview
-- **`web.post_message`** `{message}` — send postMessage to extension host via exposed vsCodeApi
-- **`wait_for_pause`** `{timeout?}` — block until breakpoint hit
-- **`ui.locator`** `{role?, testId?, text?, frame?}` — Playwright locator (auto-retries on stale sidebar frame)
-- **`ui.react_input`** `{text, selector?, clear?, submit?}` — set React textarea value via `execCommand('insertText')`; works reliably across multiple tasks
-- **`ui.send_message`** `{text, images?, files?, responseType?}` — send chat message bypassing the textarea entirely (via gRPC postMessage)
-- **`ui.command_palette`** `{command}` — run VSCode command
-
-## Typical Session
-
-```bash
-# 1. Launch
-curl localhost:19229/api -d '{"method":"launch","params":{"skipBuild":true}}'
-
-# 2. Open sidebar + dismiss overlays (ALWAYS do this first)
-curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
-curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
-
-# 3. Navigate to view
-curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
-
-# 4. Check captured OAuth URLs if testing auth
-curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
-
-# 5. Verify
-curl localhost:19229/api -d '{"method":"ui.screenshot"}'
-```
-
-## Caveats
-
-- **⚠️ Dismiss promotional overlays FIRST**: On fresh launches, full-screen promo overlays block the sidebar. **Dismiss immediately after `ui.open_sidebar`**, before any other interaction or screenshot. May need to run twice:
-  ```bash
-  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
-  curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
-  ```
-- **Screenshots — don't open the file**: `ui.screenshot` and `ui.sidebar_screenshot` save PNGs to `/tmp/cline-debug/` and return the `{path}`. Use `read_file` on that path to examine screenshots. Running `open <path>` launches Preview.app on macOS which covers the VSCode window.
-- **Scripts count = 0 after launch**: CDP connects after extension host starts, so scripts parsed during startup aren't tracked. Breakpoints still work via sourcemap resolution.
-- **Port 9230**: Extension host inspector. If another VSCode instance uses this port, the harness will fail to connect. Kill other debug instances first.
-- **macOS only** for now (Playwright Electron launch behavior).
-- **Webview CDP**: `connect_webview` may fail depending on Electron version. `web.evaluate` still works via Playwright's `frame.evaluate()` fallback.
-- **Sourcemap paths**: esbuild outputs relative paths like `../src/extension.ts` in the sourcemap. The resolver handles this, but if a file isn't found, use `ext.source_files` to see exact paths.
-- **OAuth with fake codes**: Browser capture intercepts the URL but doesn't provide a valid auth code. For real OAuth testing, open the captured URL in a browser. For unit testing, mock the token exchange.
-
-See `src/dev/debug-harness/README.md` for full API reference.

.clinerules/general.md

@@ -13,56 +13,11 @@ This file is the secret sauce for working effectively in this codebase. It captu
 **What NOT to add:** Stuff you can figure out from reading a few files, obvious patterns, or standard practices. This file should be high-signal, not comprehensive.
 
 ## Miscellaneous
-- The whole repo (including `apps/vscode`) uses **bun** for package management and task running. Emit `bun run X` / `bun install` / `bunx <bin>` / `bun file.ts`, never npm/npx. Node remains the *runtime* (VS Code's extension host and the standalone cline-core are Node), so Node-runtime tokens are legitimate and must not be "fixed" to bun — see @.clinerules/bun-and-node.md for the keep-list vs rewrite-list.
-- Avoid provider-specific string matching / hardcoded provider branches when fixing provider/config plumbing. Prefer provider metadata, shared catalog/defaults, explicit protocol/client capabilities, or centralized normalization utilities that apply by data shape rather than `providerId === "..."`. If a provider exception seems necessary, stop and explain why instead of adding ad-hoc string matching.
-- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `bun run compile`, not `bun run build`).
+- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `npm run compile`, not `npm run build`).
 - When creating PRs, contributors should not create changelog-entry files. Maintainers handle release versioning and changelog curation during the release process.
 - When adding new feature flags, see this PR as a reference https://github.com/cline/cline/pull/7566
 - Additional instructions about making requests: @.clinerules/network.md
 
-## Searching the Codebase — Avoiding Build Output
-
-Several directories contain build output or generated code that produces
-noisy or unusable results with `search_files` / `grep`:
-
-| Directory | What it is | Why it's a problem |
-|-----------|-----------|-------------------|
-| `out/` | esbuild bundle output | Mirrors `src/` structure as minified JS — every search gets duplicate hits on single-line files |
-| `dist/` | Packaged extension | Entire extension bundled into one minified `extension.js` (~1 long line) |
-| `dist-standalone/` | Standalone build output | Same minification issue |
-| `src/generated/` | Generated protobuf code | Auto-generated from `proto/`; not the source of truth |
-| `src/shared/proto/` | Generated proto type defs | Auto-generated from `proto/`; not the source of truth |
-| `node_modules/` | Dependencies | Huge, not project source |
-
-### How to skip build output
-
-**`search_files`** — Point at `src/` (not the project root) and use `file_pattern`:
-```
-search_files(path="src/core", regex="myFunction", file_pattern="*.ts")
-```
-The `file_pattern` parameter is the most effective filter — e.g. `"*.ts"`,
-`"*.tsx"`, `"*.proto"`.
-
-**`grep` directly** — Exclude build dirs and restrict to source extensions:
-```bash
-grep -rn "myFunction" src/ --include="*.ts" --exclude-dir={out,dist,node_modules,generated}
-```
-
-### When you must search minified files
-
-Sometimes you need to verify what got bundled (e.g., checking if a change
-made it into the build). Minified files are typically one long line, so
-normal `grep` shows the entire file as context. Use these approaches:
-
-- **`grep -oP`** to extract just the match with limited surrounding context:
-  ```bash
-  grep -oP '.{0,40}myFunction.{0,40}' dist/extension.js
-  ```
-- **`read_file`** on files in `out/src/` — these have source maps and are
-  more readable than `dist/extension.js` (which is the fully bundled output).
-- **Source maps** — `out/src/*.js.map` and `dist/extension.js.map` can be
-  used to trace minified output back to original source locations.
-
 ## gRPC/Protobuf Communication
 The extension and webview communicate via gRPC-like protocol over VS Code message passing.
 
@@ -73,7 +28,7 @@ The extension and webview communicate via gRPC-like protocol over VS Code messag
 - Naming: Services `PascalCaseService`, RPCs `camelCase`, Messages `PascalCase`
 - For streaming responses, use `stream` keyword (see `subscribeToAuthCallback` in `account.proto`)
 
-**Run `bun run protos`** after any proto changes—generates types in:
+**Run `npm run protos`** after any proto changes—generates types in:
 - `src/shared/proto/` - Shared type definitions
 - `src/generated/grpc-js/` - Service implementations
 - `src/generated/nice-grpc/` - Promise-based clients
@@ -93,6 +48,93 @@ The extension and webview communicate via gRPC-like protocol over VS Code messag
 - `src/core/controller/task/explainChanges.ts` - Handler implementation
 - `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
 
+## Adding a New API Provider
+When adding a new provider (e.g., "openai-codex"), you must update the proto conversion layer in THREE places or the provider will silently reset to Anthropic:
+
+1. `proto/cline/models.proto` - Add to the `ApiProvider` enum (e.g., `OPENAI_CODEX = 40;`)
+2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts` - Add case mapping string to proto enum
+3. `convertProtoToApiProvider()` in the same file - Add case mapping proto enum back to string
+
+**Why this matters:** Without these, the provider string hits the `default` case and returns `ANTHROPIC`. The webview, provider list, and handler all work fine, but the state silently resets when it round-trips through proto serialization. No error is thrown.
+
+**Other files to update when adding a provider:**
+- `src/shared/api.ts` - Add to `ApiProvider` union type, define models
+- `src/shared/providers/providers.json` - Add to provider list for dropdown
+- `src/core/api/index.ts` - Register handler in `createHandlerForProvider()`
+- `webview-ui/src/components/settings/utils/providerUtils.ts` - Add cases in `getModelsForProvider()` and `normalizeApiConfiguration()`
+- `webview-ui/src/utils/validate.ts` - Add validation case
+- `webview-ui/src/components/settings/ApiOptions.tsx` - Render provider component
+
+## Responses API Providers (OpenAI Codex, OpenAI Native)
+Providers using OpenAI's Responses API require native tool calling. XML tools don't work with the Responses API.
+
+**Symptoms of broken native tool calling:**
+- Tools get called multiple times (e.g., `ask_followup_question` asks the same question twice)
+- Tool arguments get duplicated or malformed
+- The model responds but tools aren't recognized
+
+**Root causes to check:**
+1. **Provider missing from `isNextGenModelProvider()`** in `src/utils/model-utils.ts`. The native variant matchers (e.g., `native-gpt-5/config.ts`) call this function. If your provider isn't in the list, the matcher returns false and falls back to XML tools.
+
+2. **Model missing `apiFormat: ApiFormat.OPENAI_RESPONSES`** in its model info (`src/shared/api.ts`). This property signals that the model requires native tool calling. The task runner in `src/core/task/index.ts` checks this and forces `enableNativeToolCalls: true` regardless of user settings.
+
+**When adding a new Responses API provider:**
+1. Add provider to `isNextGenModelProvider()` list in `src/utils/model-utils.ts`
+2. Set `apiFormat: ApiFormat.OPENAI_RESPONSES` on all models that use the Responses API
+3. The variant matcher and task runner will handle the rest automatically
+
+## Adding Tools to System Prompt
+This is tricky—multiple prompt variants and configs. **Always search for existing similar tools first and follow their pattern.** Look at the full chain from prompt definition → variant configs → handler → UI before implementing.
+
+1. **Add to `ClineDefaultTool` enum** in `src/shared/tools.ts`
+2. **Tool definition** in `src/core/prompts/system-prompt/tools/` (create file like `generate_explanation.ts`)
+   - Define variants for each `ModelFamily` (generic, next-gen, xs, etc.)
+   - Export variants array (e.g., `export const my_tool_variants = [GENERIC, NATIVE_NEXT_GEN, XS]`)
+   - **Fallback behavior**: If a variant isn't defined for a model family, `ClineToolSet.getToolByNameWithFallback()` automatically falls back to GENERIC. So you only need to export `[GENERIC]` unless the tool needs model-specific behavior.
+3. **Register in `src/core/prompts/system-prompt/tools/init.ts`** - Import and spread into `allToolVariants`
+4. **Add to variant configs** - Each model family has its own config in `src/core/prompts/system-prompt/variants/*/config.ts`. Add your tool's enum to the `.tools()` list:
+   - `generic/config.ts`, `next-gen/config.ts`, `gpt-5/config.ts`, `native-gpt-5/config.ts`, `native-gpt-5-1/config.ts`, `native-next-gen/config.ts`, `gemini-3/config.ts`, `glm/config.ts`, `hermes/config.ts`, `xs/config.ts`
+   - **Important**: If you add to a variant's config, make sure the tool spec exports a variant for that ModelFamily (or relies on GENERIC fallback)
+5. **Create handler** in `src/core/task/tools/handlers/`
+6. **Wire up in `ToolExecutor.ts`** if needed for execution flow
+7. **Add to tool parsing** in `src/core/assistant-message/index.ts` if needed
+8. **If tool has UI feedback**: add `ClineSay` enum in proto, update `src/shared/ExtensionMessage.ts`, update `src/shared/proto-conversions/cline-message.ts`, update `webview-ui/src/components/chat/ChatRow.tsx`
+
+## Modifying System Prompt
+**Read these first:** `src/core/prompts/system-prompt/README.md`, `tools/README.md`, `__tests__/README.md`
+
+System prompt is modular: **components** (reusable sections) + **variants** (model-specific configs) + **templates** (with `{{PLACEHOLDER}}` resolution).
+
+**Key directories:**
+- `components/` - Shared sections: `rules.ts`, `capabilities.ts`, `editing_files.ts`, etc.
+- `variants/` - Model-specific: `generic/`, `next-gen/`, `xs/`, `gpt-5/`, `gemini-3/`, `hermes/`, `glm/`, etc.
+- `templates/` - Template engine and placeholder definitions
+
+**Variant tiers (ask user which to modify):**
+- **Next-gen** (Claude 4, GPT-5, Gemini 2.5): `next-gen/`, `native-next-gen/`, `native-gpt-5/`, `native-gpt-5-1/`, `gemini-3/`, `gpt-5/`
+- **Standard** (default fallback): `generic/`
+- **Local/small models**: `xs/`, `hermes/`, `glm/`
+
+**How overrides work:** Variants can override components via `componentOverrides` in their `config.ts`, or provide a custom template in `template.ts` (e.g., `next-gen/template.ts` exports `rules_template`). If no override, the shared component from `components/` is used.
+
+**Example: Adding a rule to RULES section**
+1. Check if variant overrides rules: look for `rules_template` in `variants/*/template.ts` or `componentOverrides.RULES` in `config.ts`
+2. If shared: modify `components/rules.ts`
+3. If overridden: modify that variant's template
+4. XS variant is special—has heavily condensed inline content in `template.ts`
+
+**After any changes, regenerate snapshots:**
+```bash
+UPDATE_SNAPSHOTS=true npm run test:unit
+```
+Snapshots live in `__tests__/__snapshots__/`. Tests validate across model families and context variations (browser, MCP, focus chain).
+
+## Modifying Default Slash Commands
+Three places need updates:
+- `src/core/slash-commands/index.ts` - Command definitions
+- `src/core/prompts/commands.ts` - System prompt integration
+- `webview-ui/src/utils/slash-commands.ts` - Webview autocomplete
+
 ## Adding New Global State Keys
 Adding a new key to global state requires updates in multiple places. Missing any step causes silent failures.
 
@@ -109,7 +151,7 @@ Settings plumbing gotcha: if a key is user-toggleable from settings, wire both c
 Missing one path causes a toggle to appear to change in one surface while the backend state stays unchanged.
 
 Webview toggle gotcha: settings changes must also round-trip back in state payloads.
-- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `bun run protos`
+- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `npm run protos`
 - Include the key in `Controller.getStateToPostToWebview()` (`src/core/controller/index.ts`)
 - Ensure `ExtensionState` and webview defaults include the key (`src/shared/ExtensionMessage.ts`, `webview-ui/src/context/ExtensionStateContext.tsx`)
 If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
@@ -157,48 +199,3 @@ const isGenerating = explanationInfo.status === "generating" && !wasCancelled
 **See also:** `BrowserSessionRow.tsx` uses similar pattern with `isLastApiReqInterrupted` and `isLastMessageResume`.
 
 **Backend side:** When streaming is cancelled, clean up properly (close tabs, clear comments, etc.) by checking `taskState.abort` after the streaming function returns.
-
-## Debug Harness: clear inherited VSCode/Electron env vars before launching
-
-The debug harness (`apps/vscode/src/dev/debug-harness/server.ts`) launches a child
-VSCode via Playwright's `_electron.launch({ env: { ...process.env, ... } })`. If you
-run the harness from a process that was itself spawned by VSCode (e.g. the Cline
-extension host, an integrated terminal, or an agent running inside VSCode), the
-parent's VSCode/Electron env vars leak into the child and break the launch.
-
-The fatal one is **`ELECTRON_RUN_AS_NODE=1`**: it makes the child VSCode binary run
-as plain Node, so it rejects every VSCode CLI flag. Symptom:
-
-```
-.../Visual Studio Code.app/Contents/MacOS/Code: bad option: --extensionDevelopmentPath=...
-Error: Process failed to launch!   (Playwright _electron.launch)
-```
-
-This is NOT the macOS Playwright flakiness mentioned in the harness README — it's
-env inheritance. Fix: strip the inherited vars before starting the harness:
-
-```bash
-env -u ELECTRON_RUN_AS_NODE -u ELECTRON_NO_ATTACH_CONSOLE \
-    -u VSCODE_CLI -u VSCODE_CODE_CACHE_PATH -u VSCODE_CRASH_REPORTER_PROCESS_TYPE \
-    -u VSCODE_CWD -u VSCODE_ESM_ENTRYPOINT -u VSCODE_HANDLES_UNCAUGHT_ERRORS \
-    -u VSCODE_IPC_HOOK -u VSCODE_NLS_CONFIG -u VSCODE_PID -u VSCODE_L10N_BUNDLE_LOCATION \
-    bun src/dev/debug-harness/server.ts --auto-launch --skip-build
-```
-
-Check your own env with `env | grep -iE 'electron|vscode_'` first; `ELECTRON_RUN_AS_NODE=1`
-present means you must scrub before launching.
-
-Other harness notes confirmed in practice:
-- The extension host is **ESM** (`VSCODE_ESM_ENTRYPOINT`), so `ext.evaluate` has no
-  `require` and module-internal functions aren't reachable as globals. To inspect
-  internal builders (e.g. `buildBedrockProviderConfig`), set a breakpoint with
-  `ext.set_breakpoint` and read locals via `ext.evaluate` with the paused `callFrameId`
-  — don't try to `require()` the bundle.
-- `web.evaluate` wraps the expression as a single returned expression; multi-statement
-  snippets must be an IIFE `(() => { ...; return x; })()`, otherwise you get
-  `SyntaxError: Unexpected token ';'`.
-- Webview settings inputs are `vscode-text-field` web components with debounced React
-  onChange. Setting `.value` + dispatching events via `web.evaluate` is unreliable for
-  some fields; focus the inner shadow `input` then use real keystrokes (`ui.type` +
-  `ui.press Tab`, or click the dropdown option) to make the value persist.
-

.clinerules/protobuf-development.md

@@ -42,7 +42,7 @@ Here, we use the common `StringRequest` and `KeyValuePair` types.
 
 After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
 ```bash
-bun run protos
+npm run protos
 ```
 This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
 

.clinerules/sdk-migration.md

@@ -1,26 +0,0 @@
-# SDK Adapter
-
-The VSCode extension runs on the Cline SDK (`@cline/core`, `@cline/llms`,
-`@cline/shared`) through an adapter layer in `apps/vscode/src/sdk/`. The
-webview still talks gRPC; the adapter translates between gRPC handlers and SDK
-calls. See `apps/vscode/src/dev/debug-harness/README.md` for the debug harness.
-
-## Conventions
-
-1. **Look up SDK APIs, don't guess.** Use `kb_search(name="sdk", query="...")`
-   before implementing against an SDK surface.
-2. **Reference the pre-SDK implementation when replacing a module.** Add a
-   `// Replaces classic src/core/... (see origin/main)` header and use
-   `kb_search(name="cline", commit="origin/main")` or
-   `git show origin/main:path` to consult the prior implementation.
-3. **Single entry point.** There is one codepath — the SDK adapter. No
-   `CLINE_SDK` env flag.
-4. **Use `{appBaseUrl}`**, never hardcode `app.cline.bot`.
-5. **Avoid `as` casts.** Use explicit conversion functions with tests. The
-   branded types in `apps/vscode/src/sdk/model-catalog/contracts.ts` exist so
-   casts are unnecessary outside parse/compute boundaries.
-
-## Debug harness
-
-- **Dismiss the Kanban/promo overlay** before any debug harness interaction.
-- **Use the command palette** to navigate tabs in the debug harness.

.clinerules/workflows/hotfix-release.md

@@ -91,7 +91,7 @@ On the main branch, create a commit that updates:
 
 3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
 
-**No dependency install is needed.** A CHANGELOG + `version` bump does not change any dependency, and `bun.lock` does not pin workspace-package versions, so the lockfile stays consistent. The publish workflow runs `bun install --frozen-lockfile`, which would *fail* on an out-of-sync lock — so only run `bun install` here if you actually change dependencies (then commit the updated `bun.lock`).
+**Skip running `npm run install:all`** - release automation handles lockfile consistency as needed.
 
 Commit with message format: `v{VERSION} Release Notes (hotfix)`
 

.github/copilot-instructions.md

@@ -9,14 +9,14 @@ This is a VS Code extension. Read `.clinerules/general.md` for tribal knowledge
 - **MCP**: `src/services/mcp/McpHub.ts`.
 
 ## Build & Test (Critical — non-obvious commands)
-- **Build**: `bun run compile` — NOT `bun run build`.
-- **Watch**: `bun run watch` (extension + webview).
-- **Protos**: `bun run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
-- **Tests**: `bun run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+- **Build**: `npm run compile` — NOT `npm run build`.
+- **Watch**: `npm run watch` (extension + webview).
+- **Protos**: `npm run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
+- **Tests**: `npm run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true npm run test:unit`.
 
 ## Protobuf RPC Workflow (4 steps)
 1. **Define** in `proto/cline/*.proto`. Naming: `PascalCaseService`, `camelCase` RPCs, `PascalCase` Messages. Use `common.proto` shared types for simple data.
-2. **Generate**: `bun run protos`.
+2. **Generate**: `npm run protos`.
 3. **Backend handler**: `src/core/controller/<domain>/`. 
 4. **Frontend call**: `UiServiceClient.myMethod(Request.create({...}))`.
 - Adding enums (e.g. `ClineSay`) → also update `src/shared/proto-conversions/cline-message.ts`.
@@ -38,7 +38,7 @@ For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/mod
 4. Whitelist in `src/core/prompts/system-prompt/variants/*/config.ts` for each model family.
 5. Handler in `src/core/task/tools/handlers/`, wire in `ToolExecutor.ts`.
 6. If tool has UI: add `ClineSay` enum in proto → `ExtensionMessage.ts` → `cline-message.ts` → `ChatRow.tsx`.
-7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true bun run test:unit`.
+7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true npm run test:unit`.
 
 ## Modifying System Prompt
 Modular: `components/` (shared) + `variants/` (model-specific) + `templates/` (`{{PLACEHOLDER}}`). Variants override components via `componentOverrides` in `config.ts` or custom `template.ts`. XS variant is heavily condensed inline. Always regenerate snapshots after changes.

.github/pull_request_template.md

@@ -59,7 +59,7 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 <!-- Put an 'x' in all boxes that apply -->
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
--   [ ] Tests are passing (`bun test`) and code is formatted and linted (`bun run format && bun run lint`)
+-   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/workflows/ext-vscode-publish-nightly.yml

@@ -31,9 +31,6 @@ jobs:
     if: github.repository == 'cline/cline' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dpc/sdk-migration-simpler-login')
     runs-on: ubuntu-latest
     environment: PublishNightly
-    # The VS Code extension's package.json and lockfiles live under apps/vscode/
-    # (the repo root has no package.json). Mirror ext-vscode-test.yml so install
-    # and publish steps run in the correct workspace.
     defaults:
       run:
         working-directory: apps/vscode
@@ -53,47 +50,21 @@ jobs:
           echo "Building sha: $GITHUB_SHA"
           git --no-pager log -1 --oneline
 
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: 1.3.14
-
-      # Node is still REQUIRED in the publish job (not just for install): the publish
-      # scripts run as `node ./scripts/publish-*.mjs` and shell out to `npx ovsx`.
-      # setup-bun does not provide a Node runtime, so keep setup-node here.
-      # Pinned to Node 22 because newer LTS (Node 24 / npm 11) can make vsce's
-      # `npm list` dependency detection fail with ELSPROBLEMS during packaging.
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
+          # Keep publish environment aligned with test workflow/tooling lockfile expectations.
+          # Newer LTS (Node 24 / npm 11) can make `npm list` fail with ELSPROBLEMS during vsce packaging.
           node-version: 22
 
-      # Single root install resolves the whole bun workspace at once (replaces the
-      # per-package `npm ci` steps for apps/vscode + webview-ui).
-      - name: Install workspace dependencies
+      - name: Install extension dependencies
         working-directory: ${{ github.workspace }}
-        run: bun install --frozen-lockfile
+        run: npm --prefix apps/vscode ci --include=optional
 
-      # @cline/* are local workspace symlinks to source packages; build dist/ before
-      # packaging/publishing the extension.
-      - name: Build SDK packages
+      - name: Install webview-ui dependencies
         working-directory: ${{ github.workspace }}
-        run: bun run build:sdk
+        run: npm --prefix apps/vscode/webview-ui ci --include=optional
 
-      - name: Assert better-sqlite3 native binary present
-        run: |
-          NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-          if [ ! -f "$NODE_FILE" ]; then
-            echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-            echo "(bun trustedDependencies postinstall likely did not run)"
-            exit 1
-          fi
-          echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-      # vsce is now a workspace devDependency (on node_modules/.bin), but ovsx is not
-      # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
-      # globally here (npm is available via setup-node). vsce is installed globally
-      # too to preserve the script's existing PATH expectations.
       - name: Install Publishing Tools
         run: npm install -g @vscode/vsce ovsx
 
@@ -111,9 +82,7 @@ jobs:
           OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
           OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
           OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-        # The script itself runs under `node ./scripts/publish-nightly.mjs`; bun run
-        # just launches it. Node + npm (for `npx ovsx`) are provided by setup-node above.
-        run: bun run publish:marketplace:nightly
+        run: npm run publish:marketplace:nightly
 
       - name: Tag published commit
         working-directory: ${{ github.workspace }}

.github/workflows/ext-vscode-publish-stable.yml

@@ -109,48 +109,19 @@ jobs:
                   echo "tag=$TAG" >> $GITHUB_OUTPUT
                   echo "resolved_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
-              with:
-                  bun-version: 1.3.14
-
-            # Node is still REQUIRED in the publish job (not just for install): the
-            # publish scripts run as `node scripts/publish-*.mjs`, the version step uses
-            # `node -p`, and `npx ovsx` needs npm. setup-bun does not provide a Node
-            # runtime, so keep setup-node. Pinned to Node 22 because newer LTS
-            # (Node 24 / npm 11) can make vsce's `npm list` detection fail with
-            # ELSPROBLEMS during packaging.
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
                   node-version: 22
 
-            # Single root install resolves the whole bun workspace at once (replaces the
-            # per-package `npm install` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode install --include=optional
 
-            # @cline/* are local workspace symlinks to source packages; build dist/ before
-            # packaging/publishing the extension.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui install --include=optional
 
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # vsce is a workspace devDependency (on node_modules/.bin), but ovsx is not
-            # vendored and the publish script invokes it via `npx ovsx`, so install ovsx
-            # globally (npm is available via setup-node). vsce is installed globally too
-            # to preserve the script's existing PATH expectations.
             - name: Install Publishing Tools
               run: npm install -g @vscode/vsce ovsx
 
@@ -193,20 +164,14 @@ jobs:
                   node scripts/marketplace-readme.mjs swap-in
                   trap 'node scripts/marketplace-readme.mjs restore' EXIT
 
-                  # Required to generate the .vsix. --no-dependencies: the extension
-                  # is fully esbuild-bundled, and under the bun workspace the @cline/*
-                  # deps are symlinks pointing outside the package, so without this vsce
-                  # would walk them and pull the whole monorepo into the .vsix.
-                  vsce package --no-dependencies --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+                  # Required to generate the .vsix
+                  vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
-                  # These scripts run under `node scripts/publish-marketplace.mjs`;
-                  # bun run just launches them. Node + npm (for `npx ovsx`) come from
-                  # setup-node above.
                   if [ "$RELEASE_TYPE" = "pre-release" ]; then
-                    bun run publish:marketplace:prerelease
+                    npm run publish:marketplace:prerelease
                     echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   else
-                    bun run publish:marketplace
+                    npm run publish:marketplace
                     echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   fi
 

.github/workflows/ext-vscode-test-e2e.yml

@@ -45,16 +45,12 @@ jobs:
                           - 'apps/vscode/assets/**'
                           - 'apps/vscode/walkthrough/**'
                           - 'apps/vscode/package.json'
-                          - 'apps/vscode/webview-ui/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/biome.jsonc'
                           - 'apps/vscode/esbuild.mjs'
-                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.mocharc.json'
                           - 'apps/vscode/.vscode-test.mjs'
                           - 'apps/vscode/.vscodeignore'
                           - 'apps/vscode/playwright*.ts'
@@ -88,20 +84,26 @@ jobs:
                 working-directory: apps/vscode
         steps:
             - uses: actions/checkout@v4
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
 
-            # Cache Bun's global install cache - keyed on the authoritative root bun.lock.
-            - name: Cache Bun install cache
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache root dependencies
               uses: actions/cache@v4
-              id: bun-cache
+              id: root-cache
               with:
-                  path: ~/.bun/install/cache
-                  key: ${{ runner.os }}-bun-${{ hashFiles('bun.lock') }}
-                  restore-keys: |
-                      ${{ runner.os }}-bun-
+                  path: apps/vscode/node_modules
+                  key: ${{ runner.os }}-npm-${{ hashFiles('apps/vscode/package-lock.json') }}
+
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache webview-ui dependencies
+              uses: actions/cache@v4
+              id: webview-cache
+              with:
+                  path: apps/vscode/webview-ui/node_modules
+                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('apps/vscode/webview-ui/package-lock.json') }}
 
             # Cache VS Code installation
             - name: Cache VS Code
@@ -122,41 +124,22 @@ jobs:
                       ~/.cache/ms-playwright
                       ~/Library/Caches/ms-playwright
                       ~/AppData/Local/ms-playwright
-                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('bun.lock') }}
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('apps/vscode/package-lock.json') }}
                   restore-keys: |
                       playwright-browsers-${{ runner.os }}-
 
-            # Single root install resolves the entire bun workspace at once (replaces
-            # the per-package `npm ci` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before building/packaging the extension for E2E.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui ci
 
-            - name: Assert better-sqlite3 native binary present
-              # Force bash: the Windows runner defaults to pwsh, which can't parse this
-              # POSIX test. Git Bash ships on GitHub's windows-latest images.
-              shell: bash
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # NOTE: vsce is no longer installed globally. @vscode/vsce is a workspace
-            # devDependency of apps/vscode (resolved into node_modules/.bin), and the
-            # `test:e2e:build` script invokes `vsce` via `bun run`, which puts the local
-            # .bin on PATH. No global install needed.
+            - name: Install vsce
+              run: npm install -g @vscode/vsce
 
             - name: Install xvfb on Linux
               if: matrix.runner == 'ubuntu'
@@ -165,11 +148,11 @@ jobs:
             # Run optimized E2E tests (eliminates redundant builds)
             - name: Run E2E tests - Linux
               if: matrix.runner == 'ubuntu'
-              run: xvfb-run -a bun run test:e2e:optimal
+              run: xvfb-run -a npm run test:e2e:optimal
 
             - name: Run E2E tests - Non-Linux
               if: matrix.runner != 'ubuntu'
-              run: bun run test:e2e:optimal
+              run: npm run test:e2e:optimal
 
             - uses: actions/upload-artifact@v4
               if: ${{ failure() }}

.github/workflows/ext-vscode-test.yml

@@ -8,6 +8,7 @@ on:
     pull_request:
         branches:
             - main
+            - legacy-extension
     workflow_call:
 
 # Set default permissions for all jobs
@@ -45,16 +46,13 @@ jobs:
                           - 'apps/vscode/assets/**'
                           - 'apps/vscode/walkthrough/**'
                           - 'apps/vscode/package.json'
-                          - 'apps/vscode/webview-ui/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/biome.jsonc'
                           - 'apps/vscode/esbuild.mjs'
-                          - 'apps/vscode/bunfig.toml'
+                          - 'apps/vscode/.mocharc.json'
+                          - 'apps/vscode/.nycrc*.json'
                           - 'apps/vscode/.vscode-test.mjs'
                           - 'apps/vscode/test-setup.js'
                           - '.github/workflows/ext-vscode-test.yml'
@@ -63,13 +61,9 @@ jobs:
                           - 'apps/vscode/proto/**'
                           - 'apps/vscode/standalone/**'
                           - 'apps/vscode/testing-platform/**'
-                          - 'apps/vscode/testing-platform/package.json'
                           - 'apps/vscode/tests/specs/**'
                           - 'apps/vscode/package.json'
-                          # Root bun lockfile is authoritative for the whole workspace (incl. apps/vscode).
-                          - 'bun.lock'
-                          # SDK source packages are local workspace symlinks (@cline/*), so SDK changes affect the build.
-                          - 'sdk/packages/**'
+                          - 'apps/vscode/package-lock.json'
                           - 'apps/vscode/buf.yaml'
                           - 'apps/vscode/tsconfig*.json'
                           - 'apps/vscode/esbuild.mjs'
@@ -89,38 +83,27 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
 
-            # Single root install resolves the entire bun workspace (apps/vscode,
-            # webview-ui, testing-platform and the @cline/* SDK symlinks) at once,
-            # so the previous per-package `npm ci` steps collapse into one.
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; their dist/
-            # output must be built before the extension can type-check/compile.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
-
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+              run: npm --prefix apps/vscode/webview-ui ci
 
             - name: Run Quality Checks (Parallel)
-              run: bun run ci:check-all
+              run: npm run ci:check-all
 
     vscode-test:
         needs: [detect-changes, quality-checks]
@@ -141,43 +124,30 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
 
-            # Single root install resolves the entire bun workspace at once (replaces
-            # the per-package `npm ci` steps for apps/vscode + webview-ui).
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before compiling/testing the extension.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
+              run: npm --prefix apps/vscode/webview-ui ci
 
-            - name: Assert better-sqlite3 native binary present
+            - name: Set up NPM on Windows
+              if: runner.os == 'Windows'
+              working-directory: ${{ github.workspace }}
               run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
-
-            # NOTE: The old `npm config set script-shell bash` step is intentionally
-            # removed. Scripts are now launched with `bun run`, which uses Bun's own
-            # built-in cross-platform shell rather than npm's configured script-shell,
-            # so that npm-specific Windows workaround no longer applies. Bash-dependent
-            # scripts (e.g. scripts/proto-lint.sh, standalone/runclinecore.sh) are
-            # invoked explicitly via `bash ...` from within the package scripts, and
-            # this job's `defaults.run.shell: bash` (Git Bash on Windows) still covers
-            # the workflow `run:` blocks below.
+                  npm config set script-shell "C:\\Program Files\\Git\\bin\\bash.exe"
 
             - name: Cache VS Code test runtime
               if: runner.os == 'Windows'
@@ -189,51 +159,24 @@ jobs:
             # Build the extension and tests (without redundant checks)
             - name: Build Tests and Extension
               id: build_step
-              run: bun run ci:build
+              run: npm run ci:build
 
-            - name: Vitest Suites (SDK adapter + model catalog)
-              id: vitest_tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              # The vitest config sets passWithNoTests: true, so a broken glob/alias
-              # would "pass" with zero tests. Capture output and assert a non-zero
-              # test count to guard against silent skips.
-              run: |
-                  set -o pipefail
-                  bun run test:vitest 2>&1 | tee vitest-output.log
-                  # Strip ANSI color codes before matching — vitest colorizes the
-                  # "Tests  N passed" summary, so the count is not adjacent to the
-                  # "Tests" label in the raw bytes.
-                  if ! sed -r 's/\x1b\[[0-9;]*m//g' vitest-output.log | grep -Eq 'Tests[[:space:]]+[0-9]*[1-9][0-9]* (passed|failed)'; then
-                    echo "ERROR: vitest reported zero tests (possible silent skip)."
-                    exit 1
-                  fi
-
-            - name: Unit Tests (bun) - Linux
+            - name: Unit Tests with coverage - Linux
               id: unit_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              # The node-side unit suite (.mocharc spec set) now runs under `bun test`
-              # via scripts/run-bun-unit-tests.ts (one isolated bun process per file).
-              # The runner exits non-zero on any failure and prints a final
-              # "Files: N  Pass: P  Fail: F" summary; assert a non-zero pass count to
-              # guard against an empty glob silently "passing".
               run: |
-                  set -o pipefail
-                  bun run test:unit 2>&1 | tee unit-output.log
-                  if ! grep -Eq 'Pass:[[:space:]]+[0-9]*[1-9][0-9]*' unit-output.log; then
-                    echo "ERROR: bun unit runner reported zero passing tests (possible silent skip)."
-                    exit 1
-                  fi
+                  npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
 
-            - name: Unit Tests (bun) - Non-Linux
+            - name: Unit Tests - Non-Linux
               id: unit_tests_non_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
               run: |
-                  bun run test:unit
+                  npm run test:unit
 
             - name: Extension Integration Tests - Linux
               id: integration_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              run: xvfb-run -a bun run test:coverage
+              run: xvfb-run -a npm run test:coverage
 
             - name: Extension Integration Tests - Non-Linux
               id: integration_tests_non_linux
@@ -241,7 +184,7 @@ jobs:
               run: |
                   for attempt in 1 2 3; do
                     echo "Running extension integration tests (attempt ${attempt}/3)"
-                    if bun run test:integration; then
+                    if npm run test:integration; then
                       exit 0
                     fi
 
@@ -259,7 +202,7 @@ jobs:
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
               run: |
                   cd webview-ui
-                  bun run test:coverage
+                  npm run test:coverage
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
@@ -268,6 +211,7 @@ jobs:
               with:
                   name: pr-coverage-reports
                   path: |
+                      apps/vscode/coverage-unit/lcov.info
                       apps/vscode/webview-ui/coverage/lcov.info
 
     test-platform-integration:
@@ -281,45 +225,39 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
               with:
-                  bun-version: 1.3.14
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      apps/vscode/package-lock.json
+                      apps/vscode/webview-ui/package-lock.json
+                      apps/vscode/testing-platform/package-lock.json
 
-            # Single root install resolves the whole bun workspace, including the
-            # testing-platform package, so the separate per-package `npm ci` steps
-            # (extension + webview-ui + testing-platform) collapse into one.
-            - name: Install workspace dependencies
+            - name: Install extension dependencies
               working-directory: ${{ github.workspace }}
-              run: bun install --frozen-lockfile
+              run: npm --prefix apps/vscode ci
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            # @cline/* are local workspace symlinks to source packages; build dist/
-            # before compiling the standalone core.
-            - name: Build SDK packages
+            - name: Install webview-ui dependencies
               working-directory: ${{ github.workspace }}
-              run: bun run build:sdk
-
-            - name: Assert better-sqlite3 native binary present
-              run: |
-                  NODE_FILE="node_modules/better-sqlite3/build/Release/better_sqlite3.node"
-                  if [ ! -f "$NODE_FILE" ]; then
-                    echo "ERROR: better-sqlite3 native binary missing at apps/vscode/$NODE_FILE"
-                    echo "(bun trustedDependencies postinstall likely did not run)"
-                    exit 1
-                  fi
-                  echo "Found better-sqlite3 native binary: $NODE_FILE"
+              run: npm --prefix apps/vscode/webview-ui ci
 
             - name: Download ripgrep binaries
-              run: bun run download-ripgrep
+              run: npm run download-ripgrep
 
             - name: Compile Standalone
-              run: bun run compile-standalone
+              run: npm run compile-standalone
+
+            - name: Install testing platform dependencies
+              working-directory: ${{ github.workspace }}
+              run: npm --prefix apps/vscode/testing-platform ci
 
             - name: Running testing platform integration spec tests
               timeout-minutes: 7
-              run: bun run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
+              run: npm run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4

.gitignore

@@ -13,9 +13,6 @@ tmp
 pnpm-lock.yaml
 
 .clineignore
-.cline/enterprise
-.cline/remote-config
-**/.cline/remote-config
 .venv
 .actrc
 CLAUDE.local.md
@@ -84,4 +81,3 @@ apps/vscode/webview-ui/src/**/*.js.map
 *.db-wal
 .cline/**/managed.json
 .cline/**/bundle.json
-apps/vscode/tsconfig.test.generated.json

.husky/pre-commit

@@ -7,5 +7,4 @@ fi
 
 gitleaks git --pre-commit --redact --staged --verbose || exit 1
 
-cd apps/vscode && bunx lint-staged
-
+lint-staged

.vscode/launch.json

@@ -126,7 +126,10 @@
 				"${workspaceFolder}/apps/vscode/dist-standalone/**/*.js"
 			],
 			"preLaunchTask": "compile-standalone",
-			"runtimeExecutable": "bun",
+			"runtimeExecutable": "npx",
+			"runtimeArgs": [
+				"tsx"
+			],
 			"program": "scripts/test-standalone-core-api-server.ts",
 			"envFile": "${workspaceFolder}/apps/vscode/.env",
 			"env": {
@@ -180,7 +183,7 @@
 			"name": "Open Storybook",
 			"type": "node",
 			"request": "launch",
-			"runtimeExecutable": "bun",
+			"runtimeExecutable": "npm",
 			"runtimeArgs": [
 				"run",
 				"storybook"

.vscode/settings.json

@@ -22,24 +22,11 @@
 	},
 	// Enable Lint and format using Biome
 	"biome.enabled": true,
-	"biome.requireConfiguration": true,
-	"prettier.enable": false,
 	"editor.defaultFormatter": "biomejs.biome",
-	"[javascript]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[javascriptreact]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[typescript]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[typescriptreact]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
 	"editor.codeActionsOnSave": {
 		"source.fixAll.biome": "explicit",
 		"source.removeUnused.biome": "always",
+		"source.removeUnusedImports": "always",
 		"source.organizeImports.biome": "always"
 	},
 	// Disable auto-forwarding ports to prevent Simple Browser from opening the Vite dev server

.vscode/tasks.json

@@ -6,7 +6,7 @@
 		{
 			"label": "compile-standalone",
 			"type": "shell",
-			"command": "bun run compile-standalone",
+			"command": "npm run compile-standalone",
 			"group": "build",
 			"problemMatcher": [],
 			"presentation": {
@@ -19,7 +19,7 @@
 		{
 			"label": "npm: protos",
 			"type": "shell",
-			"command": "bun run protos",
+			"command": "npm run protos",
 			"problemMatcher": [],
 			"isBackground": false,
 			"presentation": {
@@ -65,7 +65,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run build:webview",
+			"command": "npm run build:webview",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
@@ -86,7 +86,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run build:webview:test",
+			"command": "npm run build:webview:test",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
@@ -108,7 +108,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run dev:webview",
+			"command": "npm run dev:webview",
 			"group": "build",
 			"problemMatcher": [
 				{
@@ -145,7 +145,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:esbuild",
+			"command": "npm run watch:esbuild",
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -169,8 +169,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -185,7 +184,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:esbuild:test",
+			"command": "npm run watch:esbuild:test",
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -209,8 +208,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -226,7 +224,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch:tsc",
+			"command": "npm run watch:tsc",
 			"group": "build",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
@@ -244,7 +242,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run watch-tests",
+			"command": "npm run watch-tests",
 			"label": "npm: watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
@@ -284,7 +282,7 @@
 		},
 		{
 			"type": "shell",
-			"command": "bun run storybook",
+			"command": "npm run storybook",
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": false,
@@ -313,24 +311,6 @@
 			"options": {
 				"cwd": "${workspaceFolder}"
 			}
-		},
-		{
-			"label": "build-sdk:debug",
-			"type": "shell",
-			"command": "bun run build:sdk",
-			"problemMatcher": [
-				"$tsc"
-			],
-			"presentation": {
-				"group": "watch",
-				"reveal": "always"
-			},
-			"options": {
-				"cwd": "${workspaceFolder}",
-				"env": {
-					"CLINE_SOURCEMAPS": "1"
-				}
-			}
 		}
 	],
 	"inputs": [

CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+## [4.0.12]
+
+### Added
+
+- Add support for free Cline models, shown as "(free)" in the model picker, with a dedicated error card that includes the reset time when the free limit is reached.
+
+### Fixed
+
+- Keep Claude Code responses that were already streamed when the CLI exits with a max-turns error, instead of discarding a valid response.
+
+## [4.0.11]
+
+### Added
+
+- Add Claude Opus 5 across the Anthropic, Claude Code, Bedrock, Vertex, Cline, and OpenRouter providers, including 1M context window variants.
+- Add Moonshot Kimi K3 support.
+- Include the host plugin version in telemetry events.
+
+### Fixed
+
+- Correct pricing for the Claude Opus 1M context variants, which overstated costs for requests above 200k tokens.
+- Enable native tool calling for Kimi K3 models, fixing empty responses.
+
+## [4.0.10]
+
+### Added
+
+- Add telemetry to track when Cline reaches the consecutive mistake limit.
+
+## [4.0.9]
+
+### Added
+
+- Add GPT-5.6 ChatGPT subscription models.
+
+### Changed
+
+- Soften and shorten the message shown when Cline hits the consecutive mistake limit.
+
+### Fixed
+
+- Handle cumulative usage snapshots from OpenAI-compatible providers so token counts are no longer over-reported.
+- Load skills from files saved as UTF-8 with a byte-order mark (BOM).
+
+## [4.0.8]
+
+### Added
+
+- Add more models to the GCP Vertex provider, plus a free-form entry option in the model dropdown for specifying custom Vertex models.
+
+## [4.0.7]
+
+### Added
+
+- Add a ClinePass limit-reached error with a one-click option to switch to Cline usage-based billing.
+- Allow selecting Cline free models on the ClinePass provider, organized into Subscribed and Free tabs with model descriptions.
+
+### Changed
+
+- Refine ClinePass onboarding and provider settings copy, and open the "learn more" link via the in-app URL handler.
+- Remove the Cline model picker recommendation copy.
+
+### Removed
+
+- Remove all references to GLM 5.1.
+
+## [4.0.6]
+
+### Fixed
+
+- Generalize the model capability warning so it applies more broadly.
+
+## [4.0.5]
+
+### Added
+
+- Add support for Claude Sonnet 5 across the Anthropic, Bedrock, Vertex, Claude Code, SAP AI Core, OpenRouter, and Vercel AI Gateway providers, including model picker and recommended-model updates.
+
+## [4.0.4]
+
+### Changed
+
+- Fully remove the ClinePass feature flag so ClinePass is available everywhere in the UI — onboarding, settings, the welcome promo banner, and the credit-limit "Switch to ClinePass" action.
+
+## [4.0.3]
+
+### Changed
+
+- Enable the ClinePass provider for all users by removing the feature-flag gate that previously fell back to the standard Cline provider.
+
+## [4.0.2]
+
+### Added
+
+- Add reasoning effort support (including `xhigh`) for DeepSeek thinking models.
+- Improve the ClinePass provider experience with clearer reasoning controls and model selection.
+
+### Fixed
+
+- Show reasoning effort controls for ClinePass models and align ClinePass model resolution with the rest of the provider.
+- Prefer canonical Cline Z.ai model ids and polish ClinePass and Z.ai model metadata.
+- Fix environment variable replacement in the webview.
+- Default focus chain settings in webview state so the toggle reflects the correct value on load.
+
+## [4.0.1]
+
+### Changed
+
+- Roll the stable VS Code extension back to the pre-SDK-migration codebase to resolve regressions reported in 4.0.0. This release ships the 3.89.2 extension code under a higher version number so existing 4.0.0 users receive the update. SDK-migration work continues separately on `main`.
+
 ## [3.89.2]
 
 ### Fixed

CLAUDE.md

@@ -0,0 +1,2 @@
+@.clinerules/general.md
+@.clinerules/network.md

CONTRIBUTING.md

@@ -45,7 +45,7 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 3. Install [bun](https://bun.com)
 4. Install the necessary dependencies for the extension and webview-gui:
     ```bash
-    cd apps/vscode && bun run install:all && cd ../..
+    cd apps/vscode && npm run install:all && cd ../..
     cd sdk && bun run build && cd ..
     ```
 5. Generate Protocol Buffer files (required before first build):
@@ -61,8 +61,8 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 2. Push your branch and create a PR on GitHub. Our CI will:
    - Run tests and checks
 3. Testing
-    - Run `cd apps/vscode && bun run test` to run tests locally. 
-    - Before submitting PR, run `bun run format:fix` to format your code
+    - Run `cd apps/vscode && npm run test` to run tests locally. 
+    - Before submitting PR, run `npm run format:fix` to format your code
 
 ### Extension
 
@@ -74,12 +74,12 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 2. **Local Development**
     - cd into the vscode extension, `cd apps/vscode`
-    - Run `bun run install:all` to install dependencies
-    - Run `bun run protos` to generate Protocol Buffer files (required before first build)
-    - Run `bun run test` to run tests locally
+    - Run `npm run install:all` to install dependencies
+    - Run `npm run protos` to generate Protocol Buffer files (required before first build)
+    - Run `npm run test` to run tests locally
     - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
-    - **Terminal Workflow**: Use `bun run dev` (generates protos + runs watch mode) or `bun run watch` (if protos already generated)
-    - Before submitting PR, run `bun run format:fix` to format your code
+    - **Terminal Workflow**: Use `npm run dev` (generates protos + runs watch mode) or `npm run watch` (if protos already generated)
+    - Before submitting PR, run `npm run format:fix` to format your code
 
 3. **Linux-specific Setup**
     VS Code extension tests on Linux require the following system libraries:
@@ -135,8 +135,8 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 
 2. **Code Quality**
 
-    - Run `bun run lint` to check code style
-    - Run `bun run format` to automatically format code
+    - Run `npm run lint` to check code style
+    - Run `npm run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
     - Address any warnings or errors from linter before submitting
     - Follow TypeScript best practices and maintain type safety
@@ -144,7 +144,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 3. **Testing**
 
     - Add tests for new features
-    - Run `bun test` to ensure all tests pass
+    - Run `npm test` to ensure all tests pass
     - Update existing tests if your changes affect them
     - Include both unit tests and integration tests where appropriate
 
@@ -154,9 +154,9 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     
     - **Running E2E tests:**
       ```bash
-      bun run test:e2e        # Build and run all E2E tests
-      bun run e2e             # Run tests without rebuilding
-      bun run test:e2e -- --debug  # Run with interactive debugger
+      npm run test:e2e        # Build and run all E2E tests
+      npm run e2e             # Run tests without rebuilding
+      npm run test:e2e -- --debug  # Run with interactive debugger
       ```
     
     - **Writing E2E tests:**

apps/cli/CHANGELOG.md

@@ -1,20 +1,5 @@
 # Cline CLI Changelog
 
-## 3.0.30
-
-- Added a token count to the status bar, shown alongside cost
-- Added organization-specific error messages
-- Added SAP AI Core provider support
-- Refreshed the model catalog with the latest provider models
-- Preserved OpenRouter reasoning-disable behavior and improved OpenRouter prompt caching
-- Routed LiteLLM model fetches through the SDK and stopped unrelated models from appearing in the LiteLLM model list
-- Updated ClinePass models live, restored ClinePass models in onboarding, and improved ClinePass error messages
-- Threaded proxy/CA-aware networking into the inference path
-- Persisted Bedrock settings to providers.json
-- Normalized JSON-like tool inputs by schema for more reliable tool calls
-- Fixed an "ERROR: EMPTY CONTENT" message that could appear when an error occurred
-- Fixed a packaging issue (createRequire) that could break the CLI at runtime
-
 ## 3.0.29
 
 - Costs are now hidden for Cline free models

apps/cli/bun.mts

@@ -121,7 +121,7 @@ const result = await Bun.build({
 	},
 	env: "OTEL_*",
 	banner:
-		'import { createRequire as __clineCreateRequire } from "node:module"; const require = __clineCreateRequire(import.meta.url);',
+		'import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);',
 });
 
 if (result.logs.length > 0) {

apps/cli/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cline/cli",
 	"displayName": "cline",
-	"version": "3.0.30",
+	"version": "3.0.29",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"type": "module",
 	"publishConfig": {

apps/cli/src/commands/mcp.test.ts

@@ -1,14 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import {
-	buildMcpInstallDefaults,
-	buildMcpInstallTransport,
-	runMcpInstallCommand,
-} from "./mcp";
-import { addServer } from "../wizards/mcp/settings";
-
-vi.mock("../wizards/mcp/settings", () => ({
-	addServer: vi.fn(),
-}));
+import { buildMcpInstallDefaults, runMcpInstallCommand } from "./mcp";
 
 describe("mcp install command", () => {
 	it("builds stdio wizard defaults from command args", () => {
@@ -97,52 +88,6 @@ describe("mcp install command", () => {
 		).toThrow(/only http and https are supported/);
 	});
 
-	it("builds direct stdio installs without shell-joining args", () => {
-		expect(
-			buildMcpInstallTransport({
-				name: "fs",
-				targetArgs: [
-					"npx",
-					"-y",
-					"@modelcontextprotocol/server-filesystem",
-					"/tmp/my dir",
-				],
-			}),
-		).toEqual({
-			name: "fs",
-			transport: {
-				type: "stdio",
-				command: "npx",
-				args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/my dir"],
-			},
-			warnings: [],
-		});
-	});
-
-	it("builds direct remote installs with headers and placeholder warnings", () => {
-		expect(
-			buildMcpInstallTransport({
-				name: "docs",
-				transport: "http",
-				headers: ["Authorization: Bearer <token>"],
-				targetArgs: ["https://example.com/mcp", "--header=X-Extra: yes"],
-			}),
-		).toEqual({
-			name: "docs",
-			transport: {
-				type: "streamableHttp",
-				url: "https://example.com/mcp",
-				headers: {
-					Authorization: "Bearer <token>",
-					"X-Extra": "yes",
-				},
-			},
-			warnings: [
-				'Header "Authorization" looks like it contains a placeholder. Update it in MCP settings before using this server.',
-			],
-		});
-	});
-
 	it("opens the add wizard with prefilled defaults", async () => {
 		const runWizard = vi.fn(async () => 0);
 
@@ -179,11 +124,11 @@ describe("mcp install command", () => {
 		expect(code).toBe(1);
 		expect(runWizard).not.toHaveBeenCalled();
 		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+			"cline mcp install opens the MCP wizard and requires a TTY.",
 		);
 	});
 
-	it("checks for TTY before validating wizard install arguments", async () => {
+	it("checks for TTY before validating install arguments", async () => {
 		const writeErr = vi.fn();
 
 		const code = await runMcpInstallCommand({
@@ -194,60 +139,7 @@ describe("mcp install command", () => {
 
 		expect(code).toBe(1);
 		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+			"cline mcp install opens the MCP wizard and requires a TTY.",
 		);
 	});
-
-	it("installs directly with --yes without requiring a TTY", async () => {
-		const writeln = vi.fn();
-		const writeErr = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "docs",
-			transport: "http",
-			targetArgs: [
-				"https://example.com/mcp",
-				"--header",
-				"Authorization: Bearer token",
-			],
-			isTty: false,
-			yes: true,
-			io: { writeln, writeErr },
-		});
-
-		expect(code).toBe(0);
-		expect(addServer).toHaveBeenCalledWith("docs", {
-			type: "streamableHttp",
-			url: "https://example.com/mcp",
-			headers: {
-				Authorization: "Bearer token",
-			},
-		});
-		expect(writeln).toHaveBeenCalledWith("Installed MCP server docs.");
-		expect(writeErr).not.toHaveBeenCalled();
-	});
-
-	it("prints direct install JSON with --yes --json", async () => {
-		const writeln = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "fs",
-			targetArgs: ["node", "server.js"],
-			isTty: false,
-			yes: true,
-			json: true,
-			io: { writeln, writeErr: vi.fn() },
-		});
-
-		expect(code).toBe(0);
-		expect(JSON.parse(writeln.mock.calls[0]?.[0])).toMatchObject({
-			name: "fs",
-			status: "installed",
-			transport: {
-				type: "stdio",
-				command: "node",
-				args: ["server.js"],
-			},
-		});
-	});
 });

apps/cli/src/commands/mcp.ts

@@ -1,33 +1,21 @@
 import type { McpAddDefaults } from "../wizards/mcp";
-import { addServer, type McpTransport } from "../wizards/mcp/settings";
 
 export interface McpCommandIo {
-	writeln?: (text: string) => void;
 	writeErr: (text: string) => void;
 }
 
 export interface McpInstallOptions {
 	name: string;
-	headers?: string[];
 	targetArgs?: string[];
 	transport?: string;
 	io?: McpCommandIo;
 	isTty?: boolean;
-	json?: boolean;
 	runWizard?: (defaults: McpAddDefaults) => Promise<number>;
-	yes?: boolean;
-}
-
-export interface McpInstallDirectResult {
-	name: string;
-	status: "installed";
-	transport: McpTransport;
-	warnings: string[];
 }
 
 function normalizeTransportType(
 	value: string | undefined,
-): McpTransport["type"] {
+): McpAddDefaults["type"] {
 	const normalized = (value ?? "stdio").trim();
 	if (normalized === "http" || normalized === "streamable-http") {
 		return "streamableHttp";
@@ -58,72 +46,6 @@ function assertValidUrl(url: string): void {
 	}
 }
 
-function parseHeader(value: string): [string, string] {
-	const separatorIndex = value.indexOf(":");
-	if (separatorIndex <= 0) {
-		throw new Error(
-			`Invalid MCP header "${value}". Expected "Header-Name: header value".`,
-		);
-	}
-	const name = value.slice(0, separatorIndex).trim();
-	const headerValue = value.slice(separatorIndex + 1).trim();
-	if (!name || !headerValue) {
-		throw new Error(
-			`Invalid MCP header "${value}". Expected "Header-Name: header value".`,
-		);
-	}
-	if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) {
-		throw new Error(`Invalid MCP header name "${name}".`);
-	}
-	return [name, headerValue];
-}
-
-function splitTargetArgsAndHeaders(input: {
-	headers?: string[];
-	targetArgs?: string[];
-}): { headers: string[]; targetArgs: string[] } {
-	const headers = [...(input.headers ?? [])];
-	const targetArgs: string[] = [];
-	const args = input.targetArgs ?? [];
-	for (let index = 0; index < args.length; index++) {
-		const arg = args[index];
-		if (arg === "--header") {
-			const value = args[index + 1];
-			if (!value) {
-				throw new Error("--header requires a value");
-			}
-			headers.push(value);
-			index++;
-			continue;
-		}
-		if (arg?.startsWith("--header=")) {
-			headers.push(arg.slice("--header=".length));
-			continue;
-		}
-		targetArgs.push(arg);
-	}
-	return { headers, targetArgs };
-}
-
-function buildHeaders(values: string[]): {
-	headers?: Record<string, string>;
-	warnings: string[];
-} {
-	if (values.length === 0) return { warnings: [] };
-	const headers: Record<string, string> = {};
-	const warnings: string[] = [];
-	for (const value of values) {
-		const [name, headerValue] = parseHeader(value);
-		headers[name] = headerValue;
-		if (/<[^>]+>/.test(headerValue)) {
-			warnings.push(
-				`Header "${name}" looks like it contains a placeholder. Update it in MCP settings before using this server.`,
-			);
-		}
-	}
-	return { headers, warnings };
-}
-
 function quoteCommandArg(arg: string): string {
 	if (/^[^\s"'\\]+$/.test(arg)) {
 		return arg;
@@ -169,70 +91,6 @@ export function buildMcpInstallDefaults(options: {
 	};
 }
 
-export function buildMcpInstallTransport(options: {
-	headers?: string[];
-	name: string;
-	targetArgs?: string[];
-	transport?: string;
-}): { name: string; transport: McpTransport; warnings: string[] } {
-	const name = options.name.trim();
-	if (!name) {
-		throw new Error("MCP server name is required");
-	}
-	const type = normalizeTransportType(options.transport);
-	const { headers: rawHeaders, targetArgs } = splitTargetArgsAndHeaders({
-		headers: options.headers,
-		targetArgs: options.targetArgs,
-	});
-	const { headers, warnings } = buildHeaders(rawHeaders);
-	if (type === "stdio") {
-		if (rawHeaders.length > 0) {
-			throw new Error("Stdio MCP installs do not support request headers.");
-		}
-		const [command, ...args] = targetArgs;
-		if (!command?.trim()) {
-			throw new Error(
-				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs --yes -- npx -y @modelcontextprotocol/server-filesystem /tmp",
-			);
-		}
-		return {
-			name,
-			transport: {
-				type,
-				command,
-				args: args.length > 0 ? args : undefined,
-			},
-			warnings,
-		};
-	}
-
-	if (targetArgs.length !== 1) {
-		throw new Error(
-			"Remote MCP install requires exactly one URL argument after the server name.",
-		);
-	}
-	const url = targetArgs[0]?.trim() ?? "";
-	assertValidUrl(url);
-	return {
-		name,
-		transport: headers ? { type, url, headers } : { type, url },
-		warnings,
-	};
-}
-
-export function installMcpServerDirect(
-	options: McpInstallOptions,
-): McpInstallDirectResult {
-	const { name, transport, warnings } = buildMcpInstallTransport(options);
-	addServer(name, transport);
-	return {
-		name,
-		status: "installed",
-		transport,
-		warnings,
-	};
-}
-
 async function runPrefilledWizard(defaults: McpAddDefaults): Promise<number> {
 	const { runMcpWizard } = await import("../wizards/mcp");
 	return runMcpWizard({
@@ -246,23 +104,11 @@ export async function runMcpInstallCommand(
 	options: McpInstallOptions,
 ): Promise<number> {
 	try {
-		if (options.yes) {
-			const result = installMcpServerDirect(options);
-			if (options.json) {
-				options.io?.writeln?.(JSON.stringify(result));
-			} else {
-				options.io?.writeln?.(`Installed MCP server ${result.name}.`);
-				for (const warning of result.warnings) {
-					options.io?.writeErr(warning);
-				}
-			}
-			return 0;
-		}
 		const isTty =
 			options.isTty ?? (process.stdin.isTTY && process.stdout.isTTY);
 		if (!isTty) {
 			throw new Error(
-				"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+				"cline mcp install opens the MCP wizard and requires a TTY.",
 			);
 		}
 		const defaults = buildMcpInstallDefaults(options);

apps/cli/src/commands/program.ts

@@ -33,7 +33,7 @@ export function addRootOptions(cmd: Command): Command {
 			.option("-c, --cwd <path>", "Working directory")
 			.option(
 				"--thinking <level>",
-				"Set reasoning effort: none|low|medium|high|xhigh. Bare --thinking uses medium; omitted leaves provider default.",
+				"Set reasoning effort level between none|low|medium|high|xhigh (default: medium)",
 			)
 			.option("--compaction <mode>", CLI_COMPACTION_MODE_OPTION_DESCRIPTION)
 			.option(

apps/cli/src/connectors/session-runtime.test.ts

@@ -125,12 +125,12 @@ describe("buildConnectorStartRequest", () => {
 			io: { writeln: vi.fn(), writeErr: vi.fn() },
 			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
 			systemRules: "Rules",
-			defaultModel: "cline-pass/glm-5.1",
+			defaultModel: "cline-pass/glm-5.2",
 		});
 
 		expect(request.provider).toBe("cline-pass");
 		expect(request.apiKey).toBe("workos:resolved-token");
-		expect(request.model).toBe("cline-pass/glm-5.1");
+		expect(request.model).toBe("cline-pass/glm-5.2");
 	});
 
 	it("uses auth material resolved by provider settings manager", async () => {
@@ -153,11 +153,11 @@ describe("buildConnectorStartRequest", () => {
 			io: { writeln: vi.fn(), writeErr: vi.fn() },
 			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
 			systemRules: "Rules",
-			defaultModel: "cline-pass/glm-5.1",
+			defaultModel: "cline-pass/glm-5.2",
 		});
 
 		expect(request.provider).toBe("cline-pass");
 		expect(request.apiKey).toBe("workos:resolved-token");
-		expect(request.model).toBe("cline-pass/glm-5.1");
+		expect(request.model).toBe("cline-pass/glm-5.2");
 	});
 });

apps/cli/src/main.test.ts

@@ -1082,7 +1082,7 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});
 
-	it("leaves thinking unset when --thinking is not provided", async () => {
+	it("leaves thinking disabled when --thinking is not provided", async () => {
 		mockState.runAgentCalls = 0;
 		runtimeMocks.runAgent.mockClear();
 
@@ -1091,27 +1091,6 @@ describe("runCli lightweight command dispatch", () => {
 
 		const { runCli } = await import("./main");
 
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(mockState.runAgentCalls).toBe(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"hello",
-			expect.objectContaining({
-				thinking: undefined,
-				reasoningEffort: undefined,
-			}),
-			expect.anything(),
-		);
-	});
-
-	it("disables thinking when --thinking none is explicitly provided", async () => {
-		mockState.runAgentCalls = 0;
-		runtimeMocks.runAgent.mockClear();
-
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--thinking", "none", "hello"];
-
-		const { runCli } = await import("./main");
-
 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
@@ -1175,32 +1154,6 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});
 
-	it("uses persisted disabled reasoning when --thinking is not provided", async () => {
-		mockState.runAgentCalls = 0;
-		runtimeMocks.runAgent.mockClear();
-		providerSettingsMocks.getProviderSettings.mockReturnValue({
-			provider: "cline",
-			model: "openai/gpt-5",
-			reasoning: { enabled: false },
-		});
-
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "hello"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(mockState.runAgentCalls).toBe(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"hello",
-			expect.objectContaining({
-				thinking: false,
-				reasoningEffort: undefined,
-			}),
-			expect.anything(),
-		);
-	});
-
 	it("prefers explicit --thinking over persisted reasoning effort", async () => {
 		mockState.runAgentCalls = 0;
 		runtimeMocks.runAgent.mockClear();

apps/cli/src/main.ts

@@ -42,7 +42,6 @@ import {
 	isOAuthProvider,
 	normalizeProviderId,
 } from "./utils/provider-auth";
-import { resolveCliReasoning } from "./utils/reasoning";
 import { rewriteTeamPrompt, TEAM_COMMAND_USAGE } from "./utils/team-command";
 import {
 	captureCliExtensionActivated,
@@ -113,10 +112,6 @@ export function resolveConfigDirArg(argv: string[]): string | undefined {
 	return undefined;
 }
 
-function collectOption(value: string, previous: string[] = []): string[] {
-	return [...previous, value];
-}
-
 export async function runCli(): Promise<void> {
 	installStreamErrorGuards();
 	autoUpdateOnStartup();
@@ -409,24 +404,15 @@ export async function runCli(): Promise<void> {
 			"--transport <transport>",
 			"stdio, sse, http, streamable-http, or streamableHttp (default: stdio)",
 		)
-		.option("--header <header>", "Remote MCP request header", collectOption, [])
-		.option("--yes", "Install noninteractively without opening the wizard")
-		.option("--json", "Output as JSON")
 		.action(async (name: string, targetArgs: string[]) => {
 			const opts = mcpInstallCmd.opts<{
-				header?: string[];
-				json?: boolean;
 				transport?: string;
-				yes?: boolean;
 			}>();
 			const { runMcpInstallCommand } = await import("./commands/mcp");
 			ctx.exitCode = await runMcpInstallCommand({
 				name,
-				headers: opts.header,
 				targetArgs,
 				transport: opts.transport,
-				json: opts.json === true || program.opts().json === true,
-				yes: opts.yes === true,
 				io,
 			});
 		});
@@ -1012,12 +998,19 @@ export async function runCli(): Promise<void> {
 			);
 		}
 		const knownModelIds = knownModels ? Object.keys(knownModels) : [];
-		const resolvedReasoning = resolveCliReasoning({
-			thinking: args.thinking,
-			thinkingExplicitlySet: args.thinkingExplicitlySet,
-			reasoningEffort: args.reasoningEffort,
-			persistedReasoning: selectedProviderSettings?.reasoning,
-		});
+		const persistedReasoning = selectedProviderSettings?.reasoning;
+		const persistedReasoningEffort = persistedReasoning?.effort;
+		const reasoningEffortFromSettings =
+			persistedReasoning?.enabled === false
+				? "none"
+				: persistedReasoningEffort && persistedReasoningEffort !== "none"
+					? persistedReasoningEffort
+					: persistedReasoning?.enabled === true
+						? "medium"
+						: "none";
+		const effectiveReasoningEffort = args.thinkingExplicitlySet
+			? (args.reasoningEffort ?? "none")
+			: (args.reasoningEffort ?? reasoningEffortFromSettings);
 		const { createCliLoggerAdapter } = await import("./logging/adapter");
 		const loggerAdapter = createCliLoggerAdapter({
 			runtime: "cli",
@@ -1053,8 +1046,11 @@ export async function runCli(): Promise<void> {
 			sandbox: sandboxEnabled,
 			sandboxDataDir,
 			verbose: args.verbose,
-			thinking: resolvedReasoning.thinking,
-			reasoningEffort: resolvedReasoning.reasoningEffort,
+			thinking: effectiveReasoningEffort !== "none",
+			reasoningEffort:
+				effectiveReasoningEffort === "none"
+					? undefined
+					: effectiveReasoningEffort,
 			outputMode: args.outputMode,
 			mode: args.mode,
 			logger: loggerAdapter.core,

apps/cli/src/runtime/run-agent.test.ts

@@ -39,10 +39,7 @@ const sessionEventsMocks = vi.hoisted(() => ({
 
 const CLINE_PASS_SUBSCRIPTION_URL =
 	"https://app.cline.bot/dashboard/subscription?personal=true";
-const CLI_SUBSCRIPTION_URL =
-	"https://app.cline.bot/promo?code=CLI-100&personal=true";
-const SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLINE_PASS_SUBSCRIPTION_URL}`;
-const CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLI_SUBSCRIPTION_URL}`;
+const CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLINE_PASS_SUBSCRIPTION_URL}`;
 const CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE =
 	"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass";
 
@@ -552,7 +549,7 @@ describe("runAgent", () => {
 	});
 
 	it("renders ClinePass subscription errors with friendly copy when startup throws", async () => {
-		const error = new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE);
+		const error = new Error(CLINE_PASS_SUBSCRIPTION_MESSAGE);
 		error.name = "ClineNotSubscribedError";
 		sessionManagerMocks.start.mockRejectedValue(error);
 
@@ -580,7 +577,7 @@ describe("runAgent", () => {
 
 		expect(process.exitCode).toBe(1);
 		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+			CLINE_PASS_SUBSCRIPTION_MESSAGE,
 		);
 	});
 
@@ -658,7 +655,7 @@ describe("runAgent", () => {
 			messagesPath: "/tmp/messages.json",
 			manifest: { session_id: "session-1" },
 			result: {
-				text: SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+				text: CLINE_PASS_SUBSCRIPTION_MESSAGE,
 				usage: {
 					inputTokens: 0,
 					outputTokens: 0,
@@ -702,73 +699,10 @@ describe("runAgent", () => {
 
 		expect(process.exitCode).toBe(1);
 		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+			CLINE_PASS_SUBSCRIPTION_MESSAGE,
 		);
 	});
 
-	it("does not duplicate ClinePass subscription errors already displayed by agent events", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		sessionManagerMocks.start.mockImplementation(async () => {
-			sessionEventsMocks.listener?.({
-				type: "error",
-				error: new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE),
-				recoverable: false,
-			});
-
-			return {
-				sessionId: "session-1",
-				manifestPath: "/tmp/manifest.json",
-				messagesPath: "/tmp/messages.json",
-				manifest: { session_id: "session-1" },
-				result: {
-					text: SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE,
-					usage: {
-						inputTokens: 0,
-						outputTokens: 0,
-						cacheReadTokens: 0,
-						cacheWriteTokens: 0,
-						totalCost: 0,
-					},
-					messages: [],
-					toolCalls: [],
-					iterations: 1,
-					finishReason: "error",
-					model: { id: "premium-model", provider: "cline-pass", info: {} },
-					startedAt,
-					endedAt,
-					durationMs: 1000,
-				},
-			};
-		});
-		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
-
-		const { runAgent } = await import("./run-agent");
-
-		await expect(
-			runAgent("test prompt", {
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: { maxConsecutiveMistakes: 3 },
-				logger: undefined,
-				mode: "yolo",
-				modelId: "premium-model",
-				outputMode: "text",
-				providerId: "cline-pass",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		expect(process.exitCode).toBe(1);
-		expect(outputMocks.writeErr).not.toHaveBeenCalled();
-	});
-
 	it("surfaces post-run bookkeeping failures after a completed result", async () => {
 		const startedAt = new Date("2026-03-22T00:00:00.000Z");
 		const endedAt = new Date("2026-03-22T00:00:01.000Z");

apps/cli/src/runtime/run-agent.ts

@@ -204,9 +204,7 @@ export async function runAgent(
 			(!event.recoverable || config.verbose) &&
 			event.error.message.trim()
 		) {
-			displayedErrorMessages.add(
-				formatCliErrorMessage(event.error.message).trim(),
-			);
+			displayedErrorMessages.add(event.error.message.trim());
 		}
 		handleEvent(event, config);
 	};

apps/cli/src/runtime/run-interactive.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveReasoningForModelChange } from "./run-interactive";
-
-describe("resolveReasoningForModelChange", () => {
-	it("persists disabled reasoning only when thinking is explicitly false", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: false, reasoningEffort: undefined },
-				{ reasoning: { enabled: true, effort: "high" } },
-			),
-		).toEqual({ enabled: false });
-	});
-
-	it("persists enabled reasoning with the selected effort", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: true, reasoningEffort: "low" },
-				{ reasoning: { enabled: false } },
-			),
-		).toEqual({ enabled: true, effort: "low" });
-	});
-
-	it("persists enabled reasoning when thinking is explicitly true without effort", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: true, reasoningEffort: undefined },
-				{ reasoning: { enabled: false } },
-			),
-		).toEqual({ enabled: true });
-	});
-
-	it("preserves existing reasoning when thinking is unset", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: undefined, reasoningEffort: undefined },
-				{ reasoning: { enabled: true, effort: "medium" } },
-			),
-		).toEqual({ enabled: true, effort: "medium" });
-	});
-});

apps/cli/src/runtime/run-interactive.ts

@@ -57,23 +57,6 @@ import { createInteractiveSessionRuntime } from "./interactive/session-runtime";
 import { buildUserInputMessage } from "./prompt";
 import { getUIEventEmitter } from "./session-events";
 
-type ModelChangeReasoningConfig = {
-	thinking?: boolean;
-	reasoningEffort?: Config["reasoningEffort"];
-};
-
-export function resolveReasoningForModelChange(
-	config: ModelChangeReasoningConfig,
-	existing: Pick<ProviderSettings, "reasoning">,
-): ProviderSettings["reasoning"] {
-	if (config.thinking === false) return { enabled: false };
-	if (config.reasoningEffort) {
-		return { enabled: true, effort: config.reasoningEffort };
-	}
-	if (config.thinking === true) return { enabled: true };
-	return existing.reasoning;
-}
-
 export async function runInteractive(
 	config: Config,
 	userInstructionService?: UserInstructionConfigService,
@@ -654,11 +637,12 @@ export async function runInteractive(
 			) ?? {
 				provider: config.providerId,
 			};
-			const reasoning = resolveReasoningForModelChange(config, existing);
 			providerSettingsManager.saveProviderSettings({
 				...existing,
 				model: config.modelId,
-				...(reasoning === undefined ? {} : { reasoning }),
+				reasoning: config.reasoningEffort
+					? { enabled: true, effort: config.reasoningEffort }
+					: { enabled: false },
 			});
 			await sessionRuntime.restartWithCurrentMessages();
 		},

apps/cli/src/tests/flags.test.ts

@@ -3,11 +3,7 @@ import { CLINE_BIN } from "./helpers/constants.js";
 import { clineEnv } from "./helpers/env.js";
 import { expectVisible } from "./helpers/terminal.js";
 
-// Wide enough that long option descriptions (e.g. --thinking) render on a
-// single line. At narrower widths commander wraps them, splitting phrases
-// like "omitted leaves provider default" across lines so the contiguous
-// getByText assertions below fail.
-const HELP_TERMINAL = { columns: 200, rows: 50 };
+const HELP_TERMINAL = { columns: 120, rows: 50 };
 
 // ===========================================================================
 // Root-level flag descriptions
@@ -27,11 +23,10 @@ test.describe("root flag descriptions", () => {
 			"verbose output",
 			"Working directory",
 			"Configuration directory",
-			"Set reasoning effort:",
-			"Bare --thinking uses medium",
-			"omitted leaves provider default",
+			"Set reasoning effort level",
 			"consecutive mistakes",
 			"Output messages as JSON",
+			"ACP",
 			"Check for updates and install if available",
 			"Run the kanban app",
 		]);

apps/cli/src/tui/components/chat-entry.tsx

@@ -3,8 +3,8 @@ import type React from "react";
 import { useState } from "react";
 import "opentui-spinner/react";
 import {
-	getCliSubscriptionUrl,
 	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
 	isClineOrgIndividualInferenceSubscriptionErrorMessage,
 	isClinePassSubscriptionError,
 } from "../../utils/cline-pass-errors";
@@ -297,7 +297,7 @@ function ClineCreditsErrorView(props: { defaultFg?: string }) {
 }
 
 function ClinePassSubscriptionErrorView(props: { defaultFg?: string }) {
-	const subscriptionUrl = getCliSubscriptionUrl();
+	const subscriptionUrl = getClinePassSubscriptionUrl();
 	return (
 		<box flexDirection="row">
 			<text fg="yellow" content="* " />
@@ -455,9 +455,7 @@ export function ChatEntryView(props: {
 			}
 			if (isClineOrgIndividualInferenceSubscriptionErrorMessage(entry.text)) {
 				return (
-					<ClineOrgIndividualInferenceSubscriptionErrorView
-						defaultFg={defaultFg}
-					/>
+					<ClineOrgIndividualInferenceSubscriptionErrorView defaultFg={defaultFg} />
 				);
 			}
 			if (isClinePassSubscriptionError(entry.text)) {

apps/cli/src/utils/cline-pass-errors.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, it } from "vitest";
 import {
 	formatCliErrorMessage,
-	getCliNotSubscribedMessage,
-	getCliSubscriptionUrl,
 	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
 	isClineOrgIndividualInferenceSubscriptionErrorMessage,
 	isClinePassSubscriptionError,
 } from "./cline-pass-errors";
@@ -16,18 +15,14 @@ describe("cline-pass-errors", () => {
 			),
 		).toBe(true);
 
-		const sdkFormatted =
-			"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/dashboard/subscription?personal=true";
-		const formatted = getCliNotSubscribedMessage();
-		expect(isClinePassSubscriptionError(sdkFormatted)).toBe(true);
+		const formatted = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getClinePassSubscriptionUrl()}`;
 		expect(isClinePassSubscriptionError(formatted)).toBe(true);
-		expect(formatCliErrorMessage(new Error(sdkFormatted))).toBe(formatted);
 		expect(formatCliErrorMessage(new Error(formatted))).toBe(formatted);
 	});
 
 	it("formats the ClinePass subscription URL", () => {
-		expect(getCliSubscriptionUrl()).toBe(
-			"https://app.cline.bot/promo?code=CLI-100&personal=true",
+		expect(getClinePassSubscriptionUrl()).toBe(
+			"https://app.cline.bot/dashboard/subscription?personal=true",
 		);
 	});
 

apps/cli/src/utils/cline-pass-errors.ts

@@ -1,28 +1,17 @@
 import {
 	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
 	isClineNotSubscribedError,
 	isClineNotSubscribedMessage,
 	isClineOrgIndividualInferenceSubscriptionError,
 	isClineOrgIndividualInferenceSubscriptionMessage,
 } from "@cline/core";
 
-import { getClineEnvironmentConfig } from "@cline/shared";
-
 export {
 	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
 };
 
-export function getCliSubscriptionUrl(): string {
-	return `${new URL(
-		"/promo?code=CLI-100&personal=true",
-		getClineEnvironmentConfig().appBaseUrl,
-	).toString()}`;
-}
-
-export function getCliNotSubscribedMessage(): string {
-	return `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getCliSubscriptionUrl()}`;
-}
-
 function isFormattedClinePassSubscriptionMessage(message: string): boolean {
 	const normalized = message.trim().toLowerCase();
 	return (
@@ -70,9 +59,6 @@ export function isClineOrgIndividualInferenceSubscriptionErrorMessage(
 }
 
 export function formatCliErrorMessage(error: unknown): string {
-	if (isClinePassSubscriptionError(error)) {
-		return getCliNotSubscribedMessage();
-	}
 	if (isClineOrgIndividualInferenceSubscriptionErrorMessage(error)) {
 		return getClineOrgIndividualInferenceSubscriptionMessage();
 	}

apps/cli/src/utils/reasoning.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveCliReasoning } from "./reasoning";
-
-describe("resolveCliReasoning", () => {
-	it("leaves reasoning unset when neither CLI nor persisted settings specify it", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-			}),
-		).toEqual({
-			thinking: undefined,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("preserves explicit --thinking none as disabled reasoning", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				thinkingExplicitlySet: true,
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("prefers explicit --thinking over persisted reasoning settings", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: true,
-				thinkingExplicitlySet: true,
-				reasoningEffort: "low",
-				persistedReasoning: { enabled: false },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "low",
-		});
-	});
-
-	it("uses persisted disabled reasoning when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: false },
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("uses persisted effort none as disabled reasoning when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { effort: "none" },
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("uses persisted active effort when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: true, effort: "high" },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "high",
-		});
-	});
-
-	it("uses medium effort when persisted reasoning is enabled without an effort", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: true },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "medium",
-		});
-	});
-});

apps/cli/src/utils/reasoning.ts

@@ -1,65 +0,0 @@
-import type { ProviderSettings } from "@cline/core";
-import type { CliReasoningEffort } from "./types";
-
-type ActiveCliReasoningEffort = Exclude<CliReasoningEffort, "none">;
-
-const ACTIVE_REASONING_EFFORTS = new Set<ActiveCliReasoningEffort>([
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-]);
-
-export interface ResolveCliReasoningInput {
-	thinking: boolean;
-	thinkingExplicitlySet?: boolean;
-	reasoningEffort?: CliReasoningEffort;
-	persistedReasoning?: ProviderSettings["reasoning"];
-}
-
-export interface ResolvedCliReasoning {
-	thinking?: boolean;
-	reasoningEffort?: ActiveCliReasoningEffort;
-}
-
-function isActiveReasoningEffort(
-	effort: unknown,
-): effort is ActiveCliReasoningEffort {
-	return (
-		typeof effort === "string" &&
-		ACTIVE_REASONING_EFFORTS.has(effort as ActiveCliReasoningEffort)
-	);
-}
-
-export function resolveCliReasoning({
-	thinking,
-	thinkingExplicitlySet,
-	reasoningEffort,
-	persistedReasoning,
-}: ResolveCliReasoningInput): ResolvedCliReasoning {
-	if (thinkingExplicitlySet) {
-		return {
-			thinking,
-			reasoningEffort: isActiveReasoningEffort(reasoningEffort)
-				? reasoningEffort
-				: undefined,
-		};
-	}
-
-	if (
-		persistedReasoning?.enabled === false ||
-		persistedReasoning?.effort === "none"
-	) {
-		return { thinking: false, reasoningEffort: undefined };
-	}
-
-	if (isActiveReasoningEffort(persistedReasoning?.effort)) {
-		return { thinking: true, reasoningEffort: persistedReasoning.effort };
-	}
-
-	if (persistedReasoning?.enabled === true) {
-		return { thinking: true, reasoningEffort: "medium" };
-	}
-
-	return { thinking: undefined, reasoningEffort: undefined };
-}

apps/cli/src/utils/types.ts

@@ -25,7 +25,7 @@ export interface Config extends Omit<CoreSessionConfig, "apiKey" | "mode"> {
 	timeoutSeconds?: number;
 	sandbox: boolean;
 	sandboxDataDir?: string;
-	thinking?: boolean;
+	thinking: boolean;
 	outputMode: CliOutputMode;
 	mode: CliAgentMode;
 	defaultToolAutoApprove: boolean;

apps/cli/src/wizards/mcp/settings.test.ts

@@ -57,17 +57,6 @@ describe("MCP wizard settings", () => {
 		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
 	});
 
-	it("creates the settings file when adding a server to a missing path", async () => {
-		const settingsPath = await useTempSettingsPath();
-
-		addServer("added", { type: "stdio", command: "npx", args: ["server"] });
-
-		const parsed = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<string, unknown>;
-		};
-		expect(Object.keys(parsed.mcpServers ?? {})).toEqual(["added"]);
-	});
-
 	it("parses quoted stdio command arguments", () => {
 		expect(
 			parseStdioCommand('npx -y "@scope/server name" --root "my dir"'),

apps/cli/src/wizards/mcp/settings.ts

@@ -1,9 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import {
 	type McpServerOAuthState,
-	McpSettingsUpdateSkippedError,
 	resolveDefaultMcpSettingsPath,
-	updateMcpSettingsFileSync,
 } from "@cline/core";
 
 export interface McpServerEntry {
@@ -57,6 +56,28 @@ export function loadServers(): McpServerEntry[] {
 	}
 }
 
+function readRawSettings(): Record<string, unknown> {
+	const path = getSettingsPath();
+	if (!existsSync(path)) return {};
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: {};
+	} catch {
+		return {};
+	}
+}
+
+function readRawServers(): Record<string, unknown> {
+	const settings = readRawSettings();
+	const servers = settings.mcpServers;
+	return servers && typeof servers === "object" && !Array.isArray(servers)
+		? { ...(servers as Record<string, unknown>) }
+		: {};
+}
+
 function getOwnServerRecord(
 	servers: Record<string, unknown>,
 	name: string,
@@ -71,85 +92,62 @@ function getOwnServerRecord(
 	return value as Record<string, unknown>;
 }
 
-/**
- * Mutate the MCP settings file through @cline/core's locked read-update-write
- * helper. The mutator must be synchronous and pure; the helper may call it more
- * than once to verify deterministic output. Throw McpSettingsUpdateSkippedError
- * for normal no-op cases instead of returning a boolean that callers can ignore.
- */
-function mutateServers(mutate: (servers: Record<string, unknown>) => void): void {
-	updateMcpSettingsFileSync(getSettingsPath(), (settings) => {
-		const serversValue = settings.mcpServers;
-		const servers = serversValue && typeof serversValue === "object" && !Array.isArray(serversValue)
-			? { ...(serversValue as Record<string, unknown>) }
-			: {};
-		mutate(servers);
-		settings.mcpServers = servers;
-	});
+function writeServers(servers: Record<string, unknown>): void {
+	const path = getSettingsPath();
+	const settings = readRawSettings();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(
+		path,
+		`${JSON.stringify({ ...settings, mcpServers: servers }, null, 2)}\n`,
+	);
 }
 
 export function addServer(name: string, transport: McpTransport): void {
-	mutateServers((servers) => {
-		servers[name] = { transport };
-	});
+	const servers = readRawServers();
+	servers[name] = { transport };
+	writeServers(servers);
 }
 
 export function removeServer(name: string): boolean {
-	try {
-		mutateServers((servers) => {
-			if (!(name in servers)) {
-				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
-			}
-			delete servers[name];
-		});
-		return true;
-	} catch (error) {
-		if (error instanceof McpSettingsUpdateSkippedError) {
-			return false;
-		}
-		throw error;
-	}
+	const servers = readRawServers();
+	if (!(name in servers)) return false;
+	delete servers[name];
+	writeServers(servers);
+	return true;
 }
 
 export function updateServer(name: string, transport: McpTransport): void {
-	mutateServers((servers) => {
-		const existing =
-			servers[name] && typeof servers[name] === "object"
-				? (servers[name] as Record<string, unknown>)
-				: {};
-		servers[name] = { ...existing, transport };
-	});
+	const servers = readRawServers();
+	const existing =
+		servers[name] && typeof servers[name] === "object"
+			? (servers[name] as Record<string, unknown>)
+			: {};
+	servers[name] = { ...existing, transport };
+	writeServers(servers);
 }
 
 export function clearServerOAuth(name: string): void {
-	try {
-		mutateServers((servers) => {
-			const existing = getOwnServerRecord(servers, name);
-			if (!existing) {
-				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
-			}
-			delete existing.oauth;
-			servers[name] = existing;
-		});
-	} catch (error) {
-		if (error instanceof McpSettingsUpdateSkippedError) {
-			return;
-		}
-		throw error;
+	const servers = readRawServers();
+	const existing = getOwnServerRecord(servers, name);
+	if (!existing) {
+		return;
 	}
+	delete existing.oauth;
+	servers[name] = existing;
+	writeServers(servers);
 }
 
 export function toggleServer(name: string, disabled: boolean): void {
-	mutateServers((servers) => {
-		const existing =
-			servers[name] && typeof servers[name] === "object"
-				? (servers[name] as Record<string, unknown>)
-				: {};
-		if (disabled) {
-			existing.disabled = true;
-		} else {
-			delete existing.disabled;
-		}
-		servers[name] = existing;
-	});
+	const servers = readRawServers();
+	const existing =
+		servers[name] && typeof servers[name] === "object"
+			? (servers[name] as Record<string, unknown>)
+			: {};
+	if (disabled) {
+		existing.disabled = true;
+	} else {
+		delete existing.disabled;
+	}
+	servers[name] = existing;
+	writeServers(servers);
 }

apps/cline-hub/src/server/marketplace.test.ts

@@ -51,23 +51,18 @@ describe("marketplace installer", () => {
 		vi.restoreAllMocks();
 	});
 
-	it("maps remote MCP catalog args to MCP settings shape", () => {
+	it("maps remote MCP catalog args to the hub MCP upsert shape", () => {
 		expect(
 			buildMarketplaceMcpInput([
 				"context7",
 				"--transport",
 				"http",
 				"https://mcp.context7.com/mcp",
-				"--header",
-				"Authorization: Bearer <token>",
 			]),
 		).toEqual({
 			name: "context7",
 			transportType: "streamableHttp",
 			url: "https://mcp.context7.com/mcp",
-			headers: {
-				Authorization: "Bearer <token>",
-			},
 			disabled: false,
 		});
 	});
@@ -353,7 +348,7 @@ describe("marketplace installer", () => {
 		const spawnCommand = vi.fn(async () => ({
 			exitCode: 1,
 			stdout:
-				"Authorization: Bearer stdout-token\nAuthorization: Basic basic-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
+				"Authorization: Bearer stdout-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
 			stderr:
 				"TOKEN=stderr-token\npassword is stderr-password\nANTHROPIC_SECRET_KEY=anthropic-secret",
 		}));
@@ -375,16 +370,13 @@ describe("marketplace installer", () => {
 			message = error instanceof Error ? error.message : String(error);
 		}
 
-		expect(message).toContain("Authorization: Bearer [redacted]");
 		expect(message).toContain("Authorization: [redacted]");
-		expect(message).not.toContain("Authorization: Bearer [redacted]]");
 		expect(message).toContain("api key [redacted]");
 		expect(message).toContain("OPENAI_API_KEY=[redacted]");
 		expect(message).toContain("TOKEN=[redacted]");
 		expect(message).toContain("password is [redacted]");
 		expect(message).toContain("ANTHROPIC_SECRET_KEY=[redacted]");
 		expect(message).not.toContain("stdout-token");
-		expect(message).not.toContain("basic-token");
 		expect(message).not.toContain("stdout-key");
 		expect(message).not.toContain("compound-key");
 		expect(message).not.toContain("stderr-token");
@@ -473,68 +465,6 @@ describe("marketplace installer", () => {
 		]);
 	});
 
-	it("runs MCP installs through the current Cline CLI without prompts", async () => {
-		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: JSON.stringify({
-				name: "context7",
-				status: "installed",
-				transport: {
-					type: "streamableHttp",
-					url: "https://mcp.context7.com/mcp",
-					headers: {
-						Authorization: "Bearer token",
-					},
-				},
-			}),
-			stderr: "",
-		}));
-
-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "context7",
-						type: "mcp",
-						name: "Context7",
-						install: {
-							args: [
-								"context7",
-								"--transport",
-								"http",
-								"https://mcp.context7.com/mcp",
-								"--header",
-								"Authorization: Bearer token",
-							],
-						},
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "installed",
-			message: "Installed Context7.",
-			details: {
-				name: "context7",
-				status: "installed",
-			},
-		});
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"mcp",
-			"install",
-			"--yes",
-			"--json",
-			"context7",
-			"--transport",
-			"http",
-			"https://mcp.context7.com/mcp",
-			"--header",
-			"Authorization: Bearer token",
-		]);
-	});
-
 	it("runs official plugin uninstalls through the current Cline CLI", async () => {
 		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
 		const spawnCommand = vi.fn(async () => ({

apps/cline-hub/src/server/marketplace.ts

@@ -8,7 +8,7 @@ import {
 	unlinkSync,
 	writeFileSync,
 } from "node:fs";
-import { homedir as osHomedir, platform } from "node:os";
+import { homedir, platform } from "node:os";
 import {
 	basename,
 	dirname,
@@ -23,7 +23,11 @@ import {
 	uninstallPlugin as uninstallLocalPlugin,
 } from "@cline/core";
 import { resolveClineDir } from "@cline/shared/storage";
-import { deleteMcpServer, readMcpServersResponse } from "./mcp";
+import {
+	deleteMcpServer,
+	readMcpServersResponse,
+	upsertMcpServer,
+} from "./mcp";
 import type { JsonRecord } from "./types";
 
 type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
@@ -86,12 +90,6 @@ const MARKETPLACE_CATALOG_URL =
 	"https://cline.github.io/marketplace/catalog.json";
 const SECRET_PATTERN =
 	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i;
-const SECRET_KEY_VALUE_PATTERN =
-	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi;
-const SECRET_BEARER_VALUE_PATTERN =
-	/((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi;
-const SECRET_AUTHORIZATION_VALUE_PATTERN =
-	/((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi;
 
 export async function fetchMarketplaceCatalog(
 	fetchImpl: CatalogFetch = fetch,
@@ -272,10 +270,11 @@ function redactOutput(value: string): string {
 	const lines = value.split(/\r?\n/).map((line) => {
 		if (!SECRET_PATTERN.test(line)) return line;
 		return line
-			.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
-			.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
-			.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
-			.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+			.replace(
+				/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi,
+				"$1[redacted]",
+			)
+			.replace(/\b(Bearer)\s+\S+/gi, "$1 [redacted]")
 			.replace(
 				/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
 				"$1[redacted]",
@@ -375,7 +374,6 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 		throw new Error("MCP marketplace install requires a server name");
 	}
 	let transportType = "stdio";
-	const headers: Record<string, string> = {};
 	const targetArgs: string[] = [];
 	let parsingMarketplaceOptions = true;
 	for (let index = 0; index < rest.length; index++) {
@@ -391,40 +389,11 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 			index++;
 			continue;
 		}
-		const shouldParseHeader =
-			parsingMarketplaceOptions ||
-			normalizeTransport(transportType) !== "stdio";
-		if (
-			shouldParseHeader &&
-			(arg === "--header" || arg?.startsWith("--header="))
-		) {
-			const rawHeader =
-				arg === "--header" ? rest[++index] : arg.slice("--header=".length);
-			if (!rawHeader) throw new Error("--header requires a value");
-			const separatorIndex = rawHeader.indexOf(":");
-			if (separatorIndex <= 0) {
-				throw new Error(
-					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
-				);
-			}
-			const headerName = rawHeader.slice(0, separatorIndex).trim();
-			const headerValue = rawHeader.slice(separatorIndex + 1).trim();
-			if (!headerName || !headerValue) {
-				throw new Error(
-					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
-				);
-			}
-			headers[headerName] = headerValue;
-			continue;
-		}
 		parsingMarketplaceOptions = false;
 		targetArgs.push(arg);
 	}
 	transportType = normalizeTransport(transportType);
 	if (transportType === "stdio") {
-		if (Object.keys(headers).length > 0) {
-			throw new Error("Stdio MCP installs do not support request headers.");
-		}
 		const [command, ...commandArgs] = targetArgs;
 		if (!command?.trim()) {
 			throw new Error("Stdio MCP install requires a command");
@@ -446,7 +415,6 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 		name,
 		transportType,
 		url,
-		headers: Object.keys(headers).length > 0 ? headers : undefined,
 		disabled: false,
 	};
 }
@@ -602,12 +570,6 @@ function isOfficialPluginInstalled(entry: MarketplaceInstallInput): boolean {
 	return Boolean(installPath && existsSync(installPath));
 }
 
-function resolveHomeDir(): string {
-	return (
-		process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || osHomedir()
-	);
-}
-
 function normalizeMatchValue(value: string | undefined): string {
 	return (value ?? "")
 		.toLowerCase()
@@ -644,12 +606,12 @@ function getSkillInstallCandidates(entry: MarketplaceInstallInput): string[] {
 function getGlobalSkillPaths(skillName: string): string[] {
 	return [
 		join(resolveClineDir(), "skills", skillName, "SKILL.md"),
-		join(resolveHomeDir(), ".agents", "skills", skillName, "SKILL.md"),
+		join(homedir(), ".agents", "skills", skillName, "SKILL.md"),
 	].filter((path, index, paths) => paths.indexOf(path) === index);
 }
 
 function ensureGlobalSkillsDirWritable(): void {
-	const skillsDir = join(resolveHomeDir(), ".agents", "skills");
+	const skillsDir = join(homedir(), ".agents", "skills");
 	try {
 		mkdirSync(skillsDir, { recursive: true });
 		const probePath = join(
@@ -934,38 +896,14 @@ export async function installMarketplaceEntry(
 	const entry = readInstallInput(args);
 	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
 	if (entry.type === "mcp") {
-		// Validate marketplace args before handing them to the CLI-backed installer.
-		buildMarketplaceMcpInput(entry.install.args ?? []);
-		const { command, argsPrefix } = resolveClineInvocation();
-		const result = await spawnCommand(command, [
-			...argsPrefix,
-			"mcp",
-			"install",
-			"--yes",
-			"--json",
-			...(entry.install.args ?? []),
-		]);
-		if (result.exitCode !== 0) {
-			const output = commandOutput(result);
-			throw new Error(
-				`MCP install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
-			);
-		}
-		let details: JsonRecord | undefined;
-		try {
-			details = result.stdout.trim()
-				? (JSON.parse(result.stdout.trim()) as JsonRecord)
-				: undefined;
-		} catch {
-			details = undefined;
-		}
+		const input = buildMarketplaceMcpInput(entry.install.args ?? []);
+		const response = upsertMcpServer(input);
 		return {
 			id: entry.id,
 			type: entry.type,
 			status: "installed",
-			message: `Installed ${entry.name ?? entry.id}.`,
-			details,
-			output: commandOutput(result),
+			message: `Installed ${entry.name ?? input.name ?? entry.id}.`,
+			details: { mcp: response },
 		};
 	}
 	if (entry.type === "skill") {

apps/cline-hub/src/server/mcp.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { updateMcpSettingsFileSync } from "@cline/core";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { resolveMcpSettingsPath } from "@cline/shared/storage";
 import type { JsonRecord } from "./types";
 
@@ -65,9 +65,9 @@ export function readMcpServersResponse(): JsonRecord {
 }
 
 export function writeMcpServersMap(servers: JsonRecord): void {
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		settings.mcpServers = servers;
-	});
+	const path = resolveMcpSettingsPath();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
 }
 
 export function ensureMcpSettingsFile(): string {
@@ -78,21 +78,23 @@ export function ensureMcpSettingsFile(): string {
 	return path;
 }
 
+function readServersMap(): { path: string; servers: JsonRecord } {
+	const path = ensureMcpSettingsFile();
+	const parsed = JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+	return { path, servers: (parsed.mcpServers as JsonRecord | undefined) ?? {} };
+}
+
 export function setMcpServerDisabled(
 	name: string,
 	disabled: boolean,
 ): JsonRecord {
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// (the extension, the CLI) cannot clobber this change.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		const current = servers[name];
-		if (!current || typeof current !== "object") {
-			throw new Error(`unknown MCP server: ${name}`);
-		}
-		servers[name] = { ...(current as JsonRecord), disabled };
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	const current = servers[name];
+	if (!current || typeof current !== "object") {
+		throw new Error(`unknown MCP server: ${name}`);
+	}
+	servers[name] = { ...(current as JsonRecord), disabled };
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }
 
@@ -125,27 +127,19 @@ export function upsertMcpServer(input: JsonRecord): JsonRecord {
 					},
 					disabled: input.disabled === true,
 				};
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// cannot clobber this upsert.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		if (previousName && previousName !== name) {
-			delete servers[previousName];
-		}
-		servers[name] = next;
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	if (previousName && previousName !== name) {
+		delete servers[previousName];
+	}
+	servers[name] = next;
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }
 
 export function deleteMcpServer(name: string): JsonRecord {
 	if (!name) throw new Error("server name is required");
-	// Hold the cross-process lock across read-modify-write so a concurrent writer
-	// cannot resurrect the deleted server from a stale snapshot.
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-		delete servers[name];
-		settings.mcpServers = servers;
-	});
+	const { servers } = readServersMap();
+	delete servers[name];
+	writeMcpServersMap(servers);
 	return readMcpServersResponse();
 }

apps/examples/desktop-app/sidecar/commands.ts

@@ -1,9 +1,11 @@
 import { execFileSync, spawn } from "node:child_process";
 import {
 	existsSync,
+	mkdirSync,
 	readdirSync,
 	readFileSync,
 	rmSync,
+	writeFileSync,
 } from "node:fs";
 import { basename, dirname, extname, join } from "node:path";
 import type {
@@ -43,7 +45,6 @@ import {
 	setDisabledPlugin,
 	setDisabledTools,
 	toggleDisabledTool,
-	updateMcpSettingsFileSync,
 } from "@cline/core";
 import { getClineEnvironmentConfig } from "@cline/shared";
 import { broadcastEvent, resolveSidecarAskQuestion } from "./context";
@@ -142,9 +143,9 @@ function readMcpServersResponse(): JsonRecord {
 }
 
 function writeMcpServersMap(servers: JsonRecord): void {
-	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		settings.mcpServers = servers;
-	});
+	const path = resolveMcpSettingsPath();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
 }
 
 function ensureMcpSettingsFile(): string {
@@ -1042,19 +1043,18 @@ export async function handleCommand(
 	}
 	if (command === "set_mcp_server_disabled") {
 		const path = ensureMcpSettingsFile();
-		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-			const name = String(args?.name ?? "").trim();
-			const current = servers[name];
-			if (!current || typeof current !== "object") {
-				throw new Error(`unknown MCP server: ${name}`);
-			}
-			servers[name] = {
-				...(current as JsonRecord),
-				disabled: Boolean(args?.disabled),
-			};
-			settings.mcpServers = servers;
-		});
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+		const servers = (parsed.mcpServers as JsonRecord | undefined) ?? {};
+		const name = String(args?.name ?? "").trim();
+		const current = servers[name];
+		if (!current || typeof current !== "object") {
+			throw new Error(`unknown MCP server: ${name}`);
+		}
+		servers[name] = {
+			...(current as JsonRecord),
+			disabled: Boolean(args?.disabled),
+		};
+		writeMcpServersMap(servers);
 		return readMcpServersResponse();
 	}
 	if (command === "upsert_mcp_server") {
@@ -1093,23 +1093,21 @@ export async function handleCommand(
 						metadata: input.metadata,
 					};
 		const path = ensureMcpSettingsFile();
-		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-			if (previousName && previousName !== name) {
-				delete servers[previousName];
-			}
-			servers[name] = next;
-			settings.mcpServers = servers;
-		});
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+		const servers = (parsed.mcpServers as JsonRecord | undefined) ?? {};
+		if (previousName && previousName !== name) {
+			delete servers[previousName];
+		}
+		servers[name] = next;
+		writeMcpServersMap(servers);
 		return readMcpServersResponse();
 	}
 	if (command === "delete_mcp_server") {
 		const path = ensureMcpSettingsFile();
-		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
-			delete servers[String(args?.name ?? "")];
-			settings.mcpServers = servers;
-		});
+		const parsed = JSON.parse(readFileSync(path, "utf8")) as JsonRecord;
+		const servers = (parsed.mcpServers as JsonRecord | undefined) ?? {};
+		delete servers[String(args?.name ?? "")];
+		writeMcpServersMap(servers);
 		return readMcpServersResponse();
 	}
 	if (command === "ensure_mcp_settings_file") {

apps/vscode/.mocharc.json

@@ -0,0 +1,16 @@
+{
+	"extension": [
+		"ts"
+	],
+	"spec": [
+		"src/**/__tests__/*.ts",
+		"src/test/services/**/*.test.ts"
+	],
+	"require": [
+		"ts-node/register",
+		"source-map-support/register",
+		"./src/test/requires.ts"
+	],
+	"recursive": true,
+	"exit": true
+}

apps/vscode/.nycrc.unit.json

@@ -0,0 +1,48 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": [
+		"text",
+		"lcov"
+	],
+	"include": [
+		"src/**/*.ts"
+	],
+	"exclude": [
+		"**/*.d.ts",
+
+		"**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs}",
+		"**/__tests__/**",
+		"**/test/**",
+		"**/tests/**",
+		"**/.nyc_output/**",
+		"**/.vscode-test/**",
+		"**/tests-results/**",
+		"src/test/**",
+
+		"src/generated/**",
+
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/out/**",
+		"**/build/**",
+		"**/coverage/**",
+		"**/coverage-unit/**",
+		"**/proto/**",
+
+		"**/*.{config,setup}.{js,ts,mjs,cjs}",
+		"**/vite-env.d.ts",
+
+		"**/*.{css,scss,sass,less,styl}",
+		"**/*.{svg,png,jpg,jpeg,gif,ico}",
+		"**/*.{json,yaml,yml}"
+	],
+	"extension": [
+		".ts",
+		".js"
+	],
+	"cache": true,
+	"sourceMap": true,
+	"instrument": true,
+	"report-dir": "./coverage-unit"
+}

apps/vscode/.vscode-test.mjs

@@ -1,20 +1,9 @@
 import { defineConfig } from "@vscode/test-cli"
 import path from "path"
-
 const vscodeTestVersion = process.env.VSCODE_TEST_VERSION ?? "stable"
 
 export default defineConfig({
-	files: [
-		"out/src/{core,test,utils,shared,integrations,hosts,services}/**/*.test.js",
-		"src/{core,test,utils,shared,integrations,hosts,services}/**/*.test.js",
-		// The bun unit suite (src/**/__tests__/* and src/test/services/**) runs under
-		// `bun test` (run-bun-unit-tests.ts) and imports `bun:test`, which this
-		// Node-based runner cannot load. Exclude it here.
-		"!out/src/**/__tests__/**/*.test.js",
-		"!out/src/test/services/**/*.test.js",
-		"!src/**/__tests__/**/*.test.js",
-		"!src/test/services/**/*.test.js",
-	],
+	files: "{out/**/*.test.js,src/**/*.test.js,!src/test/e2e/**/*.test.js,!out/src/test/e2e/**/*.test.js}",
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing

apps/vscode/.vscodeignore

@@ -5,31 +5,13 @@
 # Agent tooling, never shipped in the VSIX
 .agents/**
 .claude/**
-.cline/**
 .codex/**
 CLAUDE.local.md
 out/
 dist-standalone/
 node_modules/
-# Nested workspace-member node_modules (bun links these under each package).
-# Scoped to the sub-package dirs so it doesn't shadow the top-level
-# node_modules/@vscode/codicons re-include below.
-webview-ui/node_modules/**
-testing-platform/node_modules/**
-standalone/**/node_modules/**
 src/**
 standalone/**
-# Build/dev tooling and inputs — bundled into dist/extension.js, not needed in the VSIX.
-bunfig.toml
-esbuild.mjs
-knip.json
-biome.jsonc
-test-setup.js
-.env.example
-scripts/**
-proto/**
-testing-platform/**
-tests/**
 .gitignore
 .yarnrc
 esbuild.js
@@ -52,7 +34,6 @@ sdk/**
 # only exists if a publish aborts mid-swap; neither should ship in the .vsix.
 README.marketplace.md
 .README.github.bak
-package.json.backup
 
 # Custom
 **/demo.gif
@@ -65,6 +46,7 @@ eslint-rules/
 old_docs/
 evals/
 .codespellrc
+.mocharc.json
 buf.yaml
 .clinerules/
 
@@ -96,9 +78,6 @@ old_docs/**
 e2e-build.mjs
 e2e.vsix
 test-results/
-coverage/**
-webview-ui/coverage/**
-webview-ui/.vite-port
 
 # Ignore Storybook files
 **/*.stories.tsx

apps/vscode/biome.jsonc

@@ -1,11 +1,6 @@
 {
-	"root": true,
+	"root": false,
 	"$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
-	"vcs": {
-		"enabled": true,
-		"clientKind": "git",
-		"defaultBranch": "main"
-	},
 	"assist": {
 		"enabled": true,
 		"actions": {
@@ -129,18 +124,14 @@
 			"!!**/playwright",
 			"!!**/.vscode-test",
 			"!!**/test-results",
-			"!!**/coverage",
 			"!!**/node_modules",
 			"!!**/webview-ui/build",
 			"!!**/generated",
 			"!!**/proto",
-			"!!**/tests/specs",
-			"!!assets/icons/*.svg"
+			"!!**/tests/specs"
 		]
 	},
-	"plugins": [
-		"src/dev/grit/process-env.grit"
-	],
+	"plugins": ["src/dev/grit/process-env.grit"],
 	"overrides": [
 		{
 			"includes": [
@@ -155,15 +146,11 @@
 				"!!src/integrations/terminal/**",
 				"!!src/core/controller/ui/openWalkthrough.ts"
 			],
-			"plugins": [
-				"src/dev/grit/vscode-api.grit"
-			]
+			"plugins": ["src/dev/grit/vscode-api.grit"]
 		},
 		{
 			// Do not use console logging directly, use the Logger service instead.
-			"plugins": [
-				"src/dev/grit/console-log.grit"
-			],
+			"plugins": ["src/dev/grit/console-log.grit"],
 			"includes": [
 				"**",
 				"!!**/esbuild.*",
@@ -196,9 +183,7 @@
 				"!!src/core/storage/utils/state-helpers.ts",
 				"!!src/extension.ts"
 			],
-			"plugins": [
-				"src/dev/grit/use-cache-service.grit"
-			]
+			"plugins": ["src/dev/grit/use-cache-service.grit"]
 		}
 	]
 }

apps/vscode/bunfig.toml

@@ -1,7 +0,0 @@
-[test]
-# Module-substitution aliases for `bun test`. bun resolves tsconfig `paths`
-# (@/*, @core/*, @shared/*, …) and the real @cline/llms + @cline/shared dist
-# builds on its own; the preload only shadows `vscode` and `@cline/core` with
-# their unit-test stubs (mirrors vitest.config.ts resolve.alias). See
-# src/test/bun-test-preload.ts for details.
-preload = ["./src/test/bun-test-preload.ts"]

apps/vscode/esbuild.mjs

@@ -85,9 +85,50 @@ const esbuildProblemMatcherPlugin = {
 	},
 }
 
+const copyWasmFiles = {
+	name: "copy-wasm-files",
+	setup(build) {
+		build.onEnd(() => {
+			// tree sitter
+			const sourceDir = path.join(__dirname, "node_modules", "web-tree-sitter")
+			const targetDir = path.join(__dirname, destDir)
+
+			// Copy tree-sitter.wasm
+			fs.copyFileSync(path.join(sourceDir, "tree-sitter.wasm"), path.join(targetDir, "tree-sitter.wasm"))
+
+			// Copy language-specific WASM files
+			const languageWasmDir = path.join(__dirname, "node_modules", "tree-sitter-wasms", "out")
+			const languages = [
+				"typescript",
+				"tsx",
+				"python",
+				"rust",
+				"javascript",
+				"go",
+				"cpp",
+				"c",
+				"c_sharp",
+				"ruby",
+				"java",
+				"php",
+				"swift",
+				"kotlin",
+			]
+
+			languages.forEach((lang) => {
+				const filename = `tree-sitter-${lang}.wasm`
+				fs.copyFileSync(path.join(languageWasmDir, filename), path.join(targetDir, filename))
+			})
+		})
+	},
+}
+
 const buildEnvVars = {
 	"import.meta.url": "_importMetaUrl",
 	"process.env.IS_STANDALONE": JSON.stringify(standalone ? "true" : "false"),
+	// Always inline these values so ordinary builds cannot be mislabeled by a
+	// user's runtime environment. Only the combined rollout workflow sets them.
+	"process.env.CLINE_ROLLOUT_VARIANT": JSON.stringify(process.env.CLINE_ROLLOUT_VARIANT || ""),
 }
 
 if (production) {
@@ -138,6 +179,7 @@ const baseConfig = {
 	define: buildEnvVars,
 	tsconfig: path.resolve(__dirname, "tsconfig.json"),
 	plugins: [
+		copyWasmFiles,
 		aliasResolverPlugin,
 		/* add to the end of plugins array */
 		esbuildProblemMatcherPlugin,

apps/vscode/knip.json

@@ -1,34 +1,23 @@
 {
-	"$schema": "https://unpkg.com/knip@5/schema.json",
-	"workspaces": {
-		".": {
-			"entry": [
-				"src/extension.ts",
-				"src/standalone/cline-core.ts",
-				"src/generated/hosts/standalone/protobus-server-setup.ts",
-				"src/generated/hosts/standalone/host-bridge-clients.ts",
-				"src/generated/hosts/vscode/protobus-services.ts",
-				"src/generated/hosts/vscode/hostbridge-grpc-service-config.ts",
-				"src/**/*.test.ts",
-				"src/**/__tests__/**/*.ts",
-				"src/test/**/*.ts"
-			],
-			"project": [
-				"src/**/*.ts"
-			]
-		},
-		"webview-ui": {
-			"entry": [
-				"src/services/grpc-client.ts",
-				"src/**/*.test.{ts,tsx}",
-				"src/**/*.spec.{ts,tsx}",
-				"src/**/__tests__/**/*.{ts,tsx}"
-			],
-			"project": [
-				"src/**/*.{ts,tsx}",
-				"*.ts"
-			],
-			"vite": true
-		}
-	}
+	"entry": [
+		"src/extension.ts",
+		"src/standalone/cline-core.ts",
+		"src/generated/hosts/standalone/protobus-server-setup.ts",
+		"src/generated/hosts/standalone/host-bridge-clients.ts",
+		"src/generated/hosts/vscode/protobus-services.ts",
+		"src/generated/hosts/vscode/hostbridge-grpc-service-config.ts"
+	],
+	"project": [
+		"src/**/*.ts"
+	],
+	"ignore": [
+		"out/**",
+		"node_modules/**",
+		"*.d.ts",
+		"**/*.test.ts",
+		"**/__tests__",
+		"src/test/**",
+		"src/shared/**"
+	],
+	"vite": true
 }

apps/vscode/package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "4.0.0",
+	"version": "4.0.12",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -42,7 +42,8 @@
 	"activationEvents": [
 		"onLanguage",
 		"onUri",
-		"onStartupFinished"
+		"onStartupFinished",
+		"workspaceContains:evals.env"
 	],
 	"main": "./dist/extension.js",
 	"contributes": {
@@ -88,7 +89,7 @@
 					{
 						"id": "mcp",
 						"title": "Extend with Powerful Tools (MCP)",
-						"description": "Connect to databases, APIs, and other external tools through MCP.",
+						"description": "Connect to databases, APIs, or discover new capabilities in the MCP Marketplace.",
 						"media": {
 							"markdown": "walkthrough/step4.md"
 						}
@@ -137,11 +138,6 @@
 				"title": "MCP Servers",
 				"icon": "$(server)"
 			},
-			{
-				"command": "cline.marketplaceButtonClicked",
-				"title": "Customize",
-				"icon": "$(wrench)"
-			},
 			{
 				"command": "cline.historyButtonClicked",
 				"title": "History",
@@ -233,9 +229,26 @@
 				"command": "cline.reconstructTaskHistory",
 				"title": "Reconstruct Task History",
 				"category": "Cline"
+			},
+			{
+				"command": "cline.reviewComment.reply",
+				"title": "Reply",
+				"category": "Cline",
+				"enablement": "!commentIsEmpty"
+			},
+			{
+				"command": "cline.reviewComment.addToChat",
+				"title": "Add to Cline Chat",
+				"category": "Cline",
+				"icon": "$(link-external)"
 			}
 		],
 		"keybindings": [
+			{
+				"command": "editor.action.submitComment",
+				"key": "enter",
+				"when": "commentEditorFocused && commentController == cline-ai-review && !commentIsEmpty"
+			},
 			{
 				"command": "cline.addToChat",
 				"key": "cmd+'",
@@ -265,7 +278,7 @@
 					"when": "view == claude-dev.SidebarProvider"
 				},
 				{
-					"command": "cline.marketplaceButtonClicked",
+					"command": "cline.mcpButtonClicked",
 					"group": "navigation@2",
 					"when": "view == claude-dev.SidebarProvider"
 				},
@@ -337,6 +350,24 @@
 				{
 					"command": "cline.abortGitCommitMessage",
 					"when": "config.git.enabled && cline.isGeneratingCommit"
+				},
+				{
+					"command": "cline.reviewComment.reply",
+					"when": "false"
+				}
+			],
+			"comments/commentThread/context": [
+				{
+					"command": "cline.reviewComment.reply",
+					"group": "inline",
+					"when": "commentController == cline-ai-review"
+				}
+			],
+			"comments/commentThread/title": [
+				{
+					"command": "cline.reviewComment.addToChat",
+					"group": "inline",
+					"when": "commentController == cline-ai-review"
 				}
 			]
 		},
@@ -346,74 +377,66 @@
 		}
 	},
 	"scripts": {
-		"vscode:prepublish": "bun run package",
-		"compile": "bun run check-types && bun run lint && bun esbuild.mjs",
-		"compile-standalone": "bun run check-types && bun run lint && bun esbuild.mjs --standalone",
+		"vscode:prepublish": "npm run package",
+		"compile": "npm run check-types && npm run lint && node esbuild.mjs",
+		"compile-standalone": "npm run check-types && npm run lint && node esbuild.mjs --standalone",
 		"postcompile-standalone": "node scripts/package-standalone.mjs",
-		"dev": "bun run protos && bun run watch",
-		"watch": "bun run --parallel watch:esbuild watch:tsc",
-		"watch:esbuild": "bun esbuild.mjs --watch",
+		"dev": "npm run protos && npm run watch",
+		"watch": "npx npm-run-all -p watch:*",
+		"watch:esbuild": "node esbuild.mjs --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
-		"package": "bun run check-types && bun run build:webview && bun run lint && bun esbuild.mjs --production",
+		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.mjs --production",
 		"protos": "node scripts/build-proto.mjs",
 		"protos-python": "node scripts/build-python-proto.mjs",
 		"download-ripgrep": "node scripts/download-ripgrep.mjs",
-		"postprotos": "biome format --config-path ./biome.jsonc src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --no-errors-on-unmatched",
+		"postprotos": "biome format --config-path ./biome.jsonc src/shared/proto src/generated webview-ui/src/services/grpc-client.ts --write --no-errors-on-unmatched",
 		"clean:build": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"clean:deps": "rimraf node_modules webview-ui/node_modules",
-		"clean:all": "bun run clean:build && bun run clean:deps",
+		"clean:all": "npm run clean:build && npm run clean:deps",
 		"compile-tests": "node ./scripts/build-tests.js",
 		"watch-tests": "tsc -p . -w --outDir out",
-		"check-types": "bun run protos && bunx tsc --noEmit && cd webview-ui && bunx tsc --noEmit",
-		"lint": "biome lint --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error && bun run lint:proto",
+		"check-types": "npm run protos && tsc --noEmit && cd webview-ui && tsc --noEmit",
+		"lint": "biome lint --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error && npm run lint:proto",
 		"lint:proto": "bash ./scripts/proto-lint.sh",
-		"analyze:unused": "bunx --yes knip --config knip.json --include files,exports,types,enumMembers,duplicates",
-		"analyze:unused:prod": "bunx --yes knip --config knip.json --production --include files,exports,types,enumMembers,dependencies",
-		"analyze:unused:fix-exports": "node scripts/remove-unused-exports.mjs --apply",
-		"analyze:unused:fix-exports:dry": "node scripts/remove-unused-exports.mjs",
-		"format": "biome format --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error --semicolons=as-needed",
-		"format:fix": "biome check --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --write --semicolons=as-needed",
-		"fix:all": "biome check --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --write --diagnostic-level=error --unsafe --semicolons=as-needed",
-		"ci:check-all": "bun run --parallel check-types lint format",
-		"ci:build": "bun run protos && bun run build:webview && bun esbuild.mjs && bun run compile-tests",
-		"pretest": "bun run compile && bun run compile-tests && bun run compile-standalone && bun run lint",
-		"test": "bun run test:unit && bun run test:integration",
-		"test:integration": "bun run compile-tests && vscode-test",
-		"test:unit": "bun scripts/run-bun-unit-tests.ts",
-		"test:vitest": "vitest run --config vitest.config.ts",
-		"test:vitest:watch": "vitest --config vitest.config.ts",
-		"test:bun": "bun scripts/run-bun-tests.ts",
-		"test:bun:unit": "bun scripts/run-bun-unit-tests.ts",
-		"test:coverage": "bun run compile-tests && vscode-test --coverage",
-		"test:sca-server": "bun --watch scripts/test-standalone-core-api-server.ts",
-		"test:tp-orchestrator": "bun scripts/testing-platform-orchestrator.ts",
-		"dev:mcp-oauth-test-server": "bun src/dev/mcp-oauth-test-server/server.ts",
+		"format": "biome format --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --diagnostic-level=error",
+		"format:fix": "biome check --config-path ./biome.jsonc --changed --since main --no-errors-on-unmatched --files-ignore-unknown=true --write",
+		"fix:all": "biome check --config-path ./biome.jsonc --no-errors-on-unmatched --files-ignore-unknown=true --write --diagnostic-level=error --unsafe",
+		"ci:check-all": "npx npm-run-all -p check-types lint format",
+		"ci:build": "npm run protos && npm run build:webview && node esbuild.mjs && npm run compile-tests",
+		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
+		"test": "npx npm-run-all test:unit test:integration",
+		"test:integration": "vscode-test",
+		"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",
 		"e2e": "playwright test -c playwright.config.ts",
-		"test:e2e:build": "vsce package --no-dependencies --allow-package-secrets sendgrid --out dist/e2e.vsix",
-		"test:e2e": "playwright install && bun run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
-		"test:e2e:optimal": "bun run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
-		"test:e2e:ui": "bun scripts/interactive-playwright.ts",
-		"install:all": "bun install",
-		"dev:webview": "cd webview-ui && bun run dev",
-		"build:webview": "bun run protos && cd webview-ui && bun run build",
-		"test:webview": "cd webview-ui && bun run test",
+		"test:e2e:build": "vsce package --allow-package-secrets sendgrid --out dist/e2e.vsix",
+		"test:e2e": "playwright install && npm run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
+		"test:e2e:optimal": "npm run test:e2e:build && node src/test/e2e/utils/build.mjs && playwright test",
+		"test:e2e:ui": "npx tsx scripts/interactive-playwright.ts",
+		"install:all": "npm install && cd webview-ui && npm install",
+		"dev:webview": "cd webview-ui && npm run dev",
+		"build:webview": "cd webview-ui && npm run build",
+		"test:webview": "cd webview-ui && npm run test",
 		"publish:marketplace": "node scripts/publish-marketplace.mjs",
 		"publish:marketplace:prerelease": "node scripts/publish-marketplace.mjs --pre-release",
 		"publish:marketplace:nightly": "node ./scripts/publish-nightly.mjs",
-		"docs": "cd docs && bun run dev",
-		"docs:check-links": "cd docs && bun run check",
-		"docs:rename-file": "cd docs && bun run rename",
+		"prepare": "npx husky",
+		"docs": "cd docs && npm run dev",
+		"docs:check-links": "cd docs && npm run check",
+		"docs:rename-file": "cd docs && npm run rename",
 		"report-issue": "node scripts/report-issue.js",
-		"storybook": "cd webview-ui && bun run storybook",
-		"eval:smoke:run": "bun evals/smoke-tests/run-smoke-tests.ts"
+		"storybook": "cd webview-ui && npm run storybook",
+		"eval:smoke:run": "npx tsx evals/smoke-tests/run-smoke-tests.ts"
 	},
 	"lint-staged": {
 		"src/shared/storage/state-keys.ts": [
 			"node scripts/generate-state-proto.mjs",
-			"git add apps/vscode/proto/cline/state.proto"
+			"git add proto/cline/state.proto"
 		],
 		"*": [
-			"biome check --write --staged --no-errors-on-unmatched --files-ignore-unknown=true --semicolons=as-needed"
+			"biome check --write --staged --no-errors-on-unmatched --files-ignore-unknown=true"
 		]
 	},
 	"devDependencies": {
@@ -429,6 +452,7 @@
 		"@types/node": "20.x",
 		"@types/pdf-parse": "^1.1.4",
 		"@types/picomatch": "^4.0.2",
+		"@types/proxyquire": "^1.3.31",
 		"@types/shell-quote": "^1.7.5",
 		"@types/should": "^11.2.0",
 		"@types/sinon": "^21.0.0",
@@ -440,41 +464,42 @@
 		"c8": "^10.1.3",
 		"chai": "^4.3.10",
 		"chalk": "5.6.2",
+		"cross-env": "^10.1.0",
 		"dotenv": "^17.2.3",
 		"esbuild": "^0.25.0",
-		"glob": "^11.0.0",
 		"grpc-tools": "^1.13.0",
+		"husky": "^9.1.7",
 		"lint-staged": "^16.1.0",
 		"minimatch": "^3.0.3",
-		"minimist": "^1.2.8",
-		"mocha": "^11.7.4",
-		"playwright": "^1.55.1",
+		"npm-run-all": "^4.1.5",
+		"nyc": "^17.1.0",
 		"prebuild-install": "^7.1.3",
 		"protoc-gen-ts": "^0.8.7",
+		"proxyquire": "^2.1.3",
 		"rimraf": "^6.0.1",
 		"should": "^13.2.3",
 		"sinon": "^21.0.3",
-		"tar": "^7.5.2",
 		"tree-kill": "^1.2.2",
+		"ts-node": "^10.9.2",
 		"ts-proto": "^2.6.1",
 		"tsconfig-paths": "^4.2.0",
-		"typescript": "^5.4.5",
-		"vitest": "^4.0.17"
+		"typescript": "^5.4.5"
 	},
 	"dependencies": {
-		"@anthropic-ai/sdk": "^0.37.0",
+		"@anthropic-ai/sdk": "^0.50.4",
+		"@anthropic-ai/vertex-sdk": "^0.11.5",
+		"@aws-sdk/client-bedrock-runtime": "^3.922.0",
+		"@aws-sdk/credential-providers": "^3.922.0",
+		"@azure/identity": "^4.13.0",
 		"@bufbuild/protobuf": "^2.2.5",
-		"@cline/agents": "workspace:*",
-		"@cline/core": "workspace:*",
-		"@cline/llms": "workspace:*",
-		"@cline/shared": "workspace:*",
+		"@cerebras/cerebras_cloud_sdk": "^1.35.0",
+		"@google-cloud/vertexai": "^1.9.3",
 		"@google/genai": "^1.30.0",
 		"@grpc/grpc-js": "^1.9.15",
-		"@grpc/proto-loader": "^0.7.13",
 		"@grpc/reflection": "^1.0.4",
+		"@mistralai/mistralai": "^1.5.0",
 		"@modelcontextprotocol/sdk": "^1.25.1",
 		"@opentelemetry/api": "^1.9.0",
-		"@opentelemetry/api-logs": "^0.56.0",
 		"@opentelemetry/core": "^2.1.0",
 		"@opentelemetry/exporter-logs-otlp-grpc": "^0.56.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",
@@ -494,6 +519,9 @@
 		"@opentelemetry/sdk-trace-node": "^1.30.1",
 		"@opentelemetry/semantic-conventions": "^1.37.0",
 		"@playwright/test": "^1.55.1",
+		"@sap-ai-sdk/ai-api": "^2.7.0",
+		"@sap-ai-sdk/orchestration": "^2.7.0",
+		"@sap-cloud-sdk/connectivity": "^4.6.0",
 		"@streamparser/json": "^0.0.22",
 		"@tailwindcss/vite": "^4.1.14",
 		"@types/uuid": "^10.0.0",
@@ -519,15 +547,13 @@
 		"ignore": "^7.0.3",
 		"image-size": "^2.0.2",
 		"isbinaryfile": "^5.0.2",
-		"js-yaml": "^4.1.1",
 		"jschardet": "^3.1.4",
 		"json5": "^2.2.3",
-		"jwt-decode": "^4.0.0",
 		"mammoth": "^1.11.0",
 		"nanoid": "^5.1.6",
 		"nice-grpc": "^2.1.12",
-		"nice-grpc-common": "^2.0.3",
 		"node-machine-id": "^1.1.12",
+		"ollama": "^0.5.13",
 		"open": "^10.1.2",
 		"open-graph-scraper": "^6.9.0",
 		"openai": "^6.21.0",
@@ -546,13 +572,24 @@
 		"simple-git": "3.36.0",
 		"strip-ansi": "^7.1.2",
 		"tailwindcss": "^4.1.14",
+		"tree-sitter-wasms": "^0.1.11",
 		"ts-morph": "^25.0.1",
 		"turndown": "^7.2.0",
 		"ulid": "^2.4.0",
 		"undici": "^7.26.0",
 		"uuid": "^11.1.0",
 		"vscode-uri": "^3.1.0",
-		"zod": "^4.3.6"
+		"web-tree-sitter": "^0.22.6",
+		"zod": "^3.24.2"
+	},
+	"overrides": {
+		"tar-fs": ">=3.1.1",
+		"tar": "^7.5.2",
+		"vite": "^7.1.11",
+		"js-yaml": "^4.1.1",
+		"serialize-javascript": ">=7.0.3",
+		"protobufjs": "7.5.8",
+		"diff": "8.0.4"
 	},
 	"c8": {
 		"reporter": [

apps/vscode/proto/cline/checkpoints.proto

@@ -3,13 +3,17 @@ syntax = "proto3";
 package cline;
 
 import "cline/common.proto";
+import "google/protobuf/timestamp.proto";
 
 option go_package = "github.com/cline/grpc-go/cline";
 option java_multiple_files = true;
 option java_package = "bot.cline.proto";
 
 service CheckpointsService {
+  rpc checkpointDiff(Int64Request) returns (Empty);
   rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);
+  rpc subscribeToCheckpoints(CheckpointSubscriptionRequest) returns (stream CheckpointEvent);
+  rpc getCwdHash(StringArrayRequest) returns (PathHashMap);
 }
 
 message CheckpointRestoreRequest {
@@ -18,3 +22,26 @@ message CheckpointRestoreRequest {
   string restore_type = 3;
   optional int64 offset = 4;
 }
+
+message CheckpointSubscriptionRequest {
+  string cwd_hash = 1;
+}
+
+message CheckpointEvent {
+  enum OperationType {
+    CHECKPOINT_INIT = 0;
+    CHECKPOINT_COMMIT = 1;
+    CHECKPOINT_RESTORE = 2;
+  }
+
+  OperationType operation = 1;
+  string cwd_hash = 2;
+  bool is_active = 3;
+  google.protobuf.Timestamp timestamp = 4;
+  optional string task_id = 5;
+  optional string commit_hash = 6;
+}
+
+message PathHashMap {
+  map<string, string> path_hash = 1;
+}

apps/vscode/proto/cline/marketplace.proto

@@ -1,100 +0,0 @@
-syntax = "proto3";
-
-package cline;
-
-import "cline/common.proto";
-
-option go_package = "github.com/cline/grpc-go/cline";
-option java_multiple_files = true;
-option java_package = "bot.cline.proto";
-
-service MarketplaceService {
-  rpc getMarketplaceCatalog(EmptyRequest) returns (MarketplaceCatalog);
-  rpc listMarketplaceLocalInstalledEntries(EmptyRequest) returns (MarketplaceLocalInstalledEntries);
-  rpc listMarketplaceInstalledEntries(MarketplaceEntriesRequest) returns (MarketplaceInstalledEntries);
-  rpc installMarketplaceEntry(MarketplaceEntryRequest) returns (MarketplaceInstallResult);
-  rpc toggleMarketplaceLocalInstalledEntry(ToggleMarketplaceLocalInstalledEntryRequest) returns (MarketplaceLocalInstalledEntries);
-}
-
-message MarketplaceTag {
-  string label = 1;
-  optional string color = 2;
-}
-
-message MarketplaceCounts {
-  optional int32 tools = 1;
-  optional int32 prompts = 2;
-  optional int32 resources = 3;
-}
-
-message MarketplaceEnvVar {
-  string name = 1;
-  bool required = 2;
-  optional string description = 3;
-  optional string url = 4;
-}
-
-message MarketplaceInstall {
-  repeated string args = 1;
-  repeated MarketplaceEnvVar env = 2;
-  optional string command = 3;
-  optional string notes = 4;
-}
-
-message MarketplaceEntry {
-  string id = 1;
-  string type = 2;
-  string name = 3;
-  optional string tagline = 4;
-  optional string description = 5;
-  repeated string tags = 6;
-  repeated MarketplaceTag tag_objects = 7;
-  optional string author = 8;
-  optional string source_url = 9;
-  optional string homepage_url = 10;
-  optional MarketplaceCounts counts = 11;
-  optional MarketplaceInstall install = 12;
-}
-
-message MarketplaceCatalog {
-  repeated MarketplaceEntry entries = 1;
-}
-
-message MarketplaceEntriesRequest {
-  repeated MarketplaceEntry entries = 1;
-}
-
-message MarketplaceInstalledEntries {
-  repeated string installed_keys = 1;
-}
-
-message MarketplaceLocalInstalledEntry {
-  string id = 1;
-  string type = 2;
-  string name = 3;
-  optional string description = 4;
-  optional string path = 5;
-  optional string source = 6;
-  bool enabled = 7;
-}
-
-message MarketplaceLocalInstalledEntries {
-  repeated MarketplaceLocalInstalledEntry entries = 1;
-}
-
-message ToggleMarketplaceLocalInstalledEntryRequest {
-  MarketplaceLocalInstalledEntry entry = 1;
-  bool enabled = 2;
-}
-
-message MarketplaceEntryRequest {
-  MarketplaceEntry entry = 1;
-}
-
-message MarketplaceInstallResult {
-  string id = 1;
-  string type = 2;
-  string status = 3;
-  string message = 4;
-  optional string output = 5;
-}

apps/vscode/proto/cline/mcp.proto

@@ -12,11 +12,16 @@ service McpService {
   rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
   rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
   rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
+  rpc downloadMcp(StringRequest) returns (McpDownloadResponse);
   rpc restartMcpServer(StringRequest) returns (McpServers);
   rpc deleteMcpServer(StringRequest) returns (McpServers);
   rpc toggleToolAutoApprove(ToggleToolAutoApproveRequest) returns (McpServers);
+  rpc refreshMcpMarketplace(EmptyRequest) returns (McpMarketplaceCatalog);
   rpc openMcpSettings(EmptyRequest) returns (Empty);
   rpc authenticateMcpServer(StringRequest) returns (Empty);
+
+  // Subscribe to MCP marketplace catalog updates
+  rpc subscribeToMcpMarketplaceCatalog(EmptyRequest) returns (stream McpMarketplaceCatalog);
   rpc getLatestMcpServers(Empty) returns (McpServers);
 
   // Subscribe to MCP server updates
@@ -109,3 +114,40 @@ message McpServer {
 message McpServers {
   repeated McpServer mcp_servers = 1;
 }
+
+message McpMarketplaceItem {
+  string mcp_id = 1;
+  string github_url = 2;
+  string name = 3;
+  string author = 4;
+  string description = 5;
+  string codicon_icon = 6;
+  string logo_url = 7;
+  string category = 8;
+  repeated string tags = 9;
+  bool requires_api_key = 10;
+  optional string readme_content = 11;
+  optional string llms_installation_content = 12;
+  bool is_recommended = 13;
+  int32 github_stars = 14;
+  int32 download_count = 15;
+  string created_at = 16;
+  string updated_at = 17;
+  string last_github_sync = 18;
+}
+
+message McpMarketplaceCatalog {
+  repeated McpMarketplaceItem items = 1;
+}
+
+message McpDownloadResponse {
+  string mcp_id = 1;
+  string github_url = 2;
+  string name = 3;
+  string author = 4;
+  string description = 5;
+  string readme_content = 6;
+  string llms_installation_content = 7;
+  bool requires_api_key = 8;
+  optional string error = 9;
+}

apps/vscode/proto/cline/models.proto

@@ -21,6 +21,8 @@ service ModelsService {
   rpc refreshOpenRouterModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns recommended and free Cline models
   rpc refreshClineRecommendedModelsRpc(EmptyRequest) returns (ClineRecommendedModelsResponse);
+  // Refreshes and returns Cline provider models
+  rpc refreshClineModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns Hugging Face models
   rpc refreshHuggingFaceModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns OpenAI models
@@ -53,18 +55,6 @@ service ModelsService {
   rpc getAihubmixModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns Vercel AI Gateway models
   rpc refreshVercelAiGatewayModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
-  // Lists providers available from the unified SDK-backed catalog
-  rpc listProviders(Empty) returns (ProviderListingsResponse);
-  // Resolves model metadata for a provider through the unified SDK-backed catalog
-  rpc resolveProviderModels(ResolveProviderModelsRequest) returns (ProviderModelsResponse);
-  // Resolves model metadata for a provider/model without refreshing model lists
-  rpc resolveModelInfo(ResolveModelInfoRequest) returns (ResolveModelInfoResponse);
-  // Reads redacted effective provider configuration
-  rpc readProviderConfig(StringRequest) returns (ProviderConfigResponse);
-  // Writes provider configuration fields and returns redacted effective configuration
-  rpc writeProviderConfig(WriteProviderConfigRequest) returns (ProviderConfigResponse);
-  // Commits a mode-specific model selection atomically with its model metadata
-  rpc commitModelSelection(CommitModelSelectionRequest) returns (Empty);
 }
 
 // List of VS Code LM models
@@ -127,142 +117,6 @@ message OpenRouterCompatibleModelInfo {
   map<string, OpenRouterModelInfo> models = 1;
 }
 
-// Lightweight provider entry for the top-level model/provider picker.
-// Does not include the full model list; use resolveProviderModels for models.
-message ProviderListing {
-  string id = 1;
-  string name = 2;
-  optional string default_model_id = 3;
-  optional string family = 4;
-  optional string protocol = 5;
-  optional string auth_description = 6;
-  optional string base_url_description = 7;
-  bool allows_custom_model_ids = 8;
-
-  // SDK-driven hint for cost display. Values: "show" (default) or "hide".
-  // Sourced from `resolveProviderUsageCostDisplay(provider.metadata)` in
-  // `@cline/llms`. When "hide", consumers must suppress per-token pricing
-  // and total cost displays (matches the CLI's `shouldShowCliUsageCost`).
-  string usage_cost_display = 11;
-}
-
-message ProviderListingsResponse {
-  repeated ProviderListing providers = 1;
-}
-
-message ResolveProviderModelsRequest {
-  string provider_id = 1;
-  bool force_refresh = 2;
-  optional string request_id = 3;
-}
-
-message CatalogErrorInfo {
-  string kind = 1;
-  string message = 2;
-  optional string code = 3;
-  optional bool retryable = 4;
-}
-
-message ProviderModelsResponse {
-  string provider_id = 1;
-  string request_id = 2;
-  string config_fingerprint = 3;
-  int64 fetched_at = 4;
-  bool ok = 5;
-  map<string, OpenRouterModelInfo> models = 6;
-  optional string default_model_id = 7;
-  optional string source = 8;
-  optional CatalogErrorInfo error = 9;
-}
-
-message ResolveModelInfoRequest {
-  string provider_id = 1;
-  optional string model_id = 2;
-}
-
-message ResolveModelInfoResponse {
-  string provider_id = 1;
-  string model_id = 2;
-  optional OpenRouterModelInfo model_info = 3;
-  string source = 4;
-}
-
-message AwsProviderConfig {
-  optional string authentication = 1;
-  optional string profile = 2;
-  optional string access_key = 3;
-  int64 access_key_length = 4;
-  optional string secret_key = 5;
-  int64 secret_key_length = 6;
-  optional string session_token = 7;
-  int64 session_token_length = 8;
-  optional string endpoint = 9;
-  optional bool use_prompt_cache = 10;
-  optional string custom_model_base_id = 11;
-  optional bool use_cross_region_inference = 12;
-  optional bool use_global_inference = 13;
-}
-
-message GcpProviderConfig {
-  optional string project_id = 1;
-  optional string region = 2;
-}
-
-message ProviderConfigResponse {
-  string provider_id = 1;
-  optional string base_url = 2;
-  optional string api_line = 3;
-  map<string, string> headers = 4;
-  optional string region = 5;
-  int64 api_key_length = 6;
-  bool has_access_token = 7;
-  bool has_refresh_token = 8;
-  optional string account_id = 9;
-  optional CommittedModelSelection plan_selection = 10;
-  optional CommittedModelSelection act_selection = 11;
-  optional AwsProviderConfig aws = 12;
-  optional GcpProviderConfig gcp = 13;
-}
-
-message CommittedModelSelection {
-  string provider_id = 1;
-  string model_id = 2;
-  OpenRouterModelInfo model_info = 3;
-}
-
-message ProviderReasoningPatch {
-  optional bool enabled = 1;
-  optional string effort = 2; // "none" | "low" | "medium" | "high" | "xhigh"
-  optional int32 budget_tokens = 3;
-}
-
-message WriteProviderConfigPatch {
-  optional string api_key = 1;
-  optional string base_url = 2;
-  map<string, string> headers = 3;
-  optional string region = 4;
-  optional string api_line = 5;
-  optional string access_token = 6;
-  optional string refresh_token = 7;
-  optional string account_id = 8;
-  optional ProviderReasoningPatch reasoning = 9;
-  optional bool clear_headers = 10;
-  optional AwsProviderConfig aws = 11;
-  optional GcpProviderConfig gcp = 12;
-}
-
-message WriteProviderConfigRequest {
-  string provider_id = 1;
-  WriteProviderConfigPatch patch = 2;
-}
-
-message CommitModelSelectionRequest {
-  string provider_id = 1;
-  string mode = 2;
-  string model_id = 3;
-  OpenRouterModelInfo model_info = 4;
-}
-
 message ClineRecommendedModel {
   string id = 1;
   string name = 2;
@@ -477,6 +331,10 @@ message ModelsApiOptions {
   optional OpenRouterModelInfo act_mode_cline_model_info = 236;
   optional string act_mode_cline_pass_model_id = 237;
   optional OpenRouterModelInfo act_mode_cline_pass_model_info = 238;
+  optional bool plan_mode_vertex_custom_model_selected = 239;
+  optional OpenRouterModelInfo plan_mode_vertex_custom_model_info = 240;
+  optional bool act_mode_vertex_custom_model_selected = 241;
+  optional OpenRouterModelInfo act_mode_vertex_custom_model_info = 242;
 }
 
 // Request for updating API configuration (legacy - uses combined configuration)
@@ -613,12 +471,6 @@ enum ApiProvider {
   OPENAI_CODEX = 40;
   WANDB = 41;
   CLINE_PASS = 42;
-  POOLSIDE = 45;
-  V0 = 46;
-  XIAOMI = 47;
-  ZAI_CODING_PLAN = 49;
-  reserved 43, 44, 48;
-  reserved "OPENAI_CODEX_CLI", "OPENCODE", "KILO";
 }
 
 enum ApiFormat {
@@ -850,4 +702,8 @@ message ModelsApiConfiguration {
   optional OpenRouterModelInfo act_mode_cline_model_info = 241;
   optional string act_mode_cline_pass_model_id = 242;
   optional OpenRouterModelInfo act_mode_cline_pass_model_info = 243;
+  optional bool plan_mode_vertex_custom_model_selected = 244;
+  optional OpenRouterModelInfo plan_mode_vertex_custom_model_info = 245;
+  optional bool act_mode_vertex_custom_model_selected = 246;
+  optional OpenRouterModelInfo act_mode_vertex_custom_model_info = 247;
 }

apps/vscode/proto/cline/remote_config.proto

@@ -1,32 +0,0 @@
-syntax = "proto3";
-
-package cline;
-
-import "cline/common.proto";
-
-option go_package = "github.com/cline/grpc-go/cline";
-option java_multiple_files = true;
-option java_package = "bot.cline.proto";
-
-enum RemoteConfigType {
-  RULE = 0;
-  WORKFLOW = 1;
-  SKILL = 2;
-}
-
-message RemoteConfigSetting {
-  RemoteConfigType type = 1;
-  string name = 2;
-  string content = 3;
-  bool enabled = 4;
-  bool locked = 5;
-}
-
-message RemoteConfigSettingsResponse {
-  repeated RemoteConfigSetting settings = 1;
-}
-
-service RemoteConfigService {
-  rpc getRemoteConfigSettings(Empty) returns (RemoteConfigSettingsResponse);
-  rpc toggleRemoteConfigSetting(StringRequest) returns (RemoteConfigSetting);
-}

apps/vscode/proto/cline/slash.proto

@@ -23,7 +23,7 @@ message SlashCommandInfo {
   string name = 1; // Command name without slash, e.g., "newtask", "smol"
   string description = 2; // Human-readable description
   string section = 3; // "default", "custom", or "cli"
-  bool cli_compatible = 4; // false for VS Code-only commands
+  bool cli_compatible = 4; // false for VS Code-only commands like explain-changes
 }
 
 // Response containing all available slash commands

apps/vscode/proto/cline/state.proto

@@ -112,9 +112,6 @@ message Secrets {
 // in src/shared/storage/state-keys.ts and use the scripts/generate-state-proto.mjs
 // script to regenerate this list.
 message Settings {
-  reserved 144, 154, 176;
-  reserved "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";
-
   optional string lite_llm_base_url = 1;
   optional bool lite_llm_use_prompt_cache = 2;
   optional string anthropic_base_url = 4;
@@ -251,15 +248,19 @@ message Settings {
   optional bool enable_checkpoints_setting = 135;
   optional int32 shell_integration_timeout = 136;
   optional string default_terminal_profile = 137;
+  optional int32 terminal_output_line_limit = 138;
   optional int32 max_consecutive_mistakes = 139;
+  optional bool strict_plan_mode_enabled = 141;
   optional bool yolo_mode_toggled = 142;
   optional bool use_auto_condense = 143;
+  optional bool cline_web_tools_enabled = 144;
   optional string preferred_language = 145;
   optional PlanActMode mode = 147;
   optional FocusChainSettings focus_chain_settings = 149;
   optional string custom_prompt = 150;
   optional bool hooks_enabled = 152;
   optional bool subagents_enabled = 153;
+  optional bool enable_parallel_tool_calling = 154;
   optional bool background_edit_enabled = 155;
   optional bool opt_out_of_remote_config = 157;
   optional bool open_telemetry_enabled = 158;
@@ -278,12 +279,18 @@ message Settings {
   optional int32 open_telemetry_log_max_queue_size = 171;
   optional bool worktrees_enabled = 172;
   optional bool auto_approve_all_toggled = 174;
+  optional bool double_check_completion_enabled = 176;
   map<string, string> open_ai_headers = 177;
   optional string plan_mode_cline_model_id = 178;
   optional OpenRouterModelInfo plan_mode_cline_model_info = 179;
   optional string act_mode_cline_model_id = 180;
   optional OpenRouterModelInfo act_mode_cline_model_info = 181;
   optional bool show_feature_tips = 182;
+  optional bool lazy_teammate_mode_enabled = 183;
+  optional bool plan_mode_vertex_custom_model_selected = 184;
+  optional OpenRouterModelInfo plan_mode_vertex_custom_model_info = 185;
+  optional bool act_mode_vertex_custom_model_selected = 186;
+  optional OpenRouterModelInfo act_mode_vertex_custom_model_info = 187;
 }
 
 message State {
@@ -387,11 +394,7 @@ message UpdateTaskSettingsRequest {
 message UpdateSettingsRequest {
   reserved 15; // was openai_reasoning_effort (moved to mode-scoped reasoning effort)
   reserved 23; // was dictation_settings (dictation removed)
-  reserved 32, 34, 35, 41;
   reserved 38; // was skills_enabled (removed - now always enabled)
-  reserved 43; // was lazy_teammate_mode_enabled (removed)
-  reserved 12; // was terminal_output_line_limit (removed; SDK command output limits are character-based)
-  reserved "native_tool_call_enabled", "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";
 
   Metadata metadata = 1;
   optional ModelsApiConfiguration api_configuration = 2;
@@ -403,9 +406,10 @@ message UpdateSettingsRequest {
   optional bool terminal_reuse_enabled = 9;
   optional bool mcp_responses_collapsed = 10;
   optional McpDisplayMode mcp_display_mode = 11;
+  optional int32 terminal_output_line_limit = 12;
   optional PlanActMode mode = 13;
   optional string preferred_language = 14;
-  reserved 16; // was strict_plan_mode_enabled (removed)
+  optional bool strict_plan_mode_enabled = 16;
   optional FocusChainSettings focus_chain_settings = 17;
   optional bool use_auto_condense = 18;
   optional string custom_prompt = 19;
@@ -419,12 +423,17 @@ message UpdateSettingsRequest {
   optional bool subagents_enabled = 29;
   optional int32 subagent_terminal_output_line_limit = 30;
   optional string cline_env = 31;
+  optional bool native_tool_call_enabled = 32;
   optional OnboardingModelGroup onboarding_models = 33;
+  optional bool cline_web_tools_enabled = 34;
+  optional bool enable_parallel_tool_calling = 35;
   optional bool background_edit_enabled = 36;
   optional string oca_reasoning_effort = 37;
   optional bool opt_out_of_remote_config = 39;
   optional bool worktrees_enabled = 40;
+  optional bool double_check_completion_enabled = 41;
   optional bool show_feature_tips = 42;
+  optional bool lazy_teammate_mode_enabled = 43;
 }
 
 message UpdateTerminalConnectionTimeoutRequest {
@@ -451,11 +460,6 @@ message OnboardingProgressRequest {
   optional string action = 2;
   optional bool completed = 3;
   optional string model_selected = 4;
-  optional string page = 5;
-  optional string page_variant = 6;
-  optional string user_type = 7;
-  optional int32 destination_step = 8;
-  optional string destination_page = 9;
 }
 
 message OnboardingModelGroup {

apps/vscode/proto/cline/task.proto

@@ -32,14 +32,16 @@ service TaskService {
   rpc getTaskHistory(GetTaskHistoryRequest) returns (TaskHistoryArray);
   // Sends a response to a previous ask operation
   rpc askResponse(AskResponseRequest) returns (Empty);
-  // Edits a previous user message, truncates following conversation, and regenerates
-  rpc editMessageAndRegenerate(EditMessageAndRegenerateRequest) returns (Empty);
   // Records task feedback (thumbs up/down)
   rpc taskFeedback(StringRequest) returns (Empty);
+  // Shows task completion changes diff in a view
+  rpc taskCompletionViewChanges(Int64Request) returns (Empty);
   // Executes a quick win task with command and title
   rpc executeQuickWin(ExecuteQuickWinRequest) returns (Empty);
   // Deletes all task history
   rpc deleteAllTaskHistory(EmptyRequest) returns (DeleteAllTaskHistoryCount);
+  // Explains changes with AI and adds inline comments to the diff view
+  rpc explainChanges(ExplainChangesRequest) returns (Empty);
 }
 
 // Request message for creating a new task
@@ -80,14 +82,12 @@ message GetTaskHistoryRequest {
   string search_query = 3;
   string sort_by = 4;
   bool current_workspace_only = 5;
-  int32 limit = 6;
-  int32 offset = 7;
 }
 
 // Response for task history
 message TaskHistoryArray {
   repeated TaskItem tasks = 1;
-  bool has_more = 2;
+  int32 total_count = 2;
 }
 
 // Task item details for history list
@@ -114,16 +114,6 @@ message AskResponseRequest {
   repeated string files = 5;
 }
 
-// Request for editing a past user message and regenerating the conversation after it
-message EditMessageAndRegenerateRequest {
-  Metadata metadata = 1;
-  int64 message_ts = 2;
-  string text = 3;
-  repeated string images = 4;
-  repeated string files = 5;
-  bool restore_workspace = 6;
-}
-
 // Request for executing a quick win task
 message ExecuteQuickWinRequest {
   Metadata metadata = 1;
@@ -135,3 +125,10 @@ message ExecuteQuickWinRequest {
 message DeleteAllTaskHistoryCount {
   int32 tasks_deleted = 1;
 }
+
+// Request for explaining changes with AI
+message ExplainChangesRequest {
+  Metadata metadata = 1;
+  // Timestamp of the completion message to explain changes for
+  int64 message_ts = 2;
+}

apps/vscode/proto/cline/ui.proto

@@ -67,6 +67,7 @@ enum ClineSay {
   INFO = 26;
   TASK_PROGRESS = 27;
   ERROR_RETRY = 28;
+  GENERATE_EXPLANATION = 29;
   HOOK_STATUS = 30;
   HOOK_OUTPUT_STREAM = 31;
   COMMAND_PERMISSION_DENIED = 32;
@@ -225,12 +226,6 @@ message ClineMessage {
   ClineAskNewTask ask_new_task = 21;
   ClineApiReqInfo api_req_info = 22;
   ClineModelInfo model_info = 23;
-
-  // Convergent-replica fields (see webview-message-state-design.md):
-  // seq = monotonic freshness (higher seq wins for the same ts/identity)
-  // epoch = conversation/replica fence (older epoch is dropped by the webview)
-  int64 seq = 24;
-  int64 epoch = 25;
 }
 
 message ShowWebviewEvent {
@@ -254,9 +249,6 @@ service UiService {
   // Subscribe to MCP button clicked events
   rpc subscribeToMcpButtonClicked(EmptyRequest) returns (stream Empty);
 
-  // Subscribe to customize button clicked events
-  rpc subscribeToMarketplaceButtonClicked(EmptyRequest) returns (stream Empty);
-
   // Subscribe to history button click events
   rpc subscribeToHistoryButtonClicked(EmptyRequest) returns (stream Empty);
 

apps/vscode/scripts/build-proto.mjs

@@ -34,26 +34,9 @@ const GRPC_JS_OUT_DIR = path.resolve("src/generated/grpc-js")
 const NICE_JS_OUT_DIR = path.resolve("src/generated/nice-grpc")
 const DESCRIPTOR_OUT_DIR = path.resolve("dist-standalone/proto")
 
-// protoc invokes the ts-proto plugin as a child process, so it needs a path it can
-// directly execute. On POSIX the package's JS bin (with its shebang) works. On
-// Windows protoc cannot exec a bare .js or bun's `.bunx` shim ("%1 is not a valid
-// Win32 application"), and the package manager's `.cmd` shim location/name varies
-// (npm vs bun's hoisted store). To be package-manager-agnostic, generate a tiny
-// .cmd wrapper that runs the resolved plugin JS via `node`.
-function resolveTsProtoPlugin() {
-	const pluginJs = require.resolve("ts-proto/protoc-gen-ts_proto")
-	if (!isWindows) {
-		return pluginJs
-	}
-	const wrapperDir = path.resolve("dist-standalone")
-	fsSync.mkdirSync(wrapperDir, { recursive: true })
-	const wrapperPath = path.join(wrapperDir, "protoc-gen-ts_proto.cmd")
-	// %* forwards protoc's plugin args/stdio to the JS entry run under node.
-	fsSync.writeFileSync(wrapperPath, `@echo off\r\nnode "${pluginJs}" %*\r\n`)
-	return wrapperPath
-}
-
-const TS_PROTO_PLUGIN = resolveTsProtoPlugin()
+const TS_PROTO_PLUGIN = isWindows
+	? path.resolve("node_modules/.bin/protoc-gen-ts_proto.cmd") // Use the .bin directory path for Windows
+	: require.resolve("ts-proto/protoc-gen-ts_proto")
 
 const TS_PROTO_OPTIONS = [
 	"env=both",

apps/vscode/scripts/build-tests.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 const { execSync } = require("child_process")
-const fs = require("fs")
-const path = require("path")
 const esbuild = require("esbuild")
 
 const watch = process.argv.includes("--watch")
@@ -55,43 +53,7 @@ async function main() {
 	}
 }
 
-// tsc does not delete output for source/tests that were removed or are no longer
-// part of tsconfig.test.json. The VS Code test runner globs out/src/**/*.test.js,
-// so stale compiled tests can still run unless we clear the test build output first.
-fs.rmSync(path.join(__dirname, "..", "out", "src"), { recursive: true, force: true })
-fs.rmSync(path.join(__dirname, "..", "out", "packages"), { recursive: true, force: true })
-
-// Single source of truth for the bun-vs-integration test split: any *.test.ts that
-// imports from "bun:test" is owned by the bun runner (scripts/run-bun-unit-tests.ts)
-// and must NOT be compiled into the Node-based @vscode/test-cli `out/` tree (Node
-// cannot load the `bun:test` builtin, and these files use bun-only APIs like
-// `mock.module` / 3-arg `it`). Generate a tsconfig that excludes them so the
-// integration compile only ever sees mocha-owned tests.
-const projectRoot = path.join(__dirname, "..")
-const bunTestImport = /from\s+["']bun:test["']/
-function collectBunTestFiles(dir, acc) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		if (entry.name === "node_modules") continue
-		const full = path.join(dir, entry.name)
-		if (entry.isDirectory()) {
-			collectBunTestFiles(full, acc)
-		} else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
-			if (bunTestImport.test(fs.readFileSync(full, "utf-8"))) {
-				acc.push(path.relative(projectRoot, full).split(path.sep).join("/"))
-			}
-		}
-	}
-	return acc
-}
-const bunOwnedTests = collectBunTestFiles(path.join(projectRoot, "src"), [])
-// tsconfig.test.json is JSONC (contains comments); parse with json5 (a project dep).
-const JSON5 = require("json5")
-const baseTestConfig = JSON5.parse(fs.readFileSync(path.join(projectRoot, "tsconfig.test.json"), "utf-8"))
-baseTestConfig.exclude = [...(baseTestConfig.exclude ?? []), ...bunOwnedTests]
-const generatedConfigPath = path.join(projectRoot, "tsconfig.test.generated.json")
-fs.writeFileSync(generatedConfigPath, JSON.stringify(baseTestConfig, null, "\t"))
-
-execSync(`tsc -p ${JSON.stringify(generatedConfigPath)} --outDir out`, { encoding: "utf-8" })
+execSync("tsc -p ./tsconfig.test.json --outDir out", { encoding: "utf-8" })
 
 main().catch((e) => {
 	console.error(e)

apps/vscode/scripts/find-dead-src.mjs

@@ -1,129 +0,0 @@
-// Dead-source finder: uses esbuild's own bundle reachability (the same analysis
-// that drives tree-shaking + minification mangling) to compute which src/ files
-// are reachable from BOTH shipped entry points:
-//   - src/extension.ts            (VS Code extension host)
-//   - src/standalone/cline-core.ts (standalone host used by JetBrains + CLI)
-//
-// A src/*.ts file that is NOT in the union of metafile inputs for those two
-// builds is unreachable from any shipped entry => dead (modulo dynamic import()
-// of computed specifiers, which esbuild surfaces separately).
-//
-// Run: node scripts/find-dead-src.mjs
-
-import fs from "node:fs"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-import * as esbuild from "esbuild"
-import { glob } from "glob"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const root = path.resolve(__dirname, "..")
-
-const aliases = {
-	"@": path.join(root, "src"),
-	"@core": path.join(root, "src/core"),
-	"@integrations": path.join(root, "src/integrations"),
-	"@services": path.join(root, "src/services"),
-	"@shared": path.join(root, "src/shared"),
-	"@utils": path.join(root, "src/utils"),
-	"@packages": path.join(root, "src/packages"),
-}
-
-const aliasResolverPlugin = {
-	name: "alias-resolver",
-	setup(build) {
-		for (const [alias, aliasPath] of Object.entries(aliases)) {
-			const aliasRegex = new RegExp(`^${alias}($|/.*)`)
-			build.onResolve({ filter: aliasRegex }, (args) => {
-				const importPath = args.path.replace(alias, aliasPath)
-				const exts = [".ts", ".tsx", ".js", ".jsx"]
-				if (fs.existsSync(importPath)) {
-					const stats = fs.statSync(importPath)
-					if (stats.isDirectory()) {
-						for (const ext of exts) {
-							const idx = path.join(importPath, `index${ext}`)
-							if (fs.existsSync(idx)) return { path: idx }
-						}
-					} else {
-						return { path: importPath }
-					}
-				}
-				for (const ext of exts) {
-					if (fs.existsSync(`${importPath}${ext}`)) return { path: `${importPath}${ext}` }
-				}
-				return undefined
-			})
-		}
-	},
-}
-
-const common = {
-	bundle: true,
-	minify: false,
-	sourcemap: false,
-	logLevel: "silent",
-	format: "cjs",
-	platform: "node",
-	metafile: true,
-	write: false,
-	absWorkingDir: root,
-	tsconfig: path.join(root, "tsconfig.json"),
-	packages: "external",
-	plugins: [aliasResolverPlugin],
-	define: { "process.env.IS_DEV": "false", "process.env.IS_TEST": "false" },
-	banner: { js: "const _importMetaUrl=require('url').pathToFileURL(__filename)" },
-}
-
-async function inputsFor(entry, external) {
-	const r = await esbuild.build({ ...common, entryPoints: [entry], external })
-	return new Set(Object.keys(r.metafile.inputs).filter((f) => f.startsWith("src/") && /\.tsx?$/.test(f)))
-}
-
-const ext = await inputsFor("src/extension.ts", ["vscode"])
-const standalone = await inputsFor("src/standalone/cline-core.ts", [
-	"vscode",
-	"@grpc/reflection",
-	"grpc-health-check",
-	"better-sqlite3",
-])
-const live = new Set([...ext, ...standalone])
-
-// Third consumer: the webview (webview-ui/) is a separate Vite/React build that
-// imports extension code ONLY from src/shared (via "@shared/*" alias or relative
-// "../src/shared/*" paths). Any src/shared file referenced from webview-ui/src is
-// therefore live even if the extension-host/standalone bundles don't reach it.
-// Conservatively mark every src/shared file mentioned by the webview as live.
-const webviewFiles = await glob("webview-ui/src/**/*.{ts,tsx}", { cwd: root })
-const sharedMentionedByWebview = new Set()
-for (const wf of webviewFiles) {
-	const text = fs.readFileSync(path.join(root, wf), "utf8")
-	// Match @shared/X or .../src/shared/X import specifiers and map to src/shared/X
-	const re = /(?:@shared\/|src\/shared\/)([A-Za-z0-9_./-]+)/g
-	let m
-	while ((m = re.exec(text))) {
-		const rel = m[1].replace(/\.(ts|tsx|js|jsx)$/, "")
-		for (const cand of [`src/shared/${rel}.ts`, `src/shared/${rel}.tsx`, `src/shared/${rel}/index.ts`]) {
-			if (fs.existsSync(path.join(root, cand))) sharedMentionedByWebview.add(cand)
-		}
-	}
-}
-for (const f of sharedMentionedByWebview) live.add(f)
-console.log(`src/shared files referenced by webview: ${sharedMentionedByWebview.size}`)
-
-// All non-test, non-.d.ts source files on disk.
-const allSrc = (await glob("src/**/*.{ts,tsx}", { cwd: root }))
-	.filter((f) => !/\.test\.tsx?$/.test(f))
-	.filter((f) => !f.endsWith(".d.ts"))
-	.filter((f) => !f.includes("/__tests__/"))
-	.filter((f) => !f.startsWith("src/test/"))
-	.filter((f) => !f.startsWith("src/generated/")) // generated host glue
-	.filter((f) => !f.startsWith("src/dev/")) // dev-only tooling
-
-const dead = allSrc.filter((f) => !live.has(f)).sort()
-
-console.log(`extension inputs: ${ext.size}`)
-console.log(`standalone inputs: ${standalone.size}`)
-console.log(`union live src files: ${live.size}`)
-console.log(`candidate dead files: ${dead.length}`)
-fs.writeFileSync("/tmp/dead-src.json", JSON.stringify(dead, null, "\t"))
-console.log("--- dead candidates written to /tmp/dead-src.json ---")

apps/vscode/scripts/generate-state-proto.mjs

@@ -453,7 +453,7 @@ async function main() {
 	await fs.writeFile(STATE_PROTO_PATH, protoContent)
 	console.log(`Updated ${STATE_PROTO_PATH}`)
 
-	console.log("\nGeneration complete! Run 'bun run protos' to regenerate TypeScript from protos.")
+	console.log("\nGeneration complete! Run 'npm run protos' to regenerate TypeScript from protos.")
 }
 
 main().catch((error) => {

apps/vscode/scripts/interactive-playwright.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env npx tsx
 
 /**
  * Interactive Playwright launcher for the Cline VS Code extension.
@@ -15,10 +15,10 @@
  *
  * Usage:
  *   1. (Optional) Build and install the e2e extension:
- *        bun run test:e2e:build
+ *        npm run test:e2e:build
  *
  *   2. From the repo root, start the interactive session:
- *        bun run test:e2e:ui
+ *        npm run test:e2e:ui
  *
  *   3. VS Code will launch with the Cline extension loaded and gRPC recording enabled.
  *

apps/vscode/scripts/package-standalone.mjs

@@ -47,13 +47,8 @@ async function installNodeDependencies() {
 
 	await cpr(RUNTIME_DEPS_DIR, BUILD_DIR)
 
-	// This is an ISOLATED runtime install inside the standalone distribution
-	// directory (dist-standalone), driven by the "cline-core" runtime-files
-	// manifest — it is NOT part of the monorepo workspace install. TARGET_NODE_VERSION
-	// and the prebuild-install calls below target the Node ABI of the bundled
-	// runtime (matching the JetBrains-packaged Node), not the build tooling.
-	console.log("Running bun install in distribution directory...")
-	execSync("bun install", { stdio: "inherit", cwd: BUILD_DIR })
+	console.log("Running npm install in distribution directory...")
+	execSync("npm install", { stdio: "inherit", cwd: BUILD_DIR })
 
 	// Move the vscode directory into node_modules.
 	// It can't be installed using npm because it will create a symlink which cannot be unzipped correctly on windows.
@@ -97,10 +92,7 @@ async function packageAllBinaryDeps() {
 			const dest = path.join(binaryDir, module)
 			await cpr(src, dest)
 
-			// Download the binary libs.
-			// `--target=${TARGET_NODE_VERSION}` selects the Node ABI of the bundled
-			// standalone runtime (NOT the bun/build tooling) so the prebuilt native
-			// `.node` binaries load in the Node that runs cline-core.
+			// Download the binary libs
 			const v = IS_VERBOSE ? "--verbose" : ""
 			const cmd = `npx prebuild-install --platform=${platform} --arch=${arch} --target=${TARGET_NODE_VERSION} ${v}`
 			log_verbose(`${module}: ${cmd}`)

apps/vscode/scripts/publish-marketplace.mjs

@@ -37,16 +37,13 @@ process.on("SIGINT", cleanupOnSignal(130))
 process.on("SIGTERM", cleanupOnSignal(143))
 
 try {
-	// --no-dependencies: the extension is fully esbuild-bundled into dist/extension.js,
-	// so vsce must not walk node_modules (the @cline/* workspace symlinks point out of
-	// the package and would drag the whole monorepo into the VSIX).
-	const vsceArgs = ["publish", "--no-dependencies", "--allow-package-secrets", "sendgrid"]
+	const vsceArgs = ["publish", "--allow-package-secrets", "sendgrid"]
 	if (isPrerelease) {
 		vsceArgs.push("--pre-release")
 	}
 	execFileSync("vsce", vsceArgs, { stdio: "inherit" })
 
-	const ovsxArgs = ["ovsx", "publish", "--no-dependencies"]
+	const ovsxArgs = ["ovsx", "publish"]
 	if (isPrerelease) {
 		ovsxArgs.push("--pre-release")
 	}

apps/vscode/scripts/publish-nightly.mjs

@@ -35,9 +35,9 @@
  *   least as often as the scheduled release nightly runs.
  *
  * Usage:
- *   bun run publish:marketplace:nightly                    # release channel
- *   bun run publish:marketplace:nightly -- --pre-release   # pre-release channel
- *   bun run publish:marketplace:nightly -- --dry-run       # package only
+ *   npm run publish:marketplace:nightly                    # release channel
+ *   npm run publish:marketplace:nightly -- --pre-release   # pre-release channel
+ *   npm run publish:marketplace:nightly -- --dry-run       # package only
  *
  * Environment variables:
  *   VSCE_PAT  - Personal Access Token for VS Code Marketplace
@@ -388,9 +388,6 @@ class NightlyPublisher {
 		const args = [
 			"package",
 			...(isPreRelease ? ["--pre-release"] : []),
-			// The extension is fully esbuild-bundled, so vsce must not walk node_modules
-			// (the @cline/* workspace symlinks point outside the package).
-			"--no-dependencies",
 			"--no-update-package-json",
 			"--no-git-tag-version",
 			"--allow-package-secrets",
@@ -582,7 +579,7 @@ if (showHelp) {
 Nightly publish script for VS Code extension
 
 Usage:
-  bun run publish:marketplace:nightly [options]
+  npm run publish:marketplace:nightly [options]
 
 Options:
   --pre-release    Publish to the pre-release channel of cline-nightly.
@@ -596,10 +593,10 @@ Environment variables:
   OVSX_PAT         Personal Access Token for OpenVSX Registry
 
 Examples:
-  bun run publish:marketplace:nightly                      # Release channel publish
-  bun run publish:marketplace:nightly -- --pre-release     # Pre-release channel publish
-  bun run publish:marketplace:nightly -- --dry-run         # Package only
-  VSCE_PAT="token" bun run publish:marketplace:nightly     # Publish to VS Code only
+  npm run publish:marketplace:nightly                      # Release channel publish
+  npm run publish:marketplace:nightly -- --pre-release     # Pre-release channel publish
+  npm run publish:marketplace:nightly -- --dry-run         # Package only
+  VSCE_PAT="token" npm run publish:marketplace:nightly     # Publish to VS Code only
 `)
 	process.exit(0)
 }

apps/vscode/scripts/run-bun-tests.ts

@@ -1,80 +0,0 @@
-#!/usr/bin/env bun
-
-import { spawn } from "node:child_process"
-import path from "node:path"
-/**
- * Runner for the SDK-adapter + model-catalog `bun test` suites (the same set
- * `vitest.config.ts` covers; `test:vitest` runs them under vitest).
- *
- * Why a script instead of a bare `bun test <globs>`:
- *
- *  1. Curated include set. These suites are an explicit list (see
- *     INCLUDE_PATTERNS, kept in sync with `vitest.config.ts` `test.include`),
- *     not the whole tree, so the node-side unit and @vscode/test-cli suites are
- *     not pulled in. `bun test`'s positional args don't expand `**` the way we
- *     need, so we resolve the globs ourselves with bun's `Glob`.
- *
- *  2. One process per file. `bun test` runs all files in a single process by
- *     default, so `mock.module(...)` registrations leak between files — suites
- *     mocking the same specifier with different shapes (e.g.
- *     `@/core/storage/StateManager`, `@cline/core`) clobber each other.
- *     `--parallel` runs each file in its own worker process, giving each a fresh
- *     module registry.
- *
- * Usage:
- *   bun scripts/run-bun-tests.ts            # run the curated set, isolated
- *   bun scripts/run-bun-tests.ts --list     # print the resolved file list only
- */
-import { Glob } from "bun"
-
-// Mirror of vitest.config.ts `test.include`. Keep these in sync.
-const INCLUDE_PATTERNS = [
-	"src/sdk/**/*.test.ts",
-	"src/shared/vsCodeSelectorUtils.test.ts",
-	"src/core/storage/remote-config/**/*.test.ts",
-	"src/shared/model-catalog/provider-helpers.test.ts",
-	"src/core/controller/models/__tests__/providerCatalogHandlers.test.ts",
-	"src/core/controller/models/__tests__/providerSwitchNormalization.test.ts",
-	"src/core/controller/models/__tests__/resolveModelInfo.test.ts",
-	"src/core/controller/models/__tests__/providerCatalogSmoke.test.ts",
-	"src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts",
-]
-
-const projectRoot = path.resolve(import.meta.dir, "..")
-
-async function resolveFiles(): Promise<string[]> {
-	const seen = new Set<string>()
-	for (const pattern of INCLUDE_PATTERNS) {
-		const glob = new Glob(pattern)
-		for await (const match of glob.scan({ cwd: projectRoot, onlyFiles: true })) {
-			seen.add(match)
-		}
-	}
-	return [...seen].sort()
-}
-
-async function main(): Promise<void> {
-	const files = await resolveFiles()
-	if (files.length === 0) {
-		console.error("run-bun-tests: no test files matched the include patterns")
-		process.exit(1)
-	}
-
-	const passthrough = process.argv.slice(2)
-	if (passthrough.includes("--list")) {
-		console.log(files.join("\n"))
-		return
-	}
-
-	const args = ["test", "--parallel", ...passthrough.filter((arg) => arg !== "--list"), ...files]
-	const child = spawn("bun", args, { cwd: projectRoot, stdio: "inherit" })
-	child.on("exit", (code, signal) => {
-		if (signal) {
-			process.kill(process.pid, signal)
-			return
-		}
-		process.exit(code ?? 1)
-	})
-}
-
-void main()

apps/vscode/scripts/run-bun-unit-tests.ts

@@ -1,198 +0,0 @@
-#!/usr/bin/env bun
-
-import path from "node:path"
-/**
- * Runner for the node-side `bun test` unit suites.
- *
- * A test file belongs to this runner iff it imports from "bun:test" (files that
- * need the real VS Code extension host import from "mocha" and run under
- * @vscode/test-cli instead). We glob all `*.test.ts` and keep only the
- * bun:test ones; the SDK/model-catalog suites listed in IGNORED run through
- * `run-bun-tests.ts`, so they're skipped here to avoid double-running.
- *
- * Why one process per file: `bun test --parallel <allFiles>` reuses a pool of
- * worker processes, and `mock.module(...)` registrations accumulate across files
- * sharing a worker. Suites that mock the same specifier with different shapes
- * (e.g. `@core/storage/disk`, `@cline/core`, `fs/promises`, `os`) then clobber
- * each other and fail only at scale. Spawning one `bun test` process per file
- * (bounded by a small concurrency pool, via `Bun.spawn`) gives each file a fresh
- * module registry.
- *
- * Usage:
- *   bun scripts/run-bun-unit-tests.ts            # run the suite, isolated
- *   bun scripts/run-bun-unit-tests.ts --list     # print the resolved file list
- *   bun scripts/run-bun-unit-tests.ts --all      # include ELECTRON_HOST_ONLY
- *   bun scripts/run-bun-unit-tests.ts -c 6       # concurrency (default 4)
- */
-import { Glob } from "bun"
-
-const projectRoot = path.resolve(import.meta.dir, "..")
-
-// A file runs under `bun test` iff it imports "bun:test"; mocha-owned files are
-// skipped by the import filter in resolveFiles().
-const INCLUDE_PATTERNS = ["src/**/*.test.ts"]
-const BUN_TEST_IMPORT = /from\s+["']bun:test["']/
-
-// SDK + model-catalog suites run through `run-bun-tests.ts`; skip them here so
-// they aren't run twice.
-const IGNORED = new Set<string>([
-	"src/core/controller/models/__tests__/providerCatalogHandlers.test.ts",
-	"src/core/controller/models/__tests__/providerCatalogSmoke.test.ts",
-	"src/core/controller/models/__tests__/providerSwitchNormalization.test.ts",
-	"src/core/controller/models/__tests__/resolveModelInfo.test.ts",
-	"src/core/controller/models/__tests__/refreshClineRecommendedModels.test.ts",
-])
-
-// Files that require the real VSCode Electron host (@vscode/test-cli). Excluded
-// by default; they continue to run under @vscode/test-cli.
-const ELECTRON_HOST_ONLY = new Set<string>([])
-
-async function resolveFiles(includeHostOnly: boolean): Promise<string[]> {
-	const seen = new Set<string>()
-	for (const pattern of INCLUDE_PATTERNS) {
-		const glob = new Glob(pattern)
-		for await (const match of glob.scan({ cwd: projectRoot, onlyFiles: true })) {
-			const normalized = match.split(path.sep).join("/")
-			if (IGNORED.has(normalized)) {
-				continue
-			}
-			if (!includeHostOnly && ELECTRON_HOST_ONLY.has(normalized)) {
-				continue
-			}
-			// Only bun-runner-owned files (those importing "bun:test"). Files still on
-			// the @vscode/test-cli Electron host import from "mocha" and are skipped.
-			const source = await Bun.file(path.join(projectRoot, normalized)).text()
-			if (!BUN_TEST_IMPORT.test(source)) {
-				continue
-			}
-			seen.add(normalized)
-		}
-	}
-	return [...seen].sort()
-}
-
-type FileResult = {
-	file: string
-	code: number
-	pass: number
-	fail: number
-	output: string
-}
-
-// `bun test` prints its summary as e.g. " 12 pass\n  0 fail".
-function parseCounts(output: string): { pass: number; fail: number } {
-	let pass = 0
-	let fail = 0
-	for (const m of output.matchAll(/^\s*(\d+)\s+pass\b/gm)) {
-		pass += Number(m[1])
-	}
-	for (const m of output.matchAll(/^\s*(\d+)\s+fail\b/gm)) {
-		fail += Number(m[1])
-	}
-	return { pass, fail }
-}
-
-const PER_FILE_TIMEOUT_MS = 120_000
-
-async function runOne(file: string): Promise<FileResult> {
-	const proc = Bun.spawn(["bun", "test", file], {
-		cwd: projectRoot,
-		stdout: "pipe",
-		stderr: "pipe",
-		env: { ...process.env, FORCE_COLOR: "0" },
-	})
-	// Guard against a single hung file stalling the whole pool: kill it after a
-	// generous per-file budget and surface it as a failure.
-	let timedOut = false
-	const timer = setTimeout(() => {
-		timedOut = true
-		proc.kill()
-	}, PER_FILE_TIMEOUT_MS)
-	const [stdout, stderr, code] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited,
-	])
-	clearTimeout(timer)
-	const output = stdout + stderr + (timedOut ? `\n[runner] TIMEOUT after ${PER_FILE_TIMEOUT_MS}ms — killed\n` : "")
-	const { pass, fail } = parseCounts(output)
-	// A nonzero exit with no parsed counts (load/parse error, timeout) must count
-	// as a failure so the gate cannot pass silently.
-	const effectiveFail = timedOut && fail === 0 ? Math.max(fail, 1) : fail
-	return { file, code, pass, fail: effectiveFail, output }
-}
-
-async function runPool(files: string[], concurrency: number): Promise<FileResult[]> {
-	const results: FileResult[] = []
-	let next = 0
-	const launch = async (): Promise<void> => {
-		while (next < files.length) {
-			const file = files[next++]
-			const result = await runOne(file)
-			results.push(result)
-			const failed = result.fail > 0 || result.code !== 0
-			const status = failed ? "FAIL" : "ok"
-			const counts = `${result.pass} pass / ${result.fail} fail`
-			process.stdout.write(`[${results.length}/${files.length}] ${status.padEnd(4)} ${counts.padEnd(20)} ${file}\n`)
-			if (failed) {
-				process.stdout.write(result.output.trimEnd() + "\n")
-			}
-		}
-	}
-	const workers: Promise<void>[] = []
-	for (let i = 0; i < Math.min(concurrency, files.length); i++) {
-		workers.push(launch())
-	}
-	await Promise.all(workers)
-	return results
-}
-
-function parseConcurrency(argv: string[]): number {
-	const flagIdx = argv.findIndex((a) => a === "-c" || a === "--concurrency")
-	if (flagIdx !== -1 && argv[flagIdx + 1]) {
-		const n = Number(argv[flagIdx + 1])
-		if (Number.isFinite(n) && n > 0) {
-			return Math.floor(n)
-		}
-	}
-	return 4
-}
-
-async function main(): Promise<void> {
-	const passthrough = process.argv.slice(2)
-	const includeHostOnly = passthrough.includes("--all")
-	const files = await resolveFiles(includeHostOnly)
-	if (files.length === 0) {
-		console.error("run-bun-unit-tests: no test files matched")
-		process.exit(1)
-	}
-
-	if (passthrough.includes("--list")) {
-		console.log(files.join("\n"))
-		return
-	}
-
-	const concurrency = parseConcurrency(passthrough)
-	const started = Date.now()
-	console.log(`Running ${files.length} unit test files, isolated (concurrency ${concurrency})…\n`)
-
-	const results = await runPool(files, concurrency)
-
-	const totalPass = results.reduce((sum, r) => sum + r.pass, 0)
-	const totalFail = results.reduce((sum, r) => sum + r.fail, 0)
-	const failedFiles = results.filter((r) => r.fail > 0 || r.code !== 0).sort((a, b) => a.file.localeCompare(b.file))
-	const elapsed = ((Date.now() - started) / 1000).toFixed(1)
-
-	console.log("\n──────────────────────────────────────────────")
-	console.log(`Files: ${results.length}   Pass: ${totalPass}   Fail: ${totalFail}   Time: ${elapsed}s`)
-	if (failedFiles.length > 0) {
-		console.log(`\nFailing files (${failedFiles.length}):`)
-		for (const r of failedFiles) {
-			console.log(`  ${r.file}  (${r.pass} pass / ${r.fail} fail, exit ${r.code})`)
-		}
-		process.exit(1)
-	}
-	console.log("All unit test files passed.")
-}
-
-void main()

apps/vscode/scripts/run-extension-host.sh

@@ -18,11 +18,11 @@ fi
 
 # Step 1: Build protos (everything depends on this)
 echo "Building protos..."
-bun run protos || { echo "Protos build failed"; exit 1; }
+npm run protos || { echo "Protos build failed"; exit 1; }
 
 # Step 2: Build webview once
 echo "Building webview..."
-bun run build:webview || { echo "Webview build failed"; exit 1; }
+npm run build:webview || { echo "Webview build failed"; exit 1; }
 
 # Step 3: Kill existing session if one is running
 tmux kill-session -t "$SESSION" 2>/dev/null
@@ -44,9 +44,9 @@ tmux select-layout -t "$SESSION" even-horizontal
 # Ctrl+C kills the whole session
 tmux bind-key -T root C-c kill-session
 
-tmux send-keys -t "$SESSION:0.0" "bun run watch:esbuild" Enter
-tmux send-keys -t "$SESSION:0.1" "bun run watch:tsc" Enter
-tmux send-keys -t "$SESSION:0.2" "bun run dev:webview" Enter
+tmux send-keys -t "$SESSION:0.0" "npm run watch:esbuild" Enter
+tmux send-keys -t "$SESSION:0.1" "npm run watch:tsc" Enter
+tmux send-keys -t "$SESSION:0.2" "npm run dev:webview" Enter
 tmux send-keys -t "$SESSION:0.3" "while [ ! -f '$WORKSPACE/dist/extension.js' ]; do sleep 0.5; done && echo 'Launching Extension Host...' && code --extensionDevelopmentPath='$WORKSPACE' --disable-workspace-trust --disable-extension saoudrizwan.claude-dev --disable-extension saoudrizwan.cline-nightly '$WORKSPACE' && echo 'Extension Host launched.'" Enter
 
 # Attach to the session

apps/vscode/scripts/test-hostbridge-server.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env npx tsx
 import * as grpc from "@grpc/grpc-js"
 import { ReflectionService } from "@grpc/reflection"
 import * as health from "grpc-health-check"
@@ -87,12 +87,6 @@ function createMockService<T extends grpc.UntypedServiceImplementation>(serviceN
 						})
 						return
 
-					case "openExternal":
-						simulateOAuthBrowserCallback(call.request?.value || "")
-							.then(() => callback(null, {}))
-							.catch((error) => callback(error))
-						return
-
 					case "getWebviewHtml":
 						callback(null, {
 							html: "<html><body>Fake Webview</body></html>",
@@ -149,41 +143,6 @@ function createMockService<T extends grpc.UntypedServiceImplementation>(serviceN
 	return new Proxy({} as T, handler)
 }
 
-async function simulateOAuthBrowserCallback(urlString: string): Promise<void> {
-	let url: URL
-	try {
-		url = new URL(urlString)
-	} catch {
-		return
-	}
-
-	if (!isLoopbackHost(url.hostname) || url.pathname !== "/api/v1/auth/authorize") {
-		return
-	}
-
-	const callbackUrl = url.searchParams.get("callback_url") ?? url.searchParams.get("redirect_uri")
-	if (!callbackUrl) {
-		return
-	}
-
-	const callback = new URL(callbackUrl)
-	if (!isLoopbackHost(callback.hostname) || callback.pathname !== "/auth") {
-		return
-	}
-
-	callback.searchParams.set("code", "test-personal-token")
-	callback.searchParams.set("provider", "cline")
-
-	const response = await fetch(callback.toString())
-	if (!response.ok) {
-		throw new Error(`Mock OAuth callback failed: ${response.status} ${response.statusText}`)
-	}
-}
-
-function isLoopbackHost(hostname: string): boolean {
-	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"
-}
-
 if (require.main === module) {
 	startTestHostBridgeServer().catch((err) => {
 		console.error("Failed to start test host bridge server:", err)

apps/vscode/scripts/test-standalone-core-api-server.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env npx tsx
 
 /**
  * Simple Cline gRPC Server
@@ -7,13 +7,13 @@
  * without requiring the full installation, while automatically mocking all external services. Simply run:
  *
  *   # One-time setup (generates protobuf files)
- *	 bun run compile-standalone
- *   bun run test:sca-server
+ *	 npm run compile-standalone
+ *   npm run test:sca-server
  *
  * The following components are started automatically:
  *   1. HostBridge test server
  *   2. ClineApiServerMock (mock implementation of the Cline API)
- *   3. SDK WorkOS device-auth flow, with WorkOS fetches mocked by testing-platform-workos-fetch-mock.cjs
+ *   3. AuthServiceMock (activated if E2E_TEST="true")
  *
  * Environment Variables for Customization:
  *   PROJECT_ROOT - Override project root directory (default: parent of scripts dir)
@@ -22,7 +22,7 @@
  *   PROTOBUS_PORT - gRPC server port (default: 26040)
  *   HOSTBRIDGE_PORT - HostBridge server port (default: 26041)
  *   WORKSPACE_DIR - Working directory (default: current directory)
- *   E2E_TEST - Enable legacy mock auth mode (default: false)
+ *   E2E_TEST - Enable E2E test mode (default: true)
  *   CLINE_ENVIRONMENT - Environment setting (default: local)
  *
  * Ideal for local development, testing, or lightweight E2E scenarios.
@@ -38,7 +38,7 @@ import { ClineApiServerMock } from "../src/test/e2e/fixtures/server/index"
 const PROTOBUS_PORT = process.env.PROTOBUS_PORT || "26040"
 const HOSTBRIDGE_PORT = process.env.HOSTBRIDGE_PORT || "26041"
 const WORKSPACE_DIR = process.env.WORKSPACE_DIR || process.cwd()
-const E2E_TEST = process.env.E2E_TEST || "false"
+const E2E_TEST = process.env.E2E_TEST || "true"
 const CLINE_ENVIRONMENT = process.env.CLINE_ENVIRONMENT || "local"
 const USE_C8 = process.env.USE_C8 === "true"
 
@@ -66,7 +66,7 @@ async function main(): Promise<void> {
 		console.error("  CLINE_DIST_DIR - Override distribution directory")
 		console.error("  CLINE_CORE_FILE - Override core file name")
 		console.error("")
-		console.error("To build the standalone version, run: bun run compile-standalone")
+		console.error("To build the standalone version, run: npm run compile-standalone")
 		process.exit(1)
 	}
 
@@ -83,8 +83,8 @@ async function main(): Promise<void> {
 	const clineTestWorkspace = mkdtempSync(path.join(os.tmpdir(), "cline-test-workspace-"))
 
 	console.log("Starting HostBridge test server...")
-	const hostbridge: ChildProcess = spawn("bun", [path.join(__dirname, "test-hostbridge-server.ts")], {
-		stdio: "inherit",
+	const hostbridge: ChildProcess = spawn("npx", ["tsx", path.join(__dirname, "test-hostbridge-server.ts")], {
+		stdio: "pipe",
 		env: {
 			...process.env,
 			TEST_HOSTBRIDGE_WORKSPACE_DIR: clineTestWorkspace,
@@ -115,16 +115,13 @@ async function main(): Promise<void> {
 
 	const covDir = path.join(projectRoot, `coverage/coverage-core-${PROTOBUS_PORT}`)
 
-	const workosFetchMockPath = path.join(projectRoot, "scripts", "testing-platform-workos-fetch-mock.cjs")
-	const baseArgs = ["--enable-source-maps", "--require", workosFetchMockPath, path.join(distDir, "cline-core.js")]
+	const baseArgs = ["--enable-source-maps", path.join(distDir, "cline-core.js")]
 
-	const c8Bin = path.join(projectRoot, "node_modules", ".bin", process.platform === "win32" ? "c8.cmd" : "c8")
-	const spawnCommand = USE_C8 ? c8Bin : "node"
-	const spawnArgs = USE_C8 ? ["--report-dir", covDir, "node", ...baseArgs] : baseArgs
+	const spawnArgs = USE_C8 ? ["c8", "--report-dir", covDir, "node", ...baseArgs] : ["node", ...baseArgs]
 
 	console.log(`Starting Cline Core Service... (useC8=${USE_C8})`)
 
-	const coreService: ChildProcess = spawn(spawnCommand, spawnArgs, {
+	const coreService: ChildProcess = spawn("npx", spawnArgs, {
 		cwd: projectRoot,
 		env: {
 			...process.env,

apps/vscode/scripts/testing-platform-orchestrator.ts

@@ -1,15 +1,15 @@
-#!/usr/bin/env bun
+#!/usr/bin/env npx tsx
 /**
  * Test Orchestrator
  *
  * Automates server lifecycle for running spec files against the standalone server.
  *
  * Prerequisites:
- *   Build standalone first: `bun run compile-standalone`
+ *   Build standalone first: `npm run compile-standalone`
  *
  * Usage:
- *   - Single file:   `bun run test:tp-orchestrator path/to/spec.json`
- *   - All specs dir: `bun run test:tp-orchestrator tests/specs`
+ *   - Single file:   `npm run test:tp-orchestrator path/to/spec.json`
+ *   - All specs dir: `npm run test:tp-orchestrator tests/specs`
  *
  * Flags:
  *   --server-logs        Show server logs (hidden by default)
@@ -29,7 +29,7 @@ import kill from "tree-kill"
 let showServerLogs = false
 let fix = false
 let coverage = false
-const WAIT_SERVER_DEFAULT_TIMEOUT = 60000
+const WAIT_SERVER_DEFAULT_TIMEOUT = 15000
 const usedPorts = new Set<number>()
 
 /**
@@ -94,10 +94,8 @@ async function startServer(): Promise<{ server: ChildProcess; grpcPort: string }
 	const grpcPort = (await getAvailablePort()).toString()
 	const hostbridgePort = (await getAvailablePort()).toString()
 
-	const server = spawn("bun", ["scripts/test-standalone-core-api-server.ts"], {
-		// When logs are hidden, ignore stdio instead of piping it without a reader:
-		// an unread pipe can fill and stall server startup/shutdown in CI.
-		stdio: showServerLogs ? "inherit" : "ignore",
+	const server = spawn("npx", ["tsx", "scripts/test-standalone-core-api-server.ts"], {
+		stdio: showServerLogs ? "inherit" : "pipe",
 		env: {
 			...process.env,
 			PROTOBUS_PORT: grpcPort,
@@ -106,50 +104,29 @@ async function startServer(): Promise<{ server: ChildProcess; grpcPort: string }
 		},
 	})
 
-	try {
-		// Wait for either the server to become ready or fail on spawn error.
-		await Promise.race([
-			waitForPort(Number(grpcPort), "127.0.0.1", WAIT_SERVER_DEFAULT_TIMEOUT),
-			new Promise((_, reject) => server.once("error", reject)),
-			new Promise((_, reject) =>
-				server.once("exit", (code, signal) => reject(new Error(`Server exited before ready: ${code ?? signal}`))),
-			),
-		])
-	} catch (error) {
-		await stopServer(server)
-		throw error
-	}
+	// Wait for either the server to become ready or fail on spawn error
+	await Promise.race([
+		waitForPort(Number(grpcPort), "127.0.0.1", WAIT_SERVER_DEFAULT_TIMEOUT),
+		new Promise((_, reject) => server.once("error", reject)),
+	])
 
 	return { server, grpcPort }
 }
 
 function stopServer(server: ChildProcess): Promise<void> {
 	return new Promise((resolve) => {
-		if (!server.pid || server.exitCode !== null || server.signalCode !== null) return resolve()
+		if (!server.pid) return resolve()
 
-		let settled = false
-		const finish = () => {
-			if (!settled) {
-				settled = true
-				resolve()
-			}
-		}
-
-		server.once("exit", finish)
 		kill(server.pid, "SIGINT", (err) => {
 			if (err) console.warn("Failed to kill server process:", err)
+			server.once("exit", () => resolve())
 		})
-		setTimeout(() => {
-			if (!settled && server.pid) {
-				kill(server.pid, "SIGKILL", finish)
-			}
-		}, 5000).unref()
 	})
 }
 
 function runTestingPlatform(specFile: string, grpcPort: string): Promise<void> {
 	return new Promise((resolve, reject) => {
-		const testProcess = spawn("bun", ["index.ts", specFile, ...(fix ? ["--fix"] : [])], {
+		const testProcess = spawn("npx", ["ts-node", "index.ts", specFile, ...(fix ? ["--fix"] : [])], {
 			cwd: path.join(process.cwd(), "testing-platform"),
 			stdio: "inherit",
 			env: {
@@ -232,7 +209,7 @@ async function main() {
 
 	if (!inputPath) {
 		console.error(
-			"Usage: bun scripts/testing-platform-orchestrator.ts <spec-file-or-folder> [--count=N] [--server-logs] [--fix] [--coverage]",
+			"Usage: npx tsx scripts/testing-platform-orchestrator.ts <spec-file-or-folder> [--count=N] [--server-logs] [--fix] [--coverage]",
 		)
 		process.exit(1)
 	}

apps/vscode/scripts/testing-platform-workos-fetch-mock.cjs

@@ -1,56 +0,0 @@
-// Preload used by the standalone testing platform.
-// It makes the SDK WorkOS device-auth flow deterministic and fully local while
-// leaving production auth code on the same device-auth path used by users.
-
-const originalFetch = globalThis.fetch?.bind(globalThis)
-
-const WORKOS_ORIGIN = "https://api.workos.com"
-const DEVICE_CODE = "test-device-code"
-const USER_CODE = "PTBC-TXTP"
-const ACCESS_TOKEN = "test-personal-token"
-const REFRESH_TOKEN = "test-personal-token_refresh"
-
-function jsonResponse(body, init = {}) {
-	return new Response(JSON.stringify(body), {
-		status: init.status ?? 200,
-		headers: { "Content-Type": "application/json", ...(init.headers ?? {}) },
-	})
-}
-
-function inputUrl(input) {
-	if (typeof input === "string") return input
-	if (input instanceof URL) return input.toString()
-	if (input && typeof input === "object" && "url" in input) return input.url
-	return String(input)
-}
-
-globalThis.fetch = async (input, init) => {
-	const urlString = inputUrl(input)
-	let url
-	try {
-		url = new URL(urlString)
-	} catch {
-		return originalFetch(input, init)
-	}
-
-	if (url.origin === WORKOS_ORIGIN && url.pathname === "/user_management/authorize/device") {
-		return jsonResponse({
-			device_code: DEVICE_CODE,
-			user_code: USER_CODE,
-			verification_uri: "https://login.workos.test/device",
-			verification_uri_complete: `https://login.workos.test/device?user_code=${USER_CODE}`,
-			expires_in: 300,
-			interval: 1,
-		})
-	}
-
-	if (url.origin === WORKOS_ORIGIN && url.pathname === "/user_management/authenticate") {
-		return jsonResponse({
-			access_token: ACCESS_TOKEN,
-			refresh_token: REFRESH_TOKEN,
-			token_type: "Bearer",
-		})
-	}
-
-	return originalFetch(input, init)
-}

apps/vscode/src/__tests__/config.test.ts

@@ -1,21 +1,9 @@
-import { afterEach, beforeEach, describe, it, mock } from "bun:test"
+import { afterEach, beforeEach, describe, it } from "mocha"
 import "should"
 import fs from "fs/promises"
-import * as actualOs from "os"
+import os from "os"
 import path from "path"
 import sinon from "sinon"
-
-// The SUT does `import * as os from "os"; os.homedir()`. Under bun, sinon's
-// `stub(os, "homedir")` on the test's own `os` binding does NOT propagate to the
-// SUT's namespace import, so inject a module-level homedir stub via mock.module
-// (the rest of `os` — tmpdir() etc. — keeps its real behavior).
-const homedirStub = sinon.stub()
-const osMockNamespace = { ...actualOs, homedir: homedirStub }
-const osMock = () => ({ ...osMockNamespace, default: osMockNamespace })
-mock.module("os", osMock)
-mock.module("node:os", osMock)
-
-import os from "os"
 import { ClineConfigurationError, ClineEndpoint, ClineEnv, Environment } from "../config"
 
 describe("ClineEndpoint configuration", () => {
@@ -31,10 +19,11 @@ describe("ClineEndpoint configuration", () => {
 		// Create .cline directory
 		await fs.mkdir(path.join(tempDir, ".cline"), { recursive: true })
 
-		// Stub os.homedir to return our temp directory (via mock.module homedirStub)
+		// Stub os.homedir to return our temp directory
 		originalHomedir = os.homedir
-		homedirStub.reset()
-		homedirStub.returns(tempDir)
+		sandbox
+			.stub(os, "homedir")
+			.returns(tempDir)
 
 		// Reset the singleton state using internal method
 		;(ClineEndpoint as any)._instance = null

apps/vscode/src/common.ts

@@ -4,19 +4,20 @@ import "./utils/path" // necessary to have access to String.prototype.toPosix
 import { HostProvider } from "@/hosts/host-provider"
 import { Logger } from "@/shared/services/Logger"
 import type { StorageContext } from "@/shared/storage/storage-context"
+import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
 import { clearOnboardingModelsCache } from "./core/controller/models/getClineOnboardingModels"
 import { HookDiscoveryCache } from "./core/hooks/HookDiscoveryCache"
 import { HookProcessRegistry } from "./core/hooks/HookProcessRegistry"
 import { StateManager } from "./core/storage/StateManager"
 import { AgentConfigLoader } from "./core/task/tools/subagent/AgentConfigLoader"
 import { ExtensionRegistryInfo } from "./registry"
-import { registerVsCodeLmHandler } from "./sdk/vscode-lm/register-vscode-lm"
 import { ErrorService } from "./services/error"
 import { featureFlagsService } from "./services/feature-flags"
 import { getDistinctId } from "./services/logging/distinctId"
 import { telemetryService } from "./services/telemetry"
 import { PostHogClientProvider } from "./services/telemetry/providers/posthog/PostHogClientProvider"
 import { ClineTempManager } from "./services/temp"
+import { cleanupTestMode } from "./services/test/TestMode"
 import { ShowMessageType } from "./shared/proto/host/window"
 import { syncWorker } from "./shared/services/worker/sync"
 import { getBlobStoreSettingsFromEnv } from "./shared/services/worker/worker"
@@ -51,11 +52,6 @@ export async function initialize(storageContext: StorageContext): Promise<Webvie
 		})
 	}
 
-	// Register host-only SDK provider handlers (e.g. VS Code Language Model API),
-	// which depend on the `vscode` module and cannot live in the SDK package.
-	// Must run before any handler is built (standalone utilities or task loop).
-	registerVsCodeLmHandler()
-
 	// =============== External services ===============
 	await ErrorService.initialize()
 	// Initialize PostHog client provider (skip in self-hosted mode)
@@ -78,6 +74,8 @@ export async function initialize(storageContext: StorageContext): Promise<Webvie
 	syncWorker().init({ ...blobStoreSettings, userDistinctId: getDistinctId() })
 	// Clean up old temp files in background (non-blocking) and start periodic cleanup every 24 hours
 	ClineTempManager.startPeriodicCleanup()
+	// Clean up orphaned file context warnings (startup cleanup)
+	FileContextTracker.cleanupOrphanedWarnings(stateManager)
 
 	telemetryService.captureExtensionActivated()
 
@@ -108,7 +106,7 @@ async function showVersionUpdateAnnouncement(stateManager: StateManager) {
 				})
 			}
 			// Always update the main version tracker for the next launch.
-			stateManager.setGlobalState("clineVersion", currentVersion)
+			await stateManager.setGlobalState("clineVersion", currentVersion)
 		}
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)
@@ -153,28 +151,23 @@ async function checkWorktreeAutoOpen(stateManager: StateManager): Promise<void>
  * Performs cleanup when Cline is deactivated that is common to all platforms.
  */
 export async function tearDown(): Promise<void> {
-	try {
-		AgentConfigLoader.getInstance()?.dispose()
-		PostHogClientProvider.getInstance().dispose()
-		telemetryService.dispose()
-		ErrorService.get().dispose()
-		featureFlagsService.dispose()
-		// Dispose all webview instances
-		await WebviewProvider.disposeAllInstances()
-		syncWorker().dispose()
-		clearOnboardingModelsCache()
+	AgentConfigLoader.getInstance()?.dispose()
+	PostHogClientProvider.getInstance().dispose()
+	telemetryService.dispose()
+	ErrorService.get().dispose()
+	featureFlagsService.dispose()
+	// Dispose all webview instances
+	await WebviewProvider.disposeAllInstances()
+	syncWorker().dispose()
+	clearOnboardingModelsCache()
 
-		// Kill any running hook processes to prevent zombies
-		await HookProcessRegistry.terminateAll()
-		// Clean up hook discovery cache
-		HookDiscoveryCache.getInstance().dispose()
-		// Stop periodic temp file cleanup
-		ClineTempManager.stopPeriodicCleanup()
-	} finally {
-		try {
-			await StateManager.get().flushPendingState()
-		} catch (error) {
-			Logger.error("[Cline] Failed to flush pending state during teardown:", error)
-		}
-	}
+	// Kill any running hook processes to prevent zombies
+	await HookProcessRegistry.terminateAll()
+	// Clean up hook discovery cache
+	HookDiscoveryCache.getInstance().dispose()
+	// Stop periodic temp file cleanup
+	ClineTempManager.stopPeriodicCleanup()
+
+	// Clean up test mode
+	cleanupTestMode()
 }

apps/vscode/src/config.ts

@@ -4,11 +4,12 @@ import * as path from "path"
 import { Environment, type EnvironmentConfig } from "./shared/config-types"
 import { Logger } from "./shared/services/Logger"
 
-export { Environment } /**
+export { Environment, type EnvironmentConfig }
+
+/**
  * Schema for the endpoints.json configuration file used in on-premise deployments.
  * All fields are required and must be valid URLs.
  */
-
 interface EndpointsFileSchema {
 	appBaseUrl: string
 	apiBaseUrl: string
@@ -35,7 +36,7 @@ class ClineEndpoint {
 	private onPremiseConfig: EndpointsFileSchema | null = null
 	private environment: Environment = Environment.production
 	// Track if config came from bundled file (enterprise distribution)
-	private isBundled = false
+	private isBundled: boolean = false
 
 	private constructor() {
 		// Set environment at module load. Use override if provided.

apps/vscode/src/core/api/__tests__/index.test.ts

@@ -0,0 +1,104 @@
+import "should"
+import {
+	type ApiConfiguration,
+	clinePassDefaultModelId,
+	clinePassModelInfoSaneDefaults,
+	clinePassModels,
+	type ModelInfo,
+} from "@shared/api"
+import type { Mode } from "@shared/storage/types"
+import sinon from "sinon"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
+import { buildApiHandler } from "../index"
+
+describe("buildApiHandler", () => {
+	beforeEach(() => {
+		sinon.stub(ClineAccountService, "getInstance").returns({} as any)
+		sinon.stub(AuthService, "getInstance").returns({} as any)
+	})
+
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const buildClinePassHandler = (configuration: Partial<ApiConfiguration>, mode: Mode = "act") =>
+		buildApiHandler(
+			{
+				planModeApiProvider: "cline-pass",
+				actModeApiProvider: "cline-pass",
+				...configuration,
+			} as ApiConfiguration,
+			mode,
+		)
+
+	describe("cline-pass provider", () => {
+		const freeModelInfo: ModelInfo = {
+			...clinePassModelInfoSaneDefaults,
+			maxTokens: 32_768,
+			contextWindow: 256_000,
+			description: "A free model",
+		}
+
+		it("passes a free (non cline-pass prefixed) model id through with its stored info", () => {
+			const handler = buildClinePassHandler({
+				actModeClinePassModelId: "kwaipilot/kat-coder-pro",
+				actModeClinePassModelInfo: freeModelInfo,
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("kwaipilot/kat-coder-pro")
+			model.info.should.deepEqual(freeModelInfo)
+		})
+
+		it("passes a :free suffixed model id through with its stored info", () => {
+			const handler = buildClinePassHandler({
+				actModeClinePassModelId: "arcee-ai/trinity-large-preview:free",
+				actModeClinePassModelInfo: freeModelInfo,
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("arcee-ai/trinity-large-preview:free")
+			model.info.should.deepEqual(freeModelInfo)
+		})
+
+		it("falls back to sane defaults for a free model id without stored info", () => {
+			const handler = buildClinePassHandler({
+				actModeClinePassModelId: "kwaipilot/kat-coder-pro",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("kwaipilot/kat-coder-pro")
+			model.info.should.deepEqual(clinePassModelInfoSaneDefaults)
+		})
+
+		it("resolves cline-pass ids against the static model table", () => {
+			const handler = buildClinePassHandler({
+				actModeClinePassModelId: "cline-pass/glm-5.2",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("cline-pass/glm-5.2")
+			model.info.should.deepEqual(clinePassModels["cline-pass/glm-5.2"])
+		})
+
+		it("falls back to the default pass model when no model id is configured", () => {
+			const handler = buildClinePassHandler({})
+
+			const model = handler.getModel()
+			model.id.should.equal(clinePassDefaultModelId)
+			model.info.should.deepEqual(clinePassModels[clinePassDefaultModelId])
+		})
+
+		it("resolves plan and act mode model ids independently", () => {
+			const configuration: Partial<ApiConfiguration> = {
+				planModeClinePassModelId: "kwaipilot/kat-coder-pro",
+				planModeClinePassModelInfo: freeModelInfo,
+				actModeClinePassModelId: "cline-pass/glm-5.2",
+			}
+
+			buildClinePassHandler(configuration, "plan").getModel().id.should.equal("kwaipilot/kat-coder-pro")
+			buildClinePassHandler(configuration, "act").getModel().id.should.equal("cline-pass/glm-5.2")
+		})
+	})
+})

apps/vscode/src/core/api/adapters/diff-editors.ts

@@ -0,0 +1,606 @@
+import { ClineStorageMessage } from "@/shared/messages/content"
+
+const APPLY_PATCH_PATCH_REGEX = /\*\*\* Begin Patch\s+([\s\S]*?)\s+\*\*\* End Patch/m
+
+/**
+ * Convert apply_patch tool calls to write_to_file and replace_in_file format
+ */
+export function convertApplyPatchToolCalls(messages: Array<ClineStorageMessage>): Array<ClineStorageMessage> {
+	// Map to track tool_use_id to converted tool info and original input
+	const toolUseIdMap = new Map<string, { name: string; input: any; originalInput: any }>()
+
+	return messages.map((message) => {
+		if (!Array.isArray(message.content)) {
+			return message
+		}
+
+		const convertedContent = message.content.map((block) => {
+			// Handle tool_use blocks
+			if (block.type === "tool_use" && block.name === "apply_patch") {
+				const converted = convertApplyPatchToToolCalls(block.input)
+				// Store the conversion with original input for matching tool_result
+				toolUseIdMap.set(block.id, { ...converted, originalInput: block.input })
+
+				return {
+					...block,
+					name: converted.name,
+					input: converted.input,
+				}
+			}
+
+			// Handle tool_result blocks
+			if (block.type === "tool_result") {
+				const conversion = toolUseIdMap.get(block.tool_use_id)
+				if (conversion) {
+					// Reconstruct the tool_result content to match apply_patch format
+					const reconstructedContent = reconstructApplyPatchResult(
+						block,
+						conversion.name,
+						conversion.input,
+						conversion.originalInput,
+					)
+					return {
+						...block,
+						content: reconstructedContent,
+					}
+				}
+			}
+
+			return block
+		})
+
+		return {
+			...message,
+			content: convertedContent,
+		}
+	})
+}
+
+interface ConvertedTool {
+	name: string
+	input: any
+}
+
+/**
+ * Parse apply_patch input and convert to write_to_file or replace_in_file format
+ */
+function convertApplyPatchToToolCalls(input: any): ConvertedTool {
+	const patchInput = typeof input === "string" ? input : input?.input || ""
+
+	// Parse the patch format
+	const patchMatch = patchInput.match(APPLY_PATCH_PATCH_REGEX)
+	if (!patchMatch) {
+		// If we can't parse it, return as-is with write_to_file
+		return {
+			name: "write_to_file",
+			input: input,
+		}
+	}
+
+	const patchContent = patchMatch[1]
+
+	// Extract file operation (Add, Update, or Delete)
+	const fileMatch = patchContent.match(/\*\*\* (Add|Update|Delete) File: (.+?)(?:\n|$)/m)
+	if (!fileMatch) {
+		return {
+			name: "write_to_file",
+			input: input,
+		}
+	}
+
+	const action = fileMatch[1]
+	const filePath = fileMatch[2].trim()
+
+	// If it's an Add operation, convert to write_to_file
+	if (action === "Add") {
+		// Extract the content after the file line
+		const contentAfterFile = patchContent.substring(fileMatch.index! + fileMatch[0].length)
+		return {
+			name: "write_to_file",
+			input: {
+				absolutePath: filePath,
+				content: extractNewContentFromPatch(contentAfterFile),
+			},
+		}
+	}
+
+	// If it's Update or Delete, convert to replace_in_file
+	if (action === "Update" || action === "Delete") {
+		const diff = convertPatchToDiff(patchContent.substring(fileMatch.index! + fileMatch[0].length))
+		return {
+			name: "replace_in_file",
+			input: {
+				absolutePath: filePath,
+				diff: diff,
+			},
+		}
+	}
+
+	// Fallback
+	return {
+		name: "write_to_file",
+		input: input,
+	}
+}
+
+/**
+ * Extract new content from add operation patch
+ */
+function extractNewContentFromPatch(patchContent: string): string {
+	// For Add operations, the patch should contain lines starting with +
+	const lines = patchContent.split("\n")
+	const contentLines: string[] = []
+
+	for (const line of lines) {
+		if (line.startsWith("+")) {
+			// Remove the + prefix and exactly ONE space if present (but not if it's a tab)
+			let content = line.substring(1)
+			if (content.startsWith(" ") && !content.startsWith("\t")) {
+				content = content.substring(1)
+			}
+			contentLines.push(content)
+		}
+	}
+
+	return contentLines.join("\n")
+}
+
+/**
+ * Convert V4A patch format to SEARCH/REPLACE format
+ */
+function convertPatchToDiff(patchContent: string): string {
+	const diffBlocks: string[] = []
+	const lines = patchContent.split("\n")
+
+	let i = 0
+	while (i < lines.length) {
+		const line = lines[i]
+
+		// Skip empty lines at the start
+		if (!line.trim() && i === 0) {
+			i++
+			continue
+		}
+
+		// Check if this is the start of a hunk (@@) or a direct change line
+		if (line.trim().startsWith("@@") || line.startsWith("-") || line.startsWith("+")) {
+			const currentSearch: string[] = []
+			const currentReplace: string[] = []
+
+			// Collect @@ context marker lines
+			// @@ prefix marks context lines. If @@something, then "something" is context.
+			// If just @@, then it's an empty context line.
+			while (i < lines.length && lines[i].trim().startsWith("@@")) {
+				const trimmedLine = lines[i].trim()
+				// Extract the actual context content after @@
+				const contextLine = trimmedLine.substring(2)
+				// Always add the context line (even if empty)
+				currentSearch.push(contextLine)
+				currentReplace.push(contextLine)
+				i++
+			}
+
+			if (i >= lines.length) {
+				break
+			}
+
+			// Collect all remaining lines in this hunk until we hit end of content or next @@
+			const hunkLines: string[] = []
+			while (i < lines.length) {
+				// Check if this is a new hunk (starts with @@)
+				if (lines[i].trim().startsWith("@@")) {
+					break
+				}
+				hunkLines.push(lines[i])
+				i++
+			}
+
+			// Now process the hunk to build SEARCH/REPLACE
+			let hasChanges = false
+			for (let j = 0; j < hunkLines.length; j++) {
+				const hunkLine = hunkLines[j]
+
+				if (hunkLine.startsWith("-")) {
+					hasChanges = true
+					// Strip the - prefix and exactly ONE space if present (but not if it's a tab)
+					let content = hunkLine.substring(1)
+					if (content.startsWith(" ") && !content.startsWith(" \t")) {
+						content = content.substring(1)
+					}
+					currentSearch.push(content)
+				} else if (hunkLine.startsWith("+")) {
+					hasChanges = true
+					// Strip the + prefix and exactly ONE space if present (but not if it's a tab)
+					let content = hunkLine.substring(1)
+					if (content.startsWith(" ") && !content.startsWith(" \t")) {
+						content = content.substring(1)
+					}
+					currentReplace.push(content)
+				} else {
+					// Context line without @@ prefix - add to both sides
+					currentSearch.push(hunkLine)
+					currentReplace.push(hunkLine)
+				}
+			}
+
+			// Create the diff block if we have changes
+			if (hasChanges && (currentSearch.length > 0 || currentReplace.length > 0)) {
+				diffBlocks.push(
+					"------- SEARCH\n" +
+						currentSearch.join("\n") +
+						"\n=======\n" +
+						currentReplace.join("\n") +
+						"\n+++++++ REPLACE",
+				)
+			}
+		} else {
+			i++
+		}
+	}
+
+	return diffBlocks.join("\n")
+}
+
+/**
+ * Reconstruct tool_result content to match apply_patch format by extracting
+ * the final file content and converting it back to V4A patch format
+ */
+function reconstructApplyPatchResult(
+	block: any,
+	convertedToolName: string,
+	_convertedInput: any,
+	originalInput: any,
+): string | any[] {
+	// Extract the content from the tool_result
+	const content = typeof block.content === "string" ? block.content : ""
+
+	// Try to extract the final_file_content
+	const finalContentMatch = content.match(/<final_file_content path="([^"]+)">\s*([\s\S]*?)\s*<\/final_file_content>/)
+
+	if (!finalContentMatch) {
+		// If no final_file_content found, return original content
+		return block.content
+	}
+
+	const filePath = finalContentMatch[1]
+	const finalContent = finalContentMatch[2]
+
+	// Reconstruct the result message based on the converted tool type
+	if (convertedToolName === "write_to_file") {
+		// For write_to_file, we just need to confirm the file was created/written
+		return `[apply_patch for '${filePath}'] Result:\nThe content was successfully saved to ${filePath}.\n\nThe file has been created/updated with the new content.`
+	}
+
+	if (convertedToolName === "replace_in_file") {
+		// For replace_in_file, we need to reconstruct the V4A patch format result
+		// Try to parse the original patch to get the action and build context
+		const patchInput = typeof originalInput === "string" ? originalInput : originalInput?.input || ""
+		const patchMatch = patchInput.match(APPLY_PATCH_PATCH_REGEX)
+
+		if (patchMatch) {
+			const patchContent = patchMatch[1]
+			const fileMatch = patchContent.match(/\*\*\* (Add|Update|Delete) File: (.+?)(?:\n|$)/m)
+
+			if (fileMatch) {
+				const action = fileMatch[1]
+				return `[apply_patch for '${filePath}'] Result:\nThe content was successfully updated in ${filePath}.\n\nThe file has been modified using ${action} operation.\n\n<final_file_content path="${filePath}">\n${finalContent}\n</final_file_content>\n\nIMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference.`
+			}
+		}
+
+		// Fallback for replace_in_file
+		return `[apply_patch for '${filePath}'] Result:\nThe content was successfully updated in ${filePath}.\n\n<final_file_content path="${filePath}">\n${finalContent}\n</final_file_content>\n\nIMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference.`
+	}
+
+	// Default fallback
+	return block.content
+}
+
+/**
+ * Convert write_to_file and replace_in_file tool calls to apply_patch format
+ */
+export function convertWriteToFileToolCalls(messages: Array<ClineStorageMessage>): Array<ClineStorageMessage> {
+	// Map to track tool_use_id to converted tool info and original input
+	const toolUseIdMap = new Map<string, { originalName: string; originalInput: any; patchInput?: string }>()
+
+	// First pass: collect tool_use blocks
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue
+		}
+		for (const block of message.content) {
+			if (block.type === "tool_use" && (block.name === "write_to_file" || block.name === "replace_in_file")) {
+				toolUseIdMap.set(block.id, {
+					originalName: block.name,
+					originalInput: block.input,
+				})
+			}
+		}
+	}
+
+	// Second pass: find tool_results and extract final content to build proper patches
+	const finalContentMap = new Map<string, string>()
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) {
+			continue
+		}
+		for (const block of message.content) {
+			if (block.type === "tool_result" && toolUseIdMap.has(block.tool_use_id)) {
+				const content = typeof block.content === "string" ? block.content : ""
+				const finalContentMatch = content.match(
+					/<final_file_content path="([^"]+)">\s*([\s\S]*?)\s*<\/final_file_content>/,
+				)
+				if (finalContentMatch) {
+					finalContentMap.set(block.tool_use_id, finalContentMatch[2])
+				}
+			}
+		}
+	}
+
+	// Third pass: convert messages
+	return messages.map((message) => {
+		if (!Array.isArray(message.content)) {
+			return message
+		}
+
+		const convertedContent = message.content.map((block) => {
+			// Handle tool_use blocks for write_to_file and replace_in_file
+			if (block.type === "tool_use" && (block.name === "write_to_file" || block.name === "replace_in_file")) {
+				const finalContent = finalContentMap.get(block.id)
+				const patchInput = convertToPatchFormat(block.name, block.input, finalContent)
+
+				// Update the map with the generated patch
+				const existingEntry = toolUseIdMap.get(block.id)
+				if (existingEntry) {
+					existingEntry.patchInput = patchInput
+				}
+
+				return {
+					...block,
+					name: "apply_patch",
+					input: {
+						input: patchInput,
+					},
+				}
+			}
+
+			// Handle tool_result blocks
+			if (block.type === "tool_result") {
+				const conversion = toolUseIdMap.get(block.tool_use_id)
+				if (conversion) {
+					// Reconstruct the tool_result content to match apply_patch format
+					const reconstructedContent = reconstructWriteToFileResult(
+						block,
+						conversion.originalName,
+						conversion.originalInput,
+					)
+					return {
+						...block,
+						content: reconstructedContent,
+					}
+				}
+			}
+
+			return block
+		})
+
+		return {
+			...message,
+			content: convertedContent,
+		}
+	})
+}
+
+/**
+ * Convert write_to_file or replace_in_file input to apply_patch format
+ */
+function convertToPatchFormat(toolName: string, input: any, finalContent?: string): string {
+	const filePath = input.absolutePath || input.path || ""
+
+	if (toolName === "write_to_file") {
+		// Convert write_to_file to Add operation
+		const content = input.content || ""
+		const lines = content.split("\n")
+		const patchLines = ["@@"]
+		patchLines.push(...lines.map((line: string) => `+ ${line}`))
+
+		return `apply_patch <<"EOF"
+*** Begin Patch
+*** Add File: ${filePath}
+${patchLines.join("\n")}
+*** End Patch
+EOF`
+	}
+
+	if (toolName === "replace_in_file") {
+		// Convert replace_in_file to Update operation
+		const diff = input.diff || ""
+
+		// Parse SEARCH/REPLACE blocks and convert to V4A format with context
+		const patchContent = convertDiffToPatchWithContext(diff, finalContent)
+
+		return `apply_patch <<"EOF"
+*** Begin Patch
+*** Update File: ${filePath}
+${patchContent}
+*** End Patch
+EOF`
+	}
+
+	return ""
+}
+
+/**
+ * Convert SEARCH/REPLACE diff format to V4A patch format with additional context from final content
+ */
+function convertDiffToPatchWithContext(diff: string, finalContent?: string): string {
+	const patchLines: string[] = []
+
+	// Match all SEARCH/REPLACE blocks
+	const blockRegex = /------- SEARCH\s*\n([\s\S]*?)\n=======\s*\n([\s\S]*?)\n\+{7} REPLACE/g
+	let match
+
+	while ((match = blockRegex.exec(diff)) !== null) {
+		const searchContent = match[1]
+		const replaceContent = match[2]
+
+		const searchLines = searchContent.split("\n")
+		const replaceLines = replaceContent.split("\n")
+
+		// Find common prefix and suffix between search and replace
+		let prefixEnd = 0
+		while (
+			prefixEnd < searchLines.length &&
+			prefixEnd < replaceLines.length &&
+			searchLines[prefixEnd] === replaceLines[prefixEnd]
+		) {
+			prefixEnd++
+		}
+
+		let suffixStart = searchLines.length
+		let replaceSuffixStart = replaceLines.length
+		while (
+			suffixStart > prefixEnd &&
+			replaceSuffixStart > prefixEnd &&
+			searchLines[suffixStart - 1] === replaceLines[replaceSuffixStart - 1]
+		) {
+			suffixStart--
+			replaceSuffixStart--
+		}
+
+		// If we have finalContent, extract additional context from it
+		if (finalContent) {
+			const finalLines = finalContent.split("\n")
+
+			// Find where the replaced content appears in the final file
+			let matchIndex = -1
+			for (let i = 0; i < finalLines.length; i++) {
+				// Try to match the first replace line
+				if (replaceLines.length > 0 && finalLines[i] === replaceLines[0]) {
+					// Check if subsequent lines also match
+					let allMatch = true
+					for (let j = 1; j < replaceLines.length && i + j < finalLines.length; j++) {
+						if (finalLines[i + j] !== replaceLines[j]) {
+							allMatch = false
+							break
+						}
+					}
+					if (allMatch) {
+						matchIndex = i
+						break
+					}
+				}
+			}
+
+			if (matchIndex >= 0) {
+				// Extract up to 3 lines before as context
+				const contextStart = Math.max(0, matchIndex - 3)
+				const contextLines: string[] = []
+				for (let i = contextStart; i < matchIndex; i++) {
+					contextLines.push(finalLines[i])
+				}
+
+				// Pad to 3 lines if needed (with empty strings)
+				while (contextLines.length < 3) {
+					contextLines.unshift("")
+				}
+
+				// Add @@ marker with the first context line
+				if (contextLines[0] === "") {
+					patchLines.push("@@")
+				} else {
+					patchLines.push(`@@${contextLines[0]}`)
+				}
+
+				// Add remaining context lines (without @@ marker)
+				for (let i = 1; i < contextLines.length; i++) {
+					patchLines.push(contextLines[i])
+				}
+
+				// Add common prefix lines (without +/- markers)
+				for (let i = 0; i < prefixEnd; i++) {
+					patchLines.push(searchLines[i])
+				}
+
+				// Add the actual changes (lines that differ)
+				for (let i = prefixEnd; i < suffixStart; i++) {
+					patchLines.push(`- ${searchLines[i]}`)
+				}
+				for (let i = prefixEnd; i < replaceSuffixStart; i++) {
+					patchLines.push(`+ ${replaceLines[i]}`)
+				}
+
+				// Add common suffix lines (without +/- markers)
+				for (let i = suffixStart; i < searchLines.length; i++) {
+					patchLines.push(searchLines[i])
+				}
+
+				// Extract up to 3 lines after as trailing context (without @@ markers)
+				const contextEnd = Math.min(finalLines.length, matchIndex + replaceLines.length + 3)
+				for (let i = matchIndex + replaceLines.length; i < contextEnd; i++) {
+					patchLines.push(finalLines[i])
+				}
+
+				continue
+			}
+		}
+
+		// Fallback: if no finalContent or couldn't find match, use the prefix/suffix from SEARCH/REPLACE
+		patchLines.push("@@")
+
+		// Add common prefix lines (without +/- markers)
+		for (let i = 0; i < prefixEnd; i++) {
+			patchLines.push(searchLines[i])
+		}
+
+		// Add the actual changes (lines that differ)
+		for (let i = prefixEnd; i < suffixStart; i++) {
+			patchLines.push(`- ${searchLines[i]}`)
+		}
+		for (let i = prefixEnd; i < replaceSuffixStart; i++) {
+			patchLines.push(`+ ${replaceLines[i]}`)
+		}
+
+		// Add common suffix lines (without +/- markers)
+		for (let i = suffixStart; i < searchLines.length; i++) {
+			patchLines.push(searchLines[i])
+		}
+	}
+
+	return patchLines.join("\n")
+}
+
+/**
+ * Reconstruct tool_result content to match apply_patch result format
+ */
+function reconstructWriteToFileResult(block: any, originalToolName: string, originalInput: any): string | any[] {
+	// Extract the content from the tool_result
+	const content = typeof block.content === "string" ? block.content : ""
+
+	// Try to extract the final_file_content
+	const finalContentMatch = content.match(/<final_file_content path="([^"]+)">\s*([\s\S]*?)\s*<\/final_file_content>/)
+
+	const filePath = originalInput.absolutePath || originalInput.path || ""
+
+	if (!finalContentMatch) {
+		// If no final_file_content found, create a simple success message
+		if (originalToolName === "write_to_file") {
+			return `[apply_patch for '${filePath}'] Result:\nThe content was successfully saved to ${filePath}.\n\nThe file has been created/updated with the new content.`
+		} else {
+			return `[apply_patch for '${filePath}'] Result:\nThe content was successfully updated in ${filePath}.\n\nThe file has been modified.`
+		}
+	}
+
+	const finalContent = finalContentMatch[2]
+
+	// Reconstruct the result message based on the original tool type
+	if (originalToolName === "write_to_file") {
+		return `[apply_patch for '${filePath}'] Result:\nThe content was successfully saved to ${filePath}.\n\nThe file has been created/updated with the new content.`
+	}
+
+	if (originalToolName === "replace_in_file") {
+		return `[apply_patch for '${filePath}'] Result:\nThe content was successfully updated in ${filePath}.\n\nThe file has been modified using Update operation.\n\n<final_file_content path="${filePath}">\n${finalContent}\n</final_file_content>\n\nIMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference.`
+	}
+
+	// Default fallback
+	return block.content
+}

apps/vscode/src/core/api/adapters/index.ts

@@ -0,0 +1,60 @@
+import { ClineStorageMessage } from "@/shared/messages/content"
+import { ClineDefaultTool } from "@/shared/tools"
+import { convertApplyPatchToolCalls, convertWriteToFileToolCalls } from "./diff-editors"
+
+/**
+ * Transforms tool call messages between different tool formats based on native tool support.
+ * Converts between apply_patch and write_to_file/replace_in_file formats as needed.
+ *
+ * @param clineMessages - Array of messages containing tool calls to transform
+ * @param nativeTools - Array of tools natively supported by the current provider
+ * @returns Transformed messages array, or original if no transformation needed
+ */
+export function transformToolCallMessages(
+	clineMessages: ClineStorageMessage[],
+	nativeTools?: ClineDefaultTool[],
+): ClineStorageMessage[] {
+	// Early return if no messages or native tools provided
+	if (!clineMessages?.length || !nativeTools?.length) {
+		return clineMessages
+	}
+
+	// Create Sets for O(1) lookup performance
+	const nativeToolSet = new Set(nativeTools)
+	const usedToolSet = new Set<string>()
+
+	// Single pass: collect all tools used in assistant messages
+	for (const msg of clineMessages) {
+		if (msg.role === "assistant" && Array.isArray(msg.content)) {
+			for (const block of msg.content) {
+				if (block.type === "tool_use" && block.name) {
+					usedToolSet.add(block.name)
+				}
+			}
+		}
+	}
+
+	// Early return if no tools were used
+	if (usedToolSet.size === 0) {
+		return clineMessages
+	}
+
+	// Determine which conversion to apply
+	const hasApplyPatchNative = nativeToolSet.has(ClineDefaultTool.APPLY_PATCH)
+	const hasFileEditNative = nativeToolSet.has(ClineDefaultTool.FILE_EDIT) || nativeToolSet.has(ClineDefaultTool.FILE_NEW)
+
+	const hasApplyPatchUsed = usedToolSet.has(ClineDefaultTool.APPLY_PATCH)
+	const hasFileEditUsed = usedToolSet.has(ClineDefaultTool.FILE_EDIT) || usedToolSet.has(ClineDefaultTool.FILE_NEW)
+
+	// Convert write_to_file/replace_in_file → apply_patch
+	if (hasApplyPatchNative && hasFileEditUsed) {
+		return convertWriteToFileToolCalls(clineMessages)
+	}
+
+	// Convert apply_patch → write_to_file/replace_in_file
+	if (hasFileEditNative && hasApplyPatchUsed) {
+		return convertApplyPatchToolCalls(clineMessages)
+	}
+
+	return clineMessages
+}

apps/vscode/src/core/api/index.ts

@@ -1,18 +1,72 @@
-import { ModelInfo } from "@shared/api"
+import {
+	ApiConfiguration,
+	buildModelInfoNameMap,
+	clinePassDefaultModelId,
+	ModelInfo,
+	QwenApiRegions,
+	resolveClinePassModelInfo,
+} from "@shared/api"
 import { Mode } from "@shared/storage/types"
+import { ClineStorageMessage } from "@/shared/messages/content"
+import { Logger } from "@/shared/services/Logger"
+import { ClineTool } from "@/shared/tools"
+import { AIhubmixHandler } from "./providers/aihubmix"
+import { AnthropicHandler } from "./providers/anthropic"
+import { AskSageHandler } from "./providers/asksage"
+import { BasetenHandler } from "./providers/baseten"
+import { AwsBedrockHandler } from "./providers/bedrock"
+import { CerebrasHandler } from "./providers/cerebras"
+import { ClaudeCodeHandler } from "./providers/claude-code"
+import { ClineHandler } from "./providers/cline"
+import { DeepSeekHandler } from "./providers/deepseek"
+import { DifyHandler } from "./providers/dify"
+import { DoubaoHandler } from "./providers/doubao"
+import { FireworksHandler } from "./providers/fireworks"
+import { GeminiHandler } from "./providers/gemini"
+import { GroqHandler } from "./providers/groq"
+import { HicapHandler } from "./providers/hicap"
+import { HuaweiCloudMaaSHandler } from "./providers/huawei-cloud-maas"
+import { HuggingFaceHandler } from "./providers/huggingface"
+import { LiteLlmHandler } from "./providers/litellm"
+import { LmStudioHandler } from "./providers/lmstudio"
+import { MinimaxHandler } from "./providers/minimax"
+import { MistralHandler } from "./providers/mistral"
+import { MoonshotHandler } from "./providers/moonshot"
+import { NebiusHandler } from "./providers/nebius"
+import { NousResearchHandler } from "./providers/nousresearch"
+import { OcaHandler } from "./providers/oca"
+import { OllamaHandler } from "./providers/ollama"
+import { OpenAiHandler } from "./providers/openai"
+import { OpenAiCodexHandler } from "./providers/openai-codex"
+import { OpenAiNativeHandler } from "./providers/openai-native"
+import { OpenRouterHandler } from "./providers/openrouter"
+import { QwenHandler } from "./providers/qwen"
+import { QwenCodeHandler } from "./providers/qwen-code"
+import { RequestyHandler } from "./providers/requesty"
+import { SambanovaHandler } from "./providers/sambanova"
+import { SapAiCoreHandler } from "./providers/sapaicore"
+import { TogetherHandler } from "./providers/together"
+import { VercelAIGatewayHandler } from "./providers/vercel-ai-gateway"
+import { VertexHandler } from "./providers/vertex"
+import { VsCodeLmHandler } from "./providers/vscode-lm"
+import { WandbHandler } from "./providers/wandb"
+import { XAIHandler } from "./providers/xai"
+import { ZAiHandler } from "./providers/zai"
+import { ApiStream, ApiStreamUsageChunk } from "./transform/stream"
 
-// buildApiHandler now routes inference through the Cline SDK. It lives in
-// apps/vscode/src/sdk/sdk-api-handler.ts and callers import it directly from
-// there. It is deliberately NOT re-exported here: this barrel is imported
-// widely for *types* only, and re-exporting a value from the SDK module would
-// pull the entire SDK/session-factory runtime graph into every type importer
-// at module-eval time (which can break extension activation). Keep this file
-// types-only.
+export type CommonApiHandlerOptions = {
+	onRetryAttempt?: ApiConfiguration["onRetryAttempt"]
+}
+export interface ApiHandler {
+	createMessage(systemPrompt: string, messages: ClineStorageMessage[], tools?: ClineTool[], useResponseApi?: boolean): ApiStream
+	getModel(): ApiHandlerModel
+	getApiStreamUsage?(): Promise<ApiStreamUsageChunk | undefined>
+	abort?(): void
+}
 
 export interface ApiHandlerModel {
 	id: string
 	info: ModelInfo
-	providerId?: string
 }
 
 export interface ApiProviderInfo {
@@ -21,3 +75,472 @@ export interface ApiProviderInfo {
 	mode: Mode
 	customPrompt?: string // "compact"
 }
+
+export interface SingleCompletionHandler {
+	completePrompt(prompt: string): Promise<string>
+}
+
+function createHandlerForProvider(
+	apiProvider: string | undefined,
+	options: Omit<ApiConfiguration, "apiProvider">,
+	mode: Mode,
+): ApiHandler {
+	switch (apiProvider) {
+		case "anthropic":
+			return new AnthropicHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				apiKey: options.apiKey,
+				anthropicBaseUrl: options.anthropicBaseUrl,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "openrouter":
+			return new OpenRouterHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				openRouterApiKey: options.openRouterApiKey,
+				openRouterModelId: mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId,
+				openRouterModelInfo: mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo,
+				openRouterProviderSorting: options.openRouterProviderSorting,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				enableParallelToolCalling: options.enableParallelToolCalling,
+			})
+		case "bedrock":
+			return new AwsBedrockHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				awsAccessKey: options.awsAccessKey,
+				awsSecretKey: options.awsSecretKey,
+				awsSessionToken: options.awsSessionToken,
+				awsRegion: options.awsRegion,
+				awsAuthentication: options.awsAuthentication,
+				awsBedrockApiKey: options.awsBedrockApiKey,
+				awsUseCrossRegionInference: options.awsUseCrossRegionInference,
+				awsUseGlobalInference: options.awsUseGlobalInference,
+				awsBedrockUsePromptCache: options.awsBedrockUsePromptCache,
+				awsUseProfile: options.awsUseProfile,
+				awsProfile: options.awsProfile,
+				awsBedrockEndpoint: options.awsBedrockEndpoint,
+				awsBedrockCustomSelected:
+					mode === "plan" ? options.planModeAwsBedrockCustomSelected : options.actModeAwsBedrockCustomSelected,
+				awsBedrockCustomModelBaseId:
+					mode === "plan" ? options.planModeAwsBedrockCustomModelBaseId : options.actModeAwsBedrockCustomModelBaseId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "vertex":
+			return new VertexHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				vertexProjectId: options.vertexProjectId,
+				vertexRegion: options.vertexRegion,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				vertexCustomModelInfo:
+					mode === "plan" ? options.planModeVertexCustomModelInfo : options.actModeVertexCustomModelInfo,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				geminiApiKey: options.geminiApiKey,
+				geminiBaseUrl: options.geminiBaseUrl,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				ulid: options.ulid,
+			})
+		case "openai":
+			return new OpenAiHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				openAiApiKey: options.openAiApiKey,
+				openAiBaseUrl: options.openAiBaseUrl,
+				azureApiVersion: options.azureApiVersion,
+				azureIdentity: options.azureIdentity,
+				openAiHeaders: options.openAiHeaders,
+				openAiModelId: mode === "plan" ? options.planModeOpenAiModelId : options.actModeOpenAiModelId,
+				openAiModelInfo: mode === "plan" ? options.planModeOpenAiModelInfo : options.actModeOpenAiModelInfo,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+			})
+		case "ollama":
+			return new OllamaHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				ollamaBaseUrl: options.ollamaBaseUrl,
+				ollamaApiKey: options.ollamaApiKey,
+				ollamaModelId: mode === "plan" ? options.planModeOllamaModelId : options.actModeOllamaModelId,
+				ollamaApiOptionsCtxNum: options.ollamaApiOptionsCtxNum,
+				requestTimeoutMs: options.requestTimeoutMs,
+			})
+		case "lmstudio":
+			return new LmStudioHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				lmStudioBaseUrl: options.lmStudioBaseUrl,
+				lmStudioModelId: mode === "plan" ? options.planModeLmStudioModelId : options.actModeLmStudioModelId,
+				lmStudioMaxTokens: options.lmStudioMaxTokens,
+			})
+		case "gemini":
+			return new GeminiHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				vertexProjectId: options.vertexProjectId,
+				vertexRegion: options.vertexRegion,
+				geminiApiKey: options.geminiApiKey,
+				geminiBaseUrl: options.geminiBaseUrl,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				ulid: options.ulid,
+			})
+		case "openai-native":
+			return new OpenAiNativeHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				openAiNativeApiKey: options.openAiNativeApiKey,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "openai-codex":
+			return new OpenAiCodexHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "deepseek":
+			return new DeepSeekHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				deepSeekApiKey: options.deepSeekApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+			})
+		case "requesty":
+			return new RequestyHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				requestyBaseUrl: options.requestyBaseUrl,
+				requestyApiKey: options.requestyApiKey,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				requestyModelId: mode === "plan" ? options.planModeRequestyModelId : options.actModeRequestyModelId,
+				requestyModelInfo: mode === "plan" ? options.planModeRequestyModelInfo : options.actModeRequestyModelInfo,
+			})
+		case "fireworks":
+			return new FireworksHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				fireworksApiKey: options.fireworksApiKey,
+				fireworksModelId: mode === "plan" ? options.planModeFireworksModelId : options.actModeFireworksModelId,
+			})
+		case "together":
+			return new TogetherHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				togetherApiKey: options.togetherApiKey,
+				togetherModelId: mode === "plan" ? options.planModeTogetherModelId : options.actModeTogetherModelId,
+			})
+		case "qwen":
+			return new QwenHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				qwenApiKey: options.qwenApiKey,
+				qwenApiLine:
+					options.qwenApiLine === QwenApiRegions.INTERNATIONAL ? QwenApiRegions.INTERNATIONAL : QwenApiRegions.CHINA,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "qwen-code":
+			return new QwenCodeHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				qwenCodeOauthPath: options.qwenCodeOauthPath,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "doubao":
+			return new DoubaoHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				doubaoApiKey: options.doubaoApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "mistral":
+			return new MistralHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				mistralApiKey: options.mistralApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "vscode-lm":
+			return new VsCodeLmHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				vsCodeLmModelSelector:
+					mode === "plan" ? options.planModeVsCodeLmModelSelector : options.actModeVsCodeLmModelSelector,
+			})
+		case "cline": {
+			const configuredClineModelId = mode === "plan" ? options.planModeClineModelId : options.actModeClineModelId
+			const configuredClineModelInfo = mode === "plan" ? options.planModeClineModelInfo : options.actModeClineModelInfo
+			const clineModelId =
+				configuredClineModelId || (mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId)
+			const clineModelInfo =
+				configuredClineModelInfo ||
+				(mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo)
+			return new ClineHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				clineAccountId: options.clineAccountId,
+				clineApiKey: options.clineApiKey,
+				ulid: options.ulid,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				openRouterProviderSorting: options.openRouterProviderSorting,
+				openRouterModelId: clineModelId,
+				openRouterModelInfo: clineModelInfo,
+				enableParallelToolCalling: options.enableParallelToolCalling,
+			})
+		}
+		case "cline-pass": {
+			const configuredClinePassModelId =
+				mode === "plan" ? options.planModeClinePassModelId : options.actModeClinePassModelId
+			const configuredClinePassModelInfo =
+				mode === "plan" ? options.planModeClinePassModelInfo : options.actModeClinePassModelInfo
+			// ClinePass users may also select Cline free models (OpenRouter-style ids without
+			// the cline-pass/ prefix), so pass any configured id through to the Cline API.
+			const clineModelId = configuredClinePassModelId || clinePassDefaultModelId
+			const clineModelInfo = resolveClinePassModelInfo(
+				clineModelId,
+				configuredClinePassModelInfo
+					? buildModelInfoNameMap({ [clineModelId]: configuredClinePassModelInfo })
+					: undefined,
+			)
+			return new ClineHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				clineAccountId: options.clineAccountId,
+				clineApiKey: options.clineApiKey,
+				ulid: options.ulid,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				openRouterProviderSorting: options.openRouterProviderSorting,
+				openRouterModelId: clineModelId,
+				openRouterModelInfo: clineModelInfo,
+				enableParallelToolCalling: options.enableParallelToolCalling,
+			})
+		}
+		case "litellm":
+			return new LiteLlmHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				liteLlmApiKey: options.liteLlmApiKey,
+				liteLlmBaseUrl: options.liteLlmBaseUrl,
+				liteLlmModelId: mode === "plan" ? options.planModeLiteLlmModelId : options.actModeLiteLlmModelId,
+				liteLlmModelInfo: mode === "plan" ? options.planModeLiteLlmModelInfo : options.actModeLiteLlmModelInfo,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				liteLlmUsePromptCache: options.liteLlmUsePromptCache,
+				ulid: options.ulid,
+			})
+		case "moonshot":
+			return new MoonshotHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				moonshotApiKey: options.moonshotApiKey,
+				moonshotApiLine: options.moonshotApiLine,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "huggingface":
+			return new HuggingFaceHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				huggingFaceApiKey: options.huggingFaceApiKey,
+				huggingFaceModelId: mode === "plan" ? options.planModeHuggingFaceModelId : options.actModeHuggingFaceModelId,
+				huggingFaceModelInfo:
+					mode === "plan" ? options.planModeHuggingFaceModelInfo : options.actModeHuggingFaceModelInfo,
+			})
+		case "nebius":
+			return new NebiusHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				nebiusApiKey: options.nebiusApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "asksage":
+			return new AskSageHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				asksageApiKey: options.asksageApiKey,
+				asksageApiUrl: options.asksageApiUrl,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "xai":
+			return new XAIHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				xaiApiKey: options.xaiApiKey,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "sambanova":
+			return new SambanovaHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				sambanovaApiKey: options.sambanovaApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "cerebras":
+			return new CerebrasHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				cerebrasApiKey: options.cerebrasApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "groq":
+			return new GroqHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				groqApiKey: options.groqApiKey,
+				groqModelId: mode === "plan" ? options.planModeGroqModelId : options.actModeGroqModelId,
+				groqModelInfo: mode === "plan" ? options.planModeGroqModelInfo : options.actModeGroqModelInfo,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "baseten":
+			return new BasetenHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				basetenApiKey: options.basetenApiKey,
+				basetenModelId: mode === "plan" ? options.planModeBasetenModelId : options.actModeBasetenModelId,
+				basetenModelInfo: mode === "plan" ? options.planModeBasetenModelInfo : options.actModeBasetenModelInfo,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "sapaicore":
+			return new SapAiCoreHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				sapAiCoreClientId: options.sapAiCoreClientId,
+				sapAiCoreClientSecret: options.sapAiCoreClientSecret,
+				sapAiCoreTokenUrl: options.sapAiCoreTokenUrl,
+				sapAiResourceGroup: options.sapAiResourceGroup,
+				sapAiCoreBaseUrl: options.sapAiCoreBaseUrl,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				deploymentId: mode === "plan" ? options.planModeSapAiCoreDeploymentId : options.actModeSapAiCoreDeploymentId,
+				sapAiCoreUseOrchestrationMode: options.sapAiCoreUseOrchestrationMode,
+			})
+		case "claude-code":
+			return new ClaudeCodeHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				claudeCodePath: options.claudeCodePath,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "huawei-cloud-maas":
+			return new HuaweiCloudMaaSHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				huaweiCloudMaasApiKey: options.huaweiCloudMaasApiKey,
+				huaweiCloudMaasModelId:
+					mode === "plan" ? options.planModeHuaweiCloudMaasModelId : options.actModeHuaweiCloudMaasModelId,
+				huaweiCloudMaasModelInfo:
+					mode === "plan" ? options.planModeHuaweiCloudMaasModelInfo : options.actModeHuaweiCloudMaasModelInfo,
+			})
+		case "dify": // Add Dify.ai handler
+			return new DifyHandler({
+				difyApiKey: options.difyApiKey,
+				difyBaseUrl: options.difyBaseUrl,
+			})
+		case "vercel-ai-gateway":
+			return new VercelAIGatewayHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				vercelAiGatewayApiKey: options.vercelAiGatewayApiKey,
+				openRouterModelId:
+					mode === "plan" ? options.planModeVercelAiGatewayModelId : options.actModeVercelAiGatewayModelId,
+				openRouterModelInfo:
+					mode === "plan" ? options.planModeVercelAiGatewayModelInfo : options.actModeVercelAiGatewayModelInfo,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "zai":
+			return new ZAiHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				zaiApiLine: options.zaiApiLine,
+				zaiApiKey: options.zaiApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		case "oca":
+			return new OcaHandler({
+				ocaMode: options.ocaMode || "internal",
+				ocaBaseUrl: options.ocaBaseUrl,
+				ocaModelId: mode === "plan" ? options.planModeOcaModelId : options.actModeOcaModelId,
+				ocaModelInfo: mode === "plan" ? options.planModeOcaModelInfo : options.actModeOcaModelInfo,
+				ocaReasoningEffort: mode === "plan" ? options.planModeOcaReasoningEffort : options.actModeOcaReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				ocaUsePromptCache:
+					mode === "plan"
+						? options.planModeOcaModelInfo?.supportsPromptCache
+						: options.actModeOcaModelInfo?.supportsPromptCache,
+				taskId: options.ulid,
+			})
+		case "aihubmix":
+			return new AIhubmixHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				apiKey: options.aihubmixApiKey,
+				baseURL: options.aihubmixBaseUrl,
+				appCode: options.aihubmixAppCode,
+				modelId: mode === "plan" ? (options as any).planModeAihubmixModelId : (options as any).actModeAihubmixModelId,
+				modelInfo:
+					mode === "plan" ? (options as any).planModeAihubmixModelInfo : (options as any).actModeAihubmixModelInfo,
+			})
+		case "minimax":
+			return new MinimaxHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				minimaxApiKey: options.minimaxApiKey,
+				minimaxApiLine: options.minimaxApiLine,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+		case "hicap":
+			return new HicapHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				hicapApiKey: options.hicapApiKey,
+				hicapModelId: mode === "plan" ? options.planModeHicapModelId : options.actModeHicapModelId,
+			})
+		case "nousResearch":
+			return new NousResearchHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				nousResearchApiKey: options.nousResearchApiKey,
+				apiModelId: mode === "plan" ? options.planModeNousResearchModelId : options.actModeNousResearchModelId,
+			})
+		case "wandb":
+			return new WandbHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				wandbApiKey: options.wandbApiKey,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+			})
+		default:
+			return new AnthropicHandler({
+				onRetryAttempt: options.onRetryAttempt,
+				apiKey: options.apiKey,
+				anthropicBaseUrl: options.anthropicBaseUrl,
+				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+			})
+	}
+}
+
+export function buildApiHandler(configuration: ApiConfiguration, mode: Mode): ApiHandler {
+	const { planModeApiProvider, actModeApiProvider, ...options } = configuration
+
+	const apiProvider = mode === "plan" ? planModeApiProvider : actModeApiProvider
+
+	// Validate thinking budget tokens against model's maxTokens to prevent API errors
+	// wrapped in a try-catch for safety, but this should never throw
+	try {
+		const thinkingBudgetTokens = mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens
+		if (thinkingBudgetTokens && thinkingBudgetTokens > 0) {
+			const handler = createHandlerForProvider(apiProvider, options, mode)
+
+			const modelInfo = handler.getModel().info
+			if (modelInfo?.maxTokens && modelInfo.maxTokens > 0 && thinkingBudgetTokens > modelInfo.maxTokens) {
+				const clippedValue = modelInfo.maxTokens - 1
+				if (mode === "plan") {
+					options.planModeThinkingBudgetTokens = clippedValue
+				} else {
+					options.actModeThinkingBudgetTokens = clippedValue
+				}
+			} else {
+				return handler // don't rebuild unless its necessary
+			}
+		}
+	} catch (error) {
+		Logger.error("buildApiHandler error:", error)
+	}
+
+	return createHandlerForProvider(apiProvider, options, mode)
+}

apps/vscode/src/core/api/providers/__tests__/anthropic.test.ts

@@ -0,0 +1,284 @@
+import { afterEach, describe, it } from "mocha"
+import sinon from "sinon"
+import "should"
+import { anthropicModels } from "@shared/api"
+import { ANTHROPIC_FAST_MODE_BETA, AnthropicHandler } from "../anthropic"
+
+describe("AnthropicHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: readonly unknown[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	describe("getModel", () => {
+		it("should return the fast mode model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-6:fast",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-6:fast")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-6:fast"])
+		})
+
+		it("should return the 1m fast mode model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-6:1m:fast",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-6:1m:fast")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-6:1m:fast"])
+		})
+
+		it("should return the 4.7 model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-7",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-7")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-7"])
+		})
+
+		it("should return the 4.7 1m model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-7:1m",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-7:1m")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-7:1m"])
+		})
+
+		it("should return the Opus 5 model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-5",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-5")
+			result.info.should.deepEqual(anthropicModels["claude-opus-5"])
+		})
+
+		it("should return the Opus 5 1m model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-5:1m",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-5:1m")
+			result.info.should.deepEqual(anthropicModels["claude-opus-5:1m"])
+		})
+
+		it("should return the 4.8 model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-8",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-8")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-8"])
+		})
+
+		it("should return the 4.8 1m model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-8:1m",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-opus-4-8:1m")
+			result.info.should.deepEqual(anthropicModels["claude-opus-4-8:1m"])
+		})
+
+		it("should return the Fable 5 model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-fable-5",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-fable-5")
+			result.info.should.deepEqual(anthropicModels["claude-fable-5"])
+		})
+
+		it("should return the Fable 5 1m model when configured", () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-fable-5:1m",
+			})
+
+			const result = handler.getModel()
+
+			result.id.should.equal("claude-fable-5:1m")
+			result.info.should.deepEqual(anthropicModels["claude-fable-5:1m"])
+		})
+	})
+
+	describe("createMessage", () => {
+		it("should route fast mode requests through the beta messages API", async () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-6:fast",
+			})
+
+			const standardCreate = sinon.stub().resolves(createAsyncIterable())
+			const betaCreate = sinon.stub().callsFake(function (this: { _client?: object }, _params: unknown) {
+				should.exist(this._client)
+				return Promise.resolve(createAsyncIterable())
+			})
+
+			sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+				messages: {
+					create: standardCreate,
+				},
+				beta: {
+					messages: {
+						_client: {},
+						create: betaCreate,
+					},
+				},
+			})
+
+			for await (const _chunk of handler.createMessage("system prompt", [{ role: "user", content: "Hello" }])) {
+			}
+
+			sinon.assert.notCalled(standardCreate)
+			sinon.assert.calledOnce(betaCreate)
+			sinon.assert.calledWithMatch(betaCreate, {
+				model: "claude-opus-4-6",
+				betas: [ANTHROPIC_FAST_MODE_BETA],
+				speed: "fast",
+				stream: true,
+			})
+		})
+
+		it("should include the 1m beta when routing 1m fast mode requests through the beta messages API", async () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-6:1m:fast",
+			})
+
+			const standardCreate = sinon.stub().resolves(createAsyncIterable())
+			const betaCreate = sinon.stub().callsFake(function (this: { _client?: object }, _params: unknown) {
+				should.exist(this._client)
+				return Promise.resolve(createAsyncIterable())
+			})
+
+			sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+				messages: {
+					create: standardCreate,
+				},
+				beta: {
+					messages: {
+						_client: {},
+						create: betaCreate,
+					},
+				},
+			})
+
+			for await (const _chunk of handler.createMessage("system prompt", [{ role: "user", content: "Hello" }])) {
+			}
+
+			sinon.assert.notCalled(standardCreate)
+			sinon.assert.calledOnce(betaCreate)
+			sinon.assert.calledWithMatch(betaCreate, {
+				model: "claude-opus-4-6",
+				betas: [ANTHROPIC_FAST_MODE_BETA, "context-1m-2025-08-07"],
+				speed: "fast",
+				stream: true,
+			})
+		})
+
+		it("should include the 1m beta header for Claude Opus 4.7 1m requests", async () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-7:1m",
+				reasoningEffort: "high",
+			})
+
+			const standardCreate = sinon.stub().resolves(createAsyncIterable())
+
+			sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+				messages: {
+					create: standardCreate,
+				},
+				beta: {
+					messages: {
+						_client: {},
+						create: sinon.stub().resolves(createAsyncIterable()),
+					},
+				},
+			})
+
+			for await (const _chunk of handler.createMessage("system prompt", [{ role: "user", content: "Hello" }])) {
+			}
+
+			sinon.assert.calledOnce(standardCreate)
+			const requestBody = standardCreate.firstCall.args[0] as Record<string, any>
+			const requestOptions = standardCreate.firstCall.args[1] as Record<string, any>
+			requestBody.model.should.equal("claude-opus-4-7")
+			requestBody.thinking.should.deepEqual({ type: "adaptive" })
+			requestOptions.should.deepEqual({
+				headers: {
+					"anthropic-beta": "context-1m-2025-08-07",
+				},
+			})
+		})
+
+		it("should use adaptive thinking and output_config for Claude Opus adaptive models", async () => {
+			const handler = new AnthropicHandler({
+				apiKey: "test-api-key",
+				apiModelId: "claude-opus-4-7",
+				reasoningEffort: "xhigh",
+			})
+
+			const standardCreate = sinon.stub().resolves(createAsyncIterable())
+
+			sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+				messages: {
+					create: standardCreate,
+				},
+				beta: {
+					messages: {
+						_client: {},
+						create: sinon.stub().resolves(createAsyncIterable()),
+					},
+				},
+			})
+
+			for await (const _chunk of handler.createMessage("system prompt", [{ role: "user", content: "Hello" }])) {
+			}
+
+			sinon.assert.calledOnce(standardCreate)
+			const requestBody = standardCreate.firstCall.args[0] as Record<string, any>
+			requestBody.should.have.property("thinking")
+			requestBody.thinking.should.deepEqual({ type: "adaptive" })
+			requestBody.should.have.property("output_config")
+			requestBody.output_config.should.deepEqual({ effort: "xhigh" })
+			should(requestBody.temperature).equal(undefined)
+		})
+	})
+})

apps/vscode/src/core/api/providers/__tests__/claude-code.test.ts

@@ -0,0 +1,528 @@
+import { afterEach, beforeEach, describe, it } from "mocha"
+import sinon from "sinon"
+import "should"
+import { ClaudeCodeHandler } from "@core/api/providers/claude-code"
+import { ClineStorageMessage } from "@/shared/messages/content"
+
+describe("ClaudeCodeHandler", () => {
+	let handler: ClaudeCodeHandler
+	let sandbox: sinon.SinonSandbox
+
+	beforeEach(() => {
+		sandbox = sinon.createSandbox()
+		handler = new ClaudeCodeHandler({
+			claudeCodePath: "/mock/path",
+			apiModelId: "claude-opus-4-1-20250805",
+		})
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe("token counting", () => {
+		it("should correctly handle token usage from assistant messages", async () => {
+			// The 'input_tokens' field represents the TOTAL number of input tokens used.
+			// See https://docs.anthropic.com/en/api/messages#usage-object
+
+			// Mock the runClaudeCode function
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			// Create a proper async generator mock for the Claude Code response
+			async function* mockGenerator() {
+				// First yield the system init
+				yield {
+					type: "system",
+					subtype: "init",
+					apiKeySource: "api",
+				}
+
+				// Yield assistant message with usage data
+				// Example: If base input is 70 tokens, cache read is 20, and cache creation is 10,
+				// then input_tokens from Anthropic API will be 100 (70 + 20 + 10)
+				yield {
+					type: "assistant",
+					message: {
+						content: [
+							{
+								type: "text",
+								text: "Test response",
+							},
+						],
+						usage: {
+							input_tokens: 100, // Total including cache (per Anthropic docs)
+							output_tokens: 50,
+							cache_read_input_tokens: 20, // Already included in input_tokens
+							cache_creation_input_tokens: 10, // Already included in input_tokens
+						},
+						stop_reason: "end_turn",
+					},
+				}
+
+				// Yield result with cost
+				yield {
+					type: "result",
+					result: {},
+					total_cost_usd: 0.005,
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: ClineStorageMessage[] = [{ role: "user", content: "Hello" }]
+
+			const usageData: any[] = []
+
+			// Collect the results
+			for await (const chunk of handler.createMessage(systemPrompt, messages)) {
+				if (chunk.type === "usage") {
+					usageData.push({
+						inputTokens: chunk.inputTokens,
+						outputTokens: chunk.outputTokens,
+						cacheReadTokens: chunk.cacheReadTokens,
+						cacheWriteTokens: chunk.cacheWriteTokens,
+						totalCost: chunk.totalCost,
+					})
+				}
+			}
+
+			// Verify token counting follows Anthropic API specification
+			usageData.should.have.length(1)
+			usageData[0].should.deepEqual({
+				inputTokens: 100, // Total including cache tokens (per Anthropic API docs)
+				outputTokens: 50,
+				cacheReadTokens: 20, // Tracked separately for reporting
+				cacheWriteTokens: 10, // Tracked separately for reporting
+				totalCost: 0.005,
+			})
+
+			// CRITICAL ASSERTION: Verify that input_tokens is NOT inflated by re-adding cache tokens
+			// The bug would have caused inputTokens to be incorrectly calculated as 130 (100 + 20 + 10)
+			// The fix ensures it remains 100, as per Anthropic's specification
+			usageData[0].inputTokens.should.equal(100) // Correct: matches API response
+			usageData[0].inputTokens.should.not.equal(130) // Would be wrong: double-counting cache tokens
+		})
+
+		it("should handle missing usage fields with nullish coalescing", async () => {
+			// Mock the runClaudeCode function
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			// Create a proper async generator mock with missing/undefined usage fields
+			async function* mockGenerator() {
+				yield {
+					type: "assistant",
+					message: {
+						content: [
+							{
+								type: "text",
+								text: "Test response",
+							},
+						],
+						usage: {
+							input_tokens: 100,
+							output_tokens: 50,
+							// cache fields are undefined/missing
+						},
+						stop_reason: "end_turn",
+					},
+				}
+
+				yield {
+					type: "result",
+					result: {},
+					total_cost_usd: 0.005,
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: ClineStorageMessage[] = [{ role: "user", content: "Hello" }]
+
+			const usageData: any[] = []
+
+			// Collect the results
+			for await (const chunk of handler.createMessage(systemPrompt, messages)) {
+				if (chunk.type === "usage") {
+					usageData.push({
+						inputTokens: chunk.inputTokens,
+						outputTokens: chunk.outputTokens,
+						cacheReadTokens: chunk.cacheReadTokens,
+						cacheWriteTokens: chunk.cacheWriteTokens,
+					})
+				}
+			}
+
+			// Verify that undefined cache tokens default to 0
+			usageData.should.have.length(1)
+			usageData[0].should.deepEqual({
+				inputTokens: 100,
+				outputTokens: 50,
+				cacheReadTokens: 0, // Should default to 0
+				cacheWriteTokens: 0, // Should default to 0
+			})
+		})
+
+		it("should handle completely missing usage object", async () => {
+			// Mock the runClaudeCode function
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			// Create a proper async generator mock with missing usage object
+			async function* mockGenerator() {
+				yield {
+					type: "assistant",
+					message: {
+						content: [
+							{
+								type: "text",
+								text: "Test response",
+							},
+						],
+						// usage is undefined
+						usage: undefined,
+						stop_reason: "end_turn",
+					},
+				}
+
+				// Need to yield a result chunk to trigger usage data emission
+				yield {
+					type: "result",
+					result: {},
+					total_cost_usd: 0,
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			const systemPrompt = "You are a helpful assistant."
+			const messages: ClineStorageMessage[] = [{ role: "user", content: "Hello" }]
+
+			const usageData: any[] = []
+
+			// Collect the results
+			for await (const chunk of handler.createMessage(systemPrompt, messages)) {
+				if (chunk.type === "usage") {
+					usageData.push({
+						inputTokens: chunk.inputTokens,
+						outputTokens: chunk.outputTokens,
+						cacheReadTokens: chunk.cacheReadTokens,
+						cacheWriteTokens: chunk.cacheWriteTokens,
+					})
+				}
+			}
+
+			// All token counts should default to 0 when usage is undefined
+			usageData.should.have.length(1)
+			usageData[0].should.deepEqual({
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			})
+		})
+	})
+
+	describe("error handling", () => {
+		it("should not crash when assistant message has empty content array", async () => {
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			async function* mockGenerator() {
+				yield {
+					type: "assistant",
+					message: {
+						content: [], // empty content — triggered TypeError in older code
+						usage: {
+							input_tokens: 10,
+							output_tokens: 0,
+						},
+						stop_reason: "end_turn",
+					},
+				}
+
+				yield {
+					type: "result",
+					result: {},
+					total_cost_usd: 0,
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			const chunks: any[] = []
+			// Should not throw
+			for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+				chunks.push(chunk)
+			}
+
+			const usageChunk = chunks.find((c) => c.type === "usage")
+			usageChunk.should.be.ok()
+			usageChunk.inputTokens.should.equal(10)
+		})
+
+		it("should throw when result has is_error=true (e.g. rate limit with no assistant message)", async () => {
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			async function* mockGenerator() {
+				yield {
+					type: "system",
+					subtype: "init",
+					apiKeySource: "none",
+				}
+
+				yield {
+					type: "system",
+					subtype: "rate_limit_event",
+					message: "Rate limit hit",
+					retryAfterSeconds: 30,
+				}
+
+				// No assistant message — CLI hit rate limit and gave up
+				yield {
+					type: "result",
+					subtype: "error",
+					is_error: true,
+					result: "Rate limit exceeded",
+					total_cost_usd: 0,
+					duration_ms: 1000,
+					duration_api_ms: 500,
+					num_turns: 0,
+					session_id: "test",
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			let thrownError: Error | undefined
+			try {
+				for await (const _ of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+					// consume
+				}
+			} catch (err) {
+				thrownError = err as Error
+			}
+
+			thrownError!.message.should.containEql("Rate limit exceeded")
+		})
+
+		it("should ignore rate_limit_event system messages without throwing", async () => {
+			const runClaudeCodeModule = await import("@/integrations/claude-code/run")
+			const runClaudeCodeStub = sandbox.stub(runClaudeCodeModule, "runClaudeCode")
+
+			async function* mockGenerator() {
+				yield {
+					type: "system",
+					subtype: "init",
+					apiKeySource: "none",
+				}
+
+				// Newer Claude Code CLI emits this during rate limiting
+				yield {
+					type: "system",
+					subtype: "rate_limit_event",
+					message: "Rate limit hit, retrying...",
+					retryAfterSeconds: 30,
+				}
+
+				yield {
+					type: "assistant",
+					message: {
+						content: [{ type: "text", text: "Response after retry" }],
+						usage: { input_tokens: 20, output_tokens: 10 },
+						stop_reason: "end_turn",
+					},
+				}
+
+				yield {
+					type: "result",
+					result: {},
+					total_cost_usd: 0,
+				}
+			}
+
+			runClaudeCodeStub.returns(mockGenerator() as any)
+
+			const textChunks: string[] = []
+			for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+				if (chunk.type === "text") textChunks.push(chunk.text)
+			}
+
+			textChunks.should.deepEqual(["Response after retry"])
+		})
+	})
+
+	describe("getModel", () => {
+		it("should return the correct model when specified", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-sonnet-4-5-20250929",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-sonnet-4-5-20250929")
+		})
+
+		it("should support Opus 4.6 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-4-6[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-4-6[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Opus 4.7 model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-4-7",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-4-7")
+			model.info.contextWindow.should.equal(200_000)
+		})
+
+		it("should support Opus 4.7 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-4-7[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-4-7[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Opus 5 model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-5",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-5")
+			model.info.contextWindow.should.equal(200_000)
+		})
+
+		it("should support Opus 5 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-5[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-5[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Opus 4.8 model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-4-8",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-4-8")
+			model.info.contextWindow.should.equal(200_000)
+		})
+
+		it("should support Opus 4.8 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-opus-4-8[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-opus-4-8[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Fable 5 model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-fable-5",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-fable-5")
+			model.info.contextWindow.should.equal(200_000)
+		})
+
+		it("should support Sonnet 5 model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-sonnet-5",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-sonnet-5")
+			model.info.contextWindow.should.equal(200_000)
+		})
+
+		it("should support Sonnet 5 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-sonnet-5[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-sonnet-5[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Fable 5 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-fable-5[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-fable-5[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Opus 1m alias model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "opus[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("opus[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Sonnet 1m alias model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "sonnet[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("sonnet[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Sonnet 4.5 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-sonnet-4-5-20250929[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-sonnet-4-5-20250929[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should support Sonnet 4.6 1m model id", () => {
+			const handler = new ClaudeCodeHandler({
+				apiModelId: "claude-sonnet-4-6[1m]",
+			})
+
+			const model = handler.getModel()
+			model.id.should.equal("claude-sonnet-4-6[1m]")
+			model.info.contextWindow.should.equal(1_000_000)
+		})
+
+		it("should return default model when not specified", () => {
+			const handler = new ClaudeCodeHandler({})
+
+			const model = handler.getModel()
+			// The default model should be set
+			model.id.should.be.type("string")
+			model.info.should.be.type("object")
+		})
+	})
+})

apps/vscode/src/core/api/providers/__tests__/cline.test.ts

@@ -0,0 +1,197 @@
+import "should"
+import { openRouterDefaultModelInfo } from "@shared/api"
+import sinon from "sinon"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
+import { ClineError, ClineErrorType } from "@/services/error/ClineError"
+import { ClineHandler } from "../cline"
+
+describe("ClineHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	const createHandler = (options: ConstructorParameters<typeof ClineHandler>[0]) => {
+		sinon.stub(ClineAccountService, "getInstance").returns({} as any)
+		sinon.stub(AuthService, "getInstance").returns({} as any)
+		return new ClineHandler(options)
+	}
+
+	it("should handle usage-only chunks when delta is missing", async () => {
+		const handler = createHandler({})
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 17,
+									completion_tokens: 9,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler, "getModel").returns({
+			id: "openai/gpt-4o-mini",
+			info: openRouterDefaultModelInfo,
+		})
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				cacheWriteTokens: 0,
+				cacheReadTokens: 0,
+				inputTokens: 17,
+				outputTokens: 9,
+				totalCost: 0,
+			},
+		])
+	})
+
+	it("should read Anthropic-style cache creation and read tokens from usage chunks", async () => {
+		const handler = createHandler({})
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 1000,
+									completion_tokens: 200,
+									prompt_tokens_details: {
+										cached_tokens: 500,
+									},
+									cache_creation_input_tokens: 300,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler, "getModel").returns({
+			id: "anthropic/claude-sonnet-4.6",
+			info: openRouterDefaultModelInfo,
+		})
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				cacheWriteTokens: 300,
+				cacheReadTokens: 500,
+				inputTokens: 200,
+				outputTokens: 200,
+				totalCost: 0,
+			},
+		])
+	})
+
+	it("should forward enableParallelToolCalling to OpenRouter payload", async () => {
+		const handler = createHandler({ enableParallelToolCalling: true })
+		const createStub = sinon.stub().resolves(createAsyncIterable([]))
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: createStub,
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler, "getModel").returns({
+			id: "openai/gpt-4o-mini",
+			info: openRouterDefaultModelInfo,
+		})
+
+		const tools = [
+			{ type: "function", function: { name: "read_file", description: "", parameters: { type: "object" } } },
+		] as any
+		for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }], tools)) {
+			// drain stream
+		}
+
+		const payload = createStub.firstCall.args[0]
+		payload.parallel_tool_calls.should.equal(true)
+	})
+
+	it("should send cache_control for qwen3.7-max without changing the selected Cline model id", async () => {
+		const handler = createHandler({
+			openRouterModelId: "qwen/qwen3.7-max",
+			openRouterModelInfo: openRouterDefaultModelInfo,
+		})
+		const createStub = sinon.stub().resolves(createAsyncIterable([]))
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: createStub,
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler as any, "getFreeModelIdSet").resolves(new Set())
+
+		for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			// drain stream
+		}
+
+		handler.getModel().id.should.equal("qwen/qwen3.7-max")
+		const payload = createStub.firstCall.args[0]
+		payload.model.should.equal("qwen/qwen3.7-max")
+		payload.messages[0].content[0].cache_control.should.deepEqual({ type: "ephemeral" })
+		payload.messages[1].content[0].cache_control.should.deepEqual({ type: "ephemeral" })
+	})
+
+	it("propagates a pre-stream 403 entitlement error so it classifies as Entitlement", async () => {
+		const handler = createHandler({})
+		// A 403 from ValidateModelEntitlement rejects completions.create() before streaming,
+		// matching the OpenAI SDK APIError shape (status + code + error body).
+		const apiError = Object.assign(new Error("403 the user is not subscribed to required model plan"), {
+			status: 403,
+			code: "ENTITLEMENT_ERROR",
+			error: {
+				code: "ENTITLEMENT_ERROR",
+				message: "Error 403: the user is not subscribed to required model plan",
+			},
+		})
+		const fakeClient = { chat: { completions: { create: sinon.stub().rejects(apiError) } } }
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler as any, "getFreeModelIdSet").resolves(new Set())
+		sinon.stub(handler, "getModel").returns({ id: "cline-pass/glm-5.2", info: openRouterDefaultModelInfo })
+
+		let thrown: unknown
+		try {
+			for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+				// drain
+			}
+		} catch (e) {
+			thrown = e
+		}
+
+		const clineError = ClineError.transform(thrown, "cline-pass/glm-5.2", "cline-pass")
+		clineError.isErrorType(ClineErrorType.Entitlement).should.be.true()
+	})
+})

apps/vscode/src/core/api/providers/__tests__/fireworks.test.ts

@@ -0,0 +1,97 @@
+import "should"
+import sinon from "sinon"
+import { FireworksHandler } from "../fireworks"
+
+describe("FireworksHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	it("should handle usage-only chunks when delta is missing", async () => {
+		const handler = new FireworksHandler({
+			fireworksApiKey: "test-api-key",
+			fireworksModelId: "accounts/fireworks/models/llama-v3p1-8b-instruct",
+		})
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 19,
+									completion_tokens: 4,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				inputTokens: 19,
+				outputTokens: 4,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+			},
+		])
+	})
+
+	it("should read cache hits from prompt_tokens_details when hit tokens are not present", async () => {
+		const handler = new FireworksHandler({
+			fireworksApiKey: "test-api-key",
+			fireworksModelId: "accounts/fireworks/models/llama-v3p1-8b-instruct",
+		})
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 60,
+									completion_tokens: 12,
+									prompt_tokens_details: { cached_tokens: 20 },
+									prompt_cache_miss_tokens: 40,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				inputTokens: 60,
+				outputTokens: 12,
+				cacheReadTokens: 20,
+				cacheWriteTokens: 40,
+			},
+		])
+	})
+})

apps/vscode/src/core/api/providers/__tests__/gemini.test.ts

@@ -0,0 +1,235 @@
+import "should"
+import sinon from "sinon"
+import { GeminiHandler } from "../gemini"
+
+describe("GeminiHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	it("caps maxOutputTokens to 8192 for Flash models", async () => {
+		const handler = new GeminiHandler({
+			geminiApiKey: "test-api-key",
+			apiModelId: "gemini-2.5-flash",
+		})
+
+		const generateContentStream = sinon.stub().resolves(
+			createAsyncIterable([
+				{
+					responseId: "resp-1",
+					usageMetadata: {
+						promptTokenCount: 10,
+						candidatesTokenCount: 20,
+						cachedContentTokenCount: 0,
+						thoughtsTokenCount: 0,
+					},
+				},
+			]),
+		)
+		sinon.stub(handler as any, "ensureClient").returns({
+			models: { generateContentStream },
+		} as any)
+
+		for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }] as any)) {
+			// Consume stream to trigger request execution.
+		}
+
+		const requestArgs = generateContentStream.firstCall.args[0] as Record<string, any>
+		requestArgs.config.should.have.property("maxOutputTokens", 8_192)
+	})
+
+	it("supports Gemini 3.5 Flash model metadata", async () => {
+		const handler = new GeminiHandler({
+			geminiApiKey: "test-api-key",
+			apiModelId: "gemini-3.5-flash",
+		})
+
+		const model = handler.getModel()
+		model.id.should.equal("gemini-3.5-flash")
+		model.info.contextWindow!.should.equal(1_048_576)
+		model.info.inputPrice!.should.equal(1.5)
+		model.info.outputPrice!.should.equal(9)
+		model.info.cacheReadsPrice!.should.equal(0.15)
+		model.info.supportsReasoning!.should.equal(true)
+
+		const generateContentStream = sinon.stub().resolves(
+			createAsyncIterable([
+				{
+					responseId: "resp-35",
+					usageMetadata: {
+						promptTokenCount: 10,
+						candidatesTokenCount: 20,
+						cachedContentTokenCount: 0,
+						thoughtsTokenCount: 0,
+					},
+				},
+			]),
+		)
+		sinon.stub(handler as any, "ensureClient").returns({
+			models: { generateContentStream },
+		} as any)
+
+		for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }] as any)) {
+			// Consume stream to trigger request execution.
+		}
+
+		const requestArgs = generateContentStream.firstCall.args[0] as Record<string, any>
+		requestArgs.model.should.equal("gemini-3.5-flash")
+		requestArgs.config.should.have.property("maxOutputTokens", 8_192)
+		requestArgs.config.thinkingConfig.should.deepEqual({
+			thinkingBudget: undefined,
+			thinkingLevel: "LOW",
+			includeThoughts: true,
+		})
+	})
+
+	it("does not set maxOutputTokens for non-Flash models", async () => {
+		const handler = new GeminiHandler({
+			geminiApiKey: "test-api-key",
+			apiModelId: "gemini-2.5-pro",
+		})
+
+		const generateContentStream = sinon.stub().resolves(
+			createAsyncIterable([
+				{
+					responseId: "resp-2",
+					usageMetadata: {
+						promptTokenCount: 10,
+						candidatesTokenCount: 20,
+						cachedContentTokenCount: 0,
+						thoughtsTokenCount: 0,
+					},
+				},
+			]),
+		)
+		sinon.stub(handler as any, "ensureClient").returns({
+			models: { generateContentStream },
+		} as any)
+
+		for await (const _chunk of handler.createMessage("system", [{ role: "user", content: "hi" }] as any)) {
+			// Consume stream to trigger request execution.
+		}
+
+		const requestArgs = generateContentStream.firstCall.args[0] as Record<string, any>
+		requestArgs.config.should.not.have.property("maxOutputTokens")
+	})
+
+	it("should emit unique tool call IDs when multiple function calls share one responseId", async () => {
+		const handler = new GeminiHandler({
+			geminiApiKey: "test-api-key",
+		})
+
+		const fakeClient = {
+			models: {
+				generateContentStream: sinon.stub().resolves(
+					createAsyncIterable([
+						{
+							responseId: "resp_1",
+							candidates: [
+								{
+									content: {
+										parts: [
+											{
+												functionCall: {
+													name: "read_file",
+													args: { path: ".nvmrc" },
+												},
+											},
+										],
+									},
+								},
+							],
+						},
+						{
+							responseId: "resp_1",
+							candidates: [
+								{
+									content: {
+										parts: [
+											{
+												functionCall: {
+													name: "read_file",
+													args: { path: ".gitattributes" },
+												},
+											},
+										],
+									},
+								},
+							],
+						},
+					]),
+				),
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+
+		const tools = [{ name: "read_file", description: "read file", parameters: { type: "OBJECT" } }] as any
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }], tools)) {
+			if (chunk.type === "tool_calls") {
+				chunks.push(chunk)
+			}
+		}
+
+		chunks.should.have.length(2)
+		chunks[0].tool_call.function.id.should.equal("resp_1-tool-0")
+		chunks[1].tool_call.function.id.should.equal("resp_1-tool-1")
+		chunks[0].tool_call.call_id.should.equal(chunks[0].tool_call.function.id)
+		chunks[1].tool_call.call_id.should.equal(chunks[1].tool_call.function.id)
+		JSON.parse(chunks[0].tool_call.function.arguments).path.should.equal(".nvmrc")
+		JSON.parse(chunks[1].tool_call.function.arguments).path.should.equal(".gitattributes")
+	})
+
+	it("should preserve Gemini-provided functionCall.id when present", async () => {
+		const handler = new GeminiHandler({
+			geminiApiKey: "test-api-key",
+		})
+
+		const fakeClient = {
+			models: {
+				generateContentStream: sinon.stub().resolves(
+					createAsyncIterable([
+						{
+							responseId: "resp_2",
+							candidates: [
+								{
+									content: {
+										parts: [
+											{
+												functionCall: {
+													id: "call_alpha",
+													name: "read_file",
+													args: { path: ".nvmrc" },
+												},
+											},
+										],
+									},
+								},
+							],
+						},
+					]),
+				),
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+
+		const tools = [{ name: "read_file", description: "read file", parameters: { type: "OBJECT" } }] as any
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }], tools)) {
+			if (chunk.type === "tool_calls") {
+				chunks.push(chunk)
+			}
+		}
+
+		chunks.should.have.length(1)
+		chunks[0].tool_call.function.id.should.equal("call_alpha")
+		chunks[0].tool_call.call_id.should.equal("call_alpha")
+		JSON.parse(chunks[0].tool_call.function.arguments).path.should.equal(".nvmrc")
+	})
+})

apps/vscode/src/core/api/providers/__tests__/huggingface.test.ts

@@ -0,0 +1,43 @@
+import "should";
+import {
+	huggingFaceDefaultModelId,
+	huggingFaceModels,
+} from "../../../../shared/api";
+import { HuggingFaceHandler } from "../huggingface";
+
+describe("HuggingFaceHandler", () => {
+	it("uses dynamic Hugging Face model info for models outside the static list", () => {
+		const modelInfo = {
+			maxTokens: 8192,
+			contextWindow: 128_000,
+			supportsImages: false,
+			supportsPromptCache: false,
+			inputPrice: 0,
+			outputPrice: 0,
+			description: "Available on providers: test-provider",
+		};
+
+		const handler = new HuggingFaceHandler({
+			huggingFaceApiKey: "test-api-key",
+			huggingFaceModelId: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+			huggingFaceModelInfo: modelInfo,
+		});
+
+		handler.getModel().should.deepEqual({
+			id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+			info: modelInfo,
+		});
+	});
+
+	it("preserves unknown model IDs when model info is unavailable", () => {
+		const handler = new HuggingFaceHandler({
+			huggingFaceApiKey: "test-api-key",
+			huggingFaceModelId: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+		});
+
+		handler.getModel().should.deepEqual({
+			id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+			info: huggingFaceModels[huggingFaceDefaultModelId],
+		});
+	});
+});

apps/vscode/src/core/api/providers/__tests__/litellm.test.ts

@@ -0,0 +1,326 @@
+import { LiteLlmHandler, type LiteLlmModelInfoResponse } from "@core/api/providers/litellm"
+import { convertToOpenAiMessages } from "@core/api/transform/openai-format"
+import { liteLlmModelInfoSaneDefaults } from "@shared/api" // used in getModel tests
+import { expect } from "chai"
+import sinon from "sinon"
+import { StateManager } from "@/core/storage/StateManager" // used in getModel tests
+import { ClineStorageMessage } from "@/shared/messages/content"
+import { mockFetchForTesting } from "@/shared/net"
+
+const fakeClient = {
+	chat: {
+		completions: {
+			create: sinon.stub(),
+		},
+	},
+	baseURL: "https://fake.example",
+}
+
+describe("LiteLlmHandler", () => {
+	const mockFetch = sinon.stub()
+	let doneMockingFetch: (value: any) => void = () => {}
+
+	const mockModelFetch = (modelInfo: LiteLlmModelInfoResponse["data"][number]) => {
+		mockFetch.resolves({
+			ok: true,
+			json: () =>
+				Promise.resolve({
+					data: [modelInfo],
+				}),
+		})
+	}
+
+	let handler: LiteLlmHandler
+
+	const mockHandlerChat = () => {
+		sinon.stub(handler, "ensureClient" as any).returns(fakeClient)
+	}
+
+	const initializeHandler = (model: string) => {
+		handler = new LiteLlmHandler({
+			liteLlmApiKey: "test-api-key",
+			liteLlmBaseUrl: "http://localhost:4000",
+			liteLlmUsePromptCache: true,
+			liteLlmModelId: model,
+		})
+
+		mockHandlerChat()
+	}
+
+	beforeEach(() => {
+		fakeClient.chat.completions.create.resetHistory()
+
+		mockFetchForTesting(mockFetch, () => {
+			return new Promise((resolve) => {
+				doneMockingFetch = resolve
+			})
+		})
+
+		// Configure the stub to return a stream that closes immediately with usage data
+		fakeClient.chat.completions.create.resolves(
+			createAsyncIterable([
+				{
+					choices: [{ delta: { content: "test response" } }],
+				},
+				{
+					choices: [{}],
+					usage: {
+						prompt_tokens: 100,
+						completion_tokens: 50,
+						cache_creation_input_tokens: 20,
+						cache_read_input_tokens: 10,
+					},
+				},
+			]),
+		)
+	})
+
+	afterEach(() => {
+		sinon.reset()
+		doneMockingFetch(void 0)
+	})
+
+	const createAsyncIterable = (data: any[] = []) => {
+		return {
+			[Symbol.asyncIterator]: async function* () {
+				yield* data
+			},
+		}
+	}
+
+	describe("prompt cache", () => {
+		const setModelData = (model: string, supportsPromptCaching: boolean) => {
+			mockModelFetch({
+				model_name: model,
+				litellm_params: {
+					model,
+				},
+				model_info: {
+					supports_prompt_caching: supportsPromptCaching,
+					input_cost_per_token: 0.01,
+					output_cost_per_token: 0.02,
+				},
+			})
+		}
+
+		describe("when the model doesn't support prompt caching", () => {
+			const model = "openai/gpt-5"
+
+			beforeEach(() => {
+				initializeHandler(model)
+				setModelData(model, false)
+			})
+
+			it("sends the system prompt and messages with the openai format", async () => {
+				const systemPrompt = "Test System Prompt"
+				const messages: ClineStorageMessage[] = [
+					{
+						role: "user",
+						content: "first message",
+					},
+					{
+						role: "assistant",
+						content: "first response",
+					},
+					{
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: "test",
+							},
+							{
+								type: "text",
+								text: "second message",
+							},
+						],
+					},
+				]
+
+				for await (const _ of handler.createMessage(systemPrompt, messages)) {
+				}
+
+				sinon.assert.calledOnce(fakeClient.chat.completions.create)
+
+				const callArgs = fakeClient.chat.completions.create.getCall(0).args[0]
+
+				const systemPromptMessage = callArgs.messages.shift()
+				expect(systemPromptMessage).to.deep.equal({
+					role: "system",
+					content: systemPrompt,
+				})
+
+				expect(callArgs.messages).to.deep.equal(convertToOpenAiMessages(messages))
+			})
+		})
+
+		describe("when the model supports prompt caching", () => {
+			const model = "anthropic/claude-sonnet-4-20250514"
+
+			beforeEach(() => {
+				initializeHandler(model)
+
+				setModelData(model, true)
+			})
+
+			it("inserts the cache control in the system prompt and the last two user messages", async () => {
+				const systemPrompt = "Test System Prompt"
+				const messages: ClineStorageMessage[] = [
+					{
+						role: "user",
+						content: "first message",
+					},
+					{
+						role: "assistant",
+						content: "first response",
+					},
+					{
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: "test",
+							},
+							{
+								type: "text",
+								text: "second message",
+							},
+						],
+					},
+				]
+
+				for await (const _ of handler.createMessage(systemPrompt, messages)) {
+				}
+
+				sinon.assert.calledOnce(fakeClient.chat.completions.create)
+
+				const callArgs = fakeClient.chat.completions.create.getCall(0).args[0]
+
+				expect(callArgs.messages[0]).to.deep.equal({
+					role: "system",
+					content: [
+						{
+							text: systemPrompt,
+							type: "text",
+							cache_control: {
+								type: "ephemeral",
+							},
+						},
+					],
+				})
+
+				const sentMessages = callArgs.messages
+				expect(sentMessages.length).to.equal(4)
+
+				const firstUserMessage = sentMessages[1]
+
+				expect(firstUserMessage).to.deep.equal({
+					role: "user",
+					content: [
+						{
+							type: "text",
+							text: "first message",
+							cache_control: {
+								type: "ephemeral",
+							},
+						},
+					],
+				})
+
+				const lastUserMessage = sentMessages[3]
+				expect(lastUserMessage.content[0]).to.deep.equal({
+					type: "text",
+					text: "test",
+				})
+
+				const lastContentBlock = lastUserMessage.content[lastUserMessage.content.length - 1]
+				expect(lastContentBlock).to.deep.equal({
+					type: "text",
+					text: "second message",
+					cache_control: {
+						type: "ephemeral",
+					},
+				})
+
+				expect(callArgs.model).to.be.a("string")
+				expect(callArgs.stream).to.equal(true)
+				expect(callArgs.stream_options).to.deep.equal({ include_usage: true })
+			})
+		})
+	})
+
+	describe("getModel", () => {
+		let stateManagerStub: sinon.SinonStub
+
+		beforeEach(() => {
+			stateManagerStub = sinon.stub(StateManager, "get").returns({
+				getModelInfo: () => null,
+			} as any)
+		})
+
+		afterEach(() => {
+			stateManagerStub.restore()
+		})
+
+		it("returns sane defaults when no liteLlmModelInfo option is provided", () => {
+			const h = new LiteLlmHandler({
+				liteLlmApiKey: "test",
+				liteLlmModelId: "some-model",
+			})
+			const model = h.getModel()
+			expect(model.id).to.equal("some-model")
+			expect(model.info.contextWindow).to.equal(liteLlmModelInfoSaneDefaults.contextWindow)
+		})
+
+		it("returns user-configured model info when liteLlmModelInfo is provided and no cache exists", () => {
+			const h = new LiteLlmHandler({
+				liteLlmApiKey: "test",
+				liteLlmModelId: "claude-sonnet-4-6",
+				liteLlmModelInfo: {
+					contextWindow: 1_000_000,
+					maxTokens: 8192,
+					supportsImages: true,
+					supportsPromptCache: true,
+					inputPrice: 3,
+					outputPrice: 15,
+					cacheWritesPrice: 3.75,
+					cacheReadsPrice: 0.3,
+				},
+			})
+			const model = h.getModel()
+			expect(model.id).to.equal("claude-sonnet-4-6")
+			expect(model.info.contextWindow).to.equal(1_000_000)
+		})
+
+		it("prefers StateManager cached model info over user-configured liteLlmModelInfo", () => {
+			const cachedInfo = {
+				contextWindow: 200_000,
+				maxTokens: 4096,
+				supportsImages: true,
+				supportsPromptCache: true,
+				inputPrice: 0,
+				outputPrice: 0,
+			}
+			stateManagerStub.returns({
+				getModelInfo: () => cachedInfo,
+			} as any)
+
+			const h = new LiteLlmHandler({
+				liteLlmApiKey: "test",
+				liteLlmModelId: "claude-sonnet-4-6",
+				liteLlmModelInfo: {
+					contextWindow: 1_000_000,
+					maxTokens: 8192,
+					supportsImages: true,
+					supportsPromptCache: true,
+					inputPrice: 3,
+					outputPrice: 15,
+					cacheWritesPrice: 3.75,
+					cacheReadsPrice: 0.3,
+				},
+			})
+			const model = h.getModel()
+			expect(model.info.contextWindow).to.equal(200_000)
+		})
+	})
+})

apps/vscode/src/core/api/providers/__tests__/moonshot.test.ts

@@ -0,0 +1,114 @@
+import "should"
+import { moonshotModels } from "@shared/api"
+import type { ClineStorageMessage } from "@shared/messages/content"
+import sinon from "sinon"
+import { MoonshotHandler } from "../moonshot"
+
+interface MoonshotRequestPayload {
+	model: string
+	messages?: Array<{ role: string; reasoning_content?: string }>
+	temperature?: number
+	max_tokens?: number
+	max_completion_tokens?: number
+}
+
+describe("MoonshotHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: unknown[] = []): AsyncIterable<unknown> => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	it("supports kimi-k2.6 model metadata", async () => {
+		const handler = new MoonshotHandler({
+			moonshotApiKey: "test-api-key",
+			apiModelId: "kimi-k2.6",
+		})
+
+		const model = handler.getModel()
+		model.id.should.equal("kimi-k2.6")
+		model.info.should.deepEqual(moonshotModels["kimi-k2.6"])
+
+		const createStub = sinon.stub().resolves(createAsyncIterable([]))
+		sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+			chat: {
+				completions: {
+					create: createStub,
+				},
+			},
+		})
+
+		const messages: ClineStorageMessage[] = [{ role: "user", content: "hi" }]
+		for await (const _chunk of handler.createMessage("system", messages)) {
+			// Consume stream to trigger request execution.
+		}
+
+		const payload = createStub.firstCall.args[0] as MoonshotRequestPayload
+		payload.model.should.equal("kimi-k2.6")
+		should(payload.temperature).equal(moonshotModels["kimi-k2.6"].temperature)
+		should(payload.max_tokens).equal(moonshotModels["kimi-k2.6"].maxTokens)
+	})
+
+	it("supports kimi-k3 request requirements and scopes reasoning replay", async () => {
+		const handler = new MoonshotHandler({
+			moonshotApiKey: "test-api-key",
+			apiModelId: "kimi-k3",
+		})
+
+		const createStub = sinon.stub().resolves(createAsyncIterable([]))
+		sinon.stub(handler as unknown as { ensureClient: () => unknown }, "ensureClient").returns({
+			chat: {
+				completions: {
+					create: createStub,
+				},
+			},
+		})
+
+		const messages: ClineStorageMessage[] = [
+			{ role: "user", content: "foreign-provider question" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "Foreign reasoning", signature: "" },
+					{ type: "text", text: "Foreign answer" },
+				],
+				modelInfo: { providerId: "anthropic", modelId: "claude-sonnet-4", mode: "act" },
+			},
+			{ role: "user", content: "K3 question" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "K3 reasoning", signature: "" },
+					{ type: "text", text: "K3 answer" },
+				],
+				modelInfo: { providerId: "moonshot", modelId: "kimi-k3", mode: "act" },
+			},
+			{ role: "user", content: "legacy question" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "Unattributed reasoning", signature: "" },
+					{ type: "text", text: "Legacy answer" },
+				],
+			},
+			{ role: "user", content: "follow-up question" },
+		]
+		for await (const _chunk of handler.createMessage("system", messages)) {
+			// Consume stream to trigger request execution.
+		}
+
+		const payload = createStub.firstCall.args[0] as MoonshotRequestPayload
+		payload.model.should.equal("kimi-k3")
+		should(payload.max_completion_tokens).equal(moonshotModels["kimi-k3"].maxTokens)
+		should(payload.max_tokens).equal(undefined)
+		should(payload.temperature).equal(undefined)
+		const assistantReasoning = payload.messages
+			?.filter((message) => message.role === "assistant")
+			.map((message) => message.reasoning_content)
+		should(assistantReasoning).deepEqual([undefined, "K3 reasoning", undefined])
+	})
+})

apps/vscode/src/core/api/providers/__tests__/oca.test.ts

@@ -0,0 +1,93 @@
+import { expect } from "chai"
+import { afterEach, describe, it } from "mocha"
+import sinon from "sinon"
+import { ClineStorageMessage } from "@/shared/messages/content"
+import { ApiFormat } from "@/shared/proto/index.cline"
+import { OcaHandler } from "../oca"
+
+const messages: ClineStorageMessage[] = [{ role: "user", content: "Hello" }]
+
+async function collectChunks(stream: AsyncGenerator<any>) {
+	const chunks: any[] = []
+	for await (const chunk of stream) {
+		chunks.push(chunk)
+	}
+	return chunks
+}
+
+describe("OcaHandler.createMessage", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	it("routes OPENAI_RESPONSES models to createMessageResponsesApi", async () => {
+		const handler = new OcaHandler({
+			ocaModelInfo: { apiFormat: ApiFormat.OPENAI_RESPONSES } as any,
+		})
+
+		const chatStub = sinon.stub(handler as any, "createMessageChatApi").callsFake(async function* () {
+			yield { type: "text", text: "chat" }
+		})
+		const responsesStub = sinon.stub(handler as any, "createMessageResponsesApi").callsFake(async function* () {
+			yield { type: "text", text: "responses" }
+		})
+		const messagesStub = sinon.stub(handler as any, "createMessageMessagesApi").callsFake(async function* () {
+			yield { type: "text", text: "messages" }
+		})
+
+		const chunks = await collectChunks(handler.createMessage("system", messages))
+
+		expect(chunks).to.deep.equal([{ type: "text", text: "responses" }])
+		sinon.assert.notCalled(chatStub)
+		sinon.assert.calledOnce(responsesStub)
+		sinon.assert.notCalled(messagesStub)
+	})
+
+	it("routes ANTHROPIC_CHAT models to createMessageMessagesApi", async () => {
+		const handler = new OcaHandler({
+			ocaModelInfo: { apiFormat: ApiFormat.ANTHROPIC_CHAT } as any,
+		})
+
+		const chatStub = sinon.stub(handler as any, "createMessageChatApi").callsFake(async function* () {
+			yield { type: "text", text: "chat" }
+		})
+		const responsesStub = sinon.stub(handler as any, "createMessageResponsesApi").callsFake(async function* () {
+			yield { type: "text", text: "responses" }
+		})
+		const messagesStub = sinon.stub(handler as any, "createMessageMessagesApi").callsFake(async function* () {
+			yield { type: "text", text: "messages" }
+		})
+
+		const chunks = await collectChunks(handler.createMessage("system", messages))
+
+		expect(chunks).to.deep.equal([{ type: "text", text: "messages" }])
+		sinon.assert.notCalled(chatStub)
+		sinon.assert.notCalled(responsesStub)
+		sinon.assert.calledOnce(messagesStub)
+	})
+
+	it("defaults to createMessageChatApi for OPENAI_CHAT and undefined apiFormat", async () => {
+		for (const apiFormat of [ApiFormat.OPENAI_CHAT, undefined]) {
+			const handler = new OcaHandler({
+				ocaModelInfo: { apiFormat } as any,
+			})
+
+			const chatStub = sinon.stub(handler as any, "createMessageChatApi").callsFake(async function* () {
+				yield { type: "text", text: "chat" }
+			})
+			const responsesStub = sinon.stub(handler as any, "createMessageResponsesApi").callsFake(async function* () {
+				yield { type: "text", text: "responses" }
+			})
+			const messagesStub = sinon.stub(handler as any, "createMessageMessagesApi").callsFake(async function* () {
+				yield { type: "text", text: "messages" }
+			})
+
+			const chunks = await collectChunks(handler.createMessage("system", messages))
+
+			expect(chunks).to.deep.equal([{ type: "text", text: "chat" }])
+			sinon.assert.calledOnce(chatStub)
+			sinon.assert.notCalled(responsesStub)
+			sinon.assert.notCalled(messagesStub)
+		}
+	})
+})

apps/vscode/src/core/api/providers/__tests__/ollama.test.ts

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