test: verify latency harness completion flow

llama.cpp's STB image library doesn't support WebP format. Users running
GLM 4.6V, GLM 4.5, and Devstral models via llama.cpp server (openai-compatible
endpoint) were hitting a 400 error when using the browser tool because Cline
sends screenshots as WebP by default.

modelDoesntSupportWebp() only checked for Grok models. Extend it to also
cover GLM and Devstral model families using the existing family detection
functions. Also update isGLMModelFamily() to handle space-separated model IDs
like 'GLM 4.6V' (the format llama.cpp server reports for this model).

Fixes #8203

.changeset/clear-rockets-happen.md

@@ -1,5 +0,0 @@
----
-"cline": minor
----
-
-Adds Messages API support to Oracle Code Assist, adding functionality for Claude models

.changeset/cuddly-phones-count.md

@@ -1,5 +0,0 @@
----
-"cline": patch
----
-
-Add /q command to quit CLI

.changeset/early-beers-glow.md

@@ -1,5 +0,0 @@
----
-"cline": patch
----
-
-Add Additional Markdown Formatting in CLI

.changeset/neat-seals-guess.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Fix a streaming crash when a chunk has usage data but no `delta` by guarding reasoning field checks in provider handlers. Add regression tests for OpenRouter, Cline, Vercel AI Gateway, and Fireworks handlers to cover usage-only chunks.

.changeset/small-bugs-complain.md

@@ -1,4 +0,0 @@
-"claude-dev": patch
----
-
-Add missing smoke evaluation npm scripts so documented commands like `npm run eval:smoke:run` work from the repository root.

.changeset/smoke-test-retries.md

@@ -1,5 +0,0 @@
----
-"cline": patch
----
-
-Add automatic retries (up to 3 attempts) for smoke test CI jobs to reduce flaky failures

.changeset/strong-dolls-beam.md

@@ -1,5 +0,0 @@
----
-"cline": patch
----
-
-add focus ring on action buttons

.changeset/tender-berries-search.md

@@ -1,5 +0,0 @@
----
-"cline": patch
----
-
-fix acp auth check so acp mode can be used with more providers

.changeset/wacky-ends-relax.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Update SambaNova Provider models list and add temperature for models

.env.example

@@ -125,6 +125,12 @@ ERROR_SERVICE_API_KEY=your-posthog-error-tracking-api-key
 # E2E_TEST=true
 # IS_TEST=true
 
+# Remote-workspace latency debugging
+# Disable ephemeral partial message persistence to compare against durable-per-update behavior.
+# CLINE_DISABLE_EPHEMERAL_MESSAGE_PERSISTENCE=true
+# Override periodic safety flush cadence in milliseconds (default: 1500)
+# CLINE_EPHEMERAL_MESSAGE_FLUSH_CADENCE_MS=1500
+
 # ============================================================================
 # USAGE INSTRUCTIONS
 # ============================================================================

.github/copilot-instructions.md

@@ -0,0 +1,58 @@
+# Copilot Instructions for Cline
+
+This is a VS Code extension. Read `.clinerules/general.md` for tribal knowledge and nuanced patterns.
+
+## Architecture
+- **Core** (`src/`): `extension.ts` → `WebviewProvider` → `Controller` (single source of truth) → `Task` (agent loop).
+- **Webview** (`webview-ui/`): React/Vite app. State via `ExtensionStateContext.tsx`, synced through message passing.
+- **CLI** (`cli/`): React Ink terminal UI sharing core logic. Update CLI when changing webview features.
+- **Communication**: Protobuf-defined gRPC-like protocol over VS Code message passing. Schemas in `proto/`.
+- **MCP**: `src/services/mcp/McpHub.ts`.
+
+## Build & Test (Critical — non-obvious commands)
+- **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**: `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`.
+
+## Adding API Providers (silent failure risk)
+Three proto conversion updates are **required** or the provider silently resets to Anthropic:
+1. `proto/cline/models.proto` — add to `ApiProvider` enum.
+2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts`.
+3. `convertProtoToApiProvider()` in the same file.
+
+Also update: `src/shared/api.ts`, `src/shared/providers/providers.json`, `src/core/api/index.ts`, `webview-ui/.../providerUtils.ts`, `webview-ui/.../validate.ts`, `webview-ui/.../ApiOptions.tsx`, and `cli/src/components/ModelPicker.tsx`.
+
+For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/model-utils.ts` and set `apiFormat: ApiFormat.OPENAI_RESPONSES` on models.
+
+## Adding Tools to System Prompt (5+ file chain)
+1. Add enum to `ClineDefaultTool` in `src/shared/tools.ts`.
+2. Create definition in `src/core/prompts/system-prompt/tools/` (export `[GENERIC]` minimum).
+3. Register in `src/core/prompts/system-prompt/tools/init.ts`.
+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 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.
+
+## Global State Keys (silent failure risk)
+Adding a key requires: type in `src/shared/storage/state-keys.ts`, read via `context.globalState.get()` in `src/core/storage/utils/state-helpers.ts` `readGlobalStateFromDisk()`, and add to return object. Missing the `.get()` call compiles fine but value is always `undefined`.
+
+## Slash Commands (3 places)
+- `src/core/slash-commands/index.ts` — definitions.
+- `src/core/prompts/commands.ts` — system prompt integration.
+- `webview-ui/src/utils/slash-commands.ts` — webview autocomplete.
+
+## Conventions
+- **Paths**: Always use `src/utils/path` helpers (`toPosixString`) for cross-platform compatibility.
+- **Logging**: `src/shared/services/Logger.ts`.
+- **Feature flags**: See PR #7566 as reference pattern.

.github/workflows/cli-tui-tests.yml

@@ -0,0 +1,83 @@
+name: CLI TUI Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  cli-tui-tests:
+    name: CLI TUI Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm ci
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build CLI
+        run: npm run cli:build
+
+      - name: Run TUI Tests
+        id: tui_tests
+        run: |
+          npm run test:e2e:cli:tui 2>&1 | tee tui-test-output.log
+          exit_code=${PIPESTATUS[0]}
+          echo "tui_exit_code=$exit_code" >> $GITHUB_OUTPUT
+          exit $exit_code
+
+      - name: Write failure summary
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        run: |
+          echo "## ❌ CLI TUI Tests Failed" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "**Step outcome:** \`${{ steps.tui_tests.outcome }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### Test Output" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          if [ -f tui-test-output.log ]; then
+            cat tui-test-output.log >> $GITHUB_STEP_SUMMARY
+          else
+            echo "(no test output captured — process may have been killed before output was flushed)" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### Debugging" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- **TUI traces** are attached as artifacts below — download and inspect them to see terminal state at the point of failure." >> $GITHUB_STEP_SUMMARY
+          echo "- **To view a trace replay/Run a TUI Trace: ** run \`npx tui-test show-trace path/to/trace/file\` in your terminal" >> $GITHUB_STEP_SUMMARY
+          echo "- **Full test log** is also attached as an artifact." >> $GITHUB_STEP_SUMMARY
+          echo "- Tests run with \`retries: 2\` so any failure shown is a consistent failure, not a flake." >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload TUI traces
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        uses: actions/upload-artifact@v4
+        with:
+          name: tui-test-traces
+          path: tests/e2e/cli/tui-traces/
+          retention-days: 14
+          if-no-files-found: warn
+
+      - name: Upload test log
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        uses: actions/upload-artifact@v4
+        with:
+          name: tui-test-log
+          path: tui-test-output.log
+          retention-days: 14
+          if-no-files-found: warn

.github/workflows/publish-cli-trusted.yaml

@@ -30,7 +30,11 @@ permissions:
   pull-requests: write # Required by nested reusable test workflow
 
 jobs:
+  cli-tui-tests:
+    uses: ./.github/workflows/cli-tui-tests.yml
+
   publish-main:
+    needs: cli-tui-tests
     if: |
       github.repository == 'cline/cline' && (
         github.event_name == 'workflow_dispatch' &&
@@ -44,6 +48,7 @@ jobs:
       confirm_publish: ${{ github.event.inputs.confirm_publish }}
 
   publish-nightly:
+    needs: cli-tui-tests
     if: |
       github.repository == 'cline/cline' && (
         github.event_name == 'schedule' ||

.github/workflows/publish.yml

@@ -11,8 +11,13 @@ on:
                 options:
                     - pre-release
                     - release
+            auto_create_tag_from_main:
+                description: "Auto-create and push the provided tag from the tested main commit (recommended)"
+                required: true
+                default: true
+                type: boolean
             tag:
-                description: "Enter existing tag to publish (e.g., v3.1.2)"
+                description: "Tag to publish (required in both modes, e.g., v3.1.2)"
                 required: true
                 type: string
 
@@ -35,10 +40,69 @@ jobs:
         steps:
             - uses: actions/checkout@v4
               with:
-                  ref: ${{ github.event.inputs.tag }}
+                  ref: main
                   fetch-depth: 0
                   fetch-tags: true
 
+            - name: Resolve Release Tag
+              id: resolve_tag
+              run: |
+                  TAG="${{ github.event.inputs.tag }}"
+                  AUTO_CREATE="${{ github.event.inputs.auto_create_tag_from_main }}"
+                  TESTED_SHA="${{ github.sha }}"
+                  WORKFLOW_REF="${{ github.ref }}"
+
+                  if [[ -z "$TAG" ]]; then
+                    echo "Error: tag input is required"
+                    exit 1
+                  fi
+
+                  if [[ ! "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$ ]]; then
+                    echo "Error: tag must match vX.Y.Z (optionally with -suffix or .suffix)"
+                    exit 1
+                  fi
+                  TAG_REF="refs/tags/$TAG"
+
+                  git fetch origin main --tags
+
+                  if [[ "$AUTO_CREATE" == "true" ]]; then
+                    if [[ "$WORKFLOW_REF" != "refs/heads/main" ]]; then
+                      echo "Error: auto-create mode requires dispatching from main (current ref: $WORKFLOW_REF)"
+                      exit 1
+                    fi
+                    echo "Auto-create enabled. Using tested workflow SHA: $TESTED_SHA"
+
+                    if ! git merge-base --is-ancestor "$TESTED_SHA" origin/main; then
+                      echo "Error: tested SHA $TESTED_SHA is not on origin/main"
+                      exit 1
+                    fi
+
+                    if git show-ref --verify --quiet "$TAG_REF"; then
+                      TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
+                      if [[ "$TAG_SHA" != "$TESTED_SHA" ]]; then
+                        echo "Error: tag '$TAG' already exists at $TAG_SHA, not at tested SHA ($TESTED_SHA)"
+                        exit 1
+                      fi
+                      echo "Tag '$TAG' already exists at tested SHA. Continuing."
+                    else
+                      git config user.name "github-actions[bot]"
+                      git config user.email "github-actions[bot]@users.noreply.github.com"
+                      git tag "$TAG" "$TESTED_SHA"
+                      git push origin "$TAG_REF"
+                      echo "Created and pushed tag '$TAG' from tested SHA $TESTED_SHA."
+                    fi
+                  else
+                    if ! git show-ref --verify --quiet "$TAG_REF"; then
+                      echo "Error: tag '$TAG' does not exist in the repository"
+                      exit 1
+                    fi
+                    echo "Using existing tag '$TAG'."
+                  fi
+
+                  git checkout --detach "$TAG_REF^{commit}"
+                  echo "tag=$TAG" >> $GITHUB_OUTPUT
+                  echo "resolved_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
@@ -59,20 +123,15 @@ jobs:
                   VERSION=$(node -p "require('./package.json').version")
                   echo "version=$VERSION" >> $GITHUB_OUTPUT
 
-            - name: Validate Tag
-              id: validate_tag
+            - name: Verify Tag Matches Package Version
               run: |
-                  TAG="${{ github.event.inputs.tag }}"
-                  echo "tag=$TAG" >> $GITHUB_OUTPUT
-                  echo "Using existing tag: $TAG"
-
-                  # Verify the tag exists
-                  if ! git rev-parse "$TAG" >/dev/null 2>&1; then
-                    echo "Error: Tag '$TAG' does not exist in the repository"
+                  TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  VERSION="v${{ steps.get_version.outputs.version }}"
+                  if [[ "$TAG" != "$VERSION" ]]; then
+                    echo "Error: tag '$TAG' does not match package version '$VERSION'"
                     exit 1
                   fi
-
-                  echo "Tag '$TAG' validated successfully"
+                  echo "Tag and package version match: $TAG"
 
             - name: Package and Publish Extension
               env:
@@ -103,7 +162,7 @@ jobs:
             - name: Get Previous Tag
               id: prev_tag
               run: |
-                  CURRENT_TAG="${{ steps.validate_tag.outputs.tag }}"
+                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
                   PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
                   echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
 
@@ -119,12 +178,12 @@ jobs:
             - name: Create GitHub Release
               uses: softprops/action-gh-release@v1
               with:
-                  tag_name: ${{ steps.validate_tag.outputs.tag }}
+                  tag_name: ${{ steps.resolve_tag.outputs.tag }}
                   files: "*.vsix"
                   body: |
                       ${{ steps.changelog.outputs.content }}
 
-                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.validate_tag.outputs.tag }}
+                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}
                   prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/trigger-jetbrains-tests.yml

@@ -20,7 +20,8 @@ jobs:
       github.event_name == 'pull_request_target' ||
       (github.event_name == 'issue_comment' &&
        github.event.issue.pull_request &&
-       contains(github.event.comment.body, '/test-jetbrains'))
+       contains(github.event.comment.body, '/test-jetbrains') &&
+       contains(fromJSON('["MEMBER","OWNER","COLLABORATOR"]'), github.event.comment.author_association))
     steps:
       - name: Generate GitHub App Token
         id: app-token

.gitignore

@@ -51,3 +51,8 @@ test-results
 
 # Smoke test results (generated)
 evals/smoke-tests/results/
+
+.tui-test
+secrets.json
+tui-traces
+tests/**/cache

CHANGELOG.md

@@ -1,5 +1,113 @@
 # Changelog
 
+## [3.73.0]
+
+### Added
+
+- Added W&B Inference by CoreWeave as a new API provider with 17 models
+- Improved parallel tool calling support for OpenRouter and Cline providers
+
+### Fixed
+
+- Claude Code Provider: handle rate limit events, empty content arrays, error results, and unknown content types without crashing
+- Tool handlers (`read_file`, `list_files`, `list_code_definition_names`, `search_files`) now return graceful errors instead of crashing
+
+## [3.72.0]
+
+### Added
+
+- Added Anthropic Opus 4.6 fast mode variants
+
+### Fixed
+
+- Resolved native tool placeholder interpolation in prompts
+- Gemini: capped Flash output tokens to 8192 across providers
+- Fixed Windows unit test path normalization
+- Fixed flaky hooks tests on Windows
+- Bedrock: handle thinking and redacted_thinking blocks correctly in message conversion and streaming
+- Prevent crash when `list_files` or `list_code_definition_names` receives a file path
+
+### Changed
+
+- Updated Jupyter Notebook GIFs
+- Markdown image loading now requires user consent
+- Added `.github/copilot-instructions.md` for coding agents
+- Hooks: reintroduced feature toggle
+
+## [3.71.0]
+
+### Added
+
+- Added GPT-5.4 models for ChatGPT subscription users
+- Hooks: Added a `Notification` hook for attention and completion boundaries
+
+### Fixed
+
+- Handle streamable HTTP MCP reconnects more reliably after disconnects
+
+## [3.70.0]
+
+### Added
+
+- New Cline API docs: Getting Started, Auth, Chat Completions, Models, Errors, and SDK Examples
+- Hook payloads now include `model.provider` and `model.slug` 
+- Token/cost updates now happen immediately as usage chunks arrive, not after tool execution
+
+### Fixed
+
+- Improve subagent context compaction logic
+- Subagent stream retry delay increased to reduce noise from transient failures
+- State serialization errors are now caught and logged instead of crashing
+- Removed incorrect `max_tokens` from OpenRouter requests
+
+### Changed
+
+- Windows test cleanup now retries on locked files and applies per-test timeouts
+- Updated hooks docs 
+
+
+## [3.69.0]
+
+### Added
+
+- Add `User-Agent` header to requests sent to the Cline backend
+- Add default auto-tag workflow for publish release flow
+- Show Cline SDK docs on the Cline page
+
+### Fixed
+
+- Retry nested git restore and prevent silent `.git_disabled` leftovers in checkpoints
+- Prevent Chinese filename escaping in diff view
+- Trigger auto-compaction on OpenRouter context overflow errors
+- Restore GPT-OSS native file editing on OpenAI-compatible models
+
+### Changed
+
+- Update Cline SDK docs
+- Improve hooks support for Windows PowerShell
+
+## [3.68.0]
+
+### Added
+
+- Add dynamic Cline provider model fetching from Cline endpoint
+- Add additional Markdown formatting in CLI
+- Add focus indicator on action buttons in extension
+
+### Fixed
+
+- Clear all OCA secrets on auth refresh failure to prevent re-auth loops
+- Resolve "Could not find the file context" error in Explain Changes
+- Use `JSON_SCHEMA` for `yaml.load` to prevent unsafe deserialization
+- Fetch model info from API in CLI headless auth for Cline and Vercel providers
+- Generate commit message from staged changes only when staging exists
+- Update stale `maxTokens` values for Claude 3.7+ models across Anthropic, Bedrock, Vertex, and SAP AI Core
+- Use `model.info.maxTokens` for OpenRouter instead of hardcoded `8192`
+
+### Changed
+
+- Increase timeout for a flaky test to reduce short-term test instability
+
 ## [3.67.1]
 
 ### Added

cli/CHANGELOG.md

@@ -1,5 +1,90 @@
 # cline
 
+## [2.8.0]
+
+### Added
+
+- Added W&B Inference by CoreWeave as a new API provider with 17 models including DeepSeek-V3.1, Llama 4, and Qwen3-Coder
+- Added CLI TUI end-to-end test suite
+
+### Fixed
+
+- Claude Code: handle rate limit events, empty content arrays, error results, and unknown content types without crashing
+- CLI: `/q` and `/exit` slash commands now execute immediately on Enter without requiring the slash menu to be visible
+- CLI: slash command filtering now prioritizes exact and prefix matches over fuzzy matches
+
+## [2.7.0]
+
+### Added
+
+- Added MCP add shortcuts for stdio and HTTP servers
+- Added `--continue` for the current directory
+- Added `--auto-condense` flag for AI-powered context compaction
+- Added `--hooks-dir` flag for runtime hook injection
+- Enabled error autocapture
+- Prompt rules now include test verification guidance and make `CLI_RULES` language-agnostic
+
+### Fixed
+
+- Fixed remount behavior so TUI remounts only on width resize
+- Fixed startup prompt replay on resize remount
+- Fixed task flags so they are applied before the welcome TUI mounts
+
+### Changed
+
+- Hooks: reintroduced feature toggle
+
+## [2.6.1]
+
+### Added
+
+- Added GPT-5.4 models for ChatGPT subscription users
+- Hooks: Added a `Notification` hook for attention and completion boundaries
+- Added `--hooks-dir` CLI flag for runtime hook injection
+- Added `--auto-approve-all` CLI flag for interactive mode
+
+### Fixed
+
+- Handle streamable HTTP MCP reconnects more reliably
+
+## [2.6.0]
+
+### Added
+
+- Hook payloads now include `model.provider` and `model.slug` 
+- Token/cost updates now happen immediately as usage chunks arrive, not after tool execution
+
+### Fixed
+
+- Improve subagent context compaction logic
+- Subagent stream retry delay increased to reduce noise from transient failures
+- State serialization errors are now caught and logged instead of crashing
+- Removed incorrect `max_tokens` from OpenRouter requests
+
+## [2.5.2]
+
+### Added
+
+- Added Windows PowerShell support for hooks (execution, resolution, and management), improving hook behavior on Windows for CLI and shared core workflows.
+
+### Fixed
+
+- Restored GPT-OSS native file editing for OpenAI-compatible models used through shared core tooling.
+- Improved OpenRouter context overflow error handling so auto-compaction triggers correctly for wrapped 400 errors.
+- Hardened checkpoint recovery by retrying nested git restore and preventing silent `.git_disabled` leftovers.
+- Added a User-Agent header for requests to the Cline back-end to improve request handling consistency.
+
+## [2.5.1]
+
+### Added
+
+- Expanded CLI markdown rendering support (headings, lists, blockquotes, fenced code blocks, links, and nested lists).
+
+### Fixed
+
+- Fixed CLI headless auth provider model metadata loading for Cline and Vercel AI Gateway by fetching model info from API with cache fallback.
+- Increased flaky CLI import test timeout on Windows CI to reduce intermittent test failures.
+
 ## [2.5.0]
 
 ### Added

cli/esbuild.mts

@@ -186,6 +186,7 @@ const buildEnvVars: Record<string, string> = {
 const buildTimeEnvs = [
 	"TELEMETRY_SERVICE_API_KEY",
 	"ERROR_SERVICE_API_KEY",
+	"ENABLE_ERROR_AUTOCAPTURE",
 	"POSTHOG_TELEMETRY_ENABLED",
 	"OTEL_TELEMETRY_ENABLED",
 	"OTEL_LOGS_EXPORTER",

cli/man/cline.1.md

@@ -162,6 +162,8 @@ When running **cline** with just a prompt (no subcommand), these options are ava
 
 **-T**, **\--taskId** *id* :   Resume an existing task by ID instead of starting a new one. The prompt becomes an optional follow-up message.
 
+**\--continue** :   Resume the most recent task from the current working directory instead of starting a new one.
+
 # JSON OUTPUT FORMAT
 
 When using **\--json**, each message is output as a JSON object with these fields:
@@ -268,6 +270,9 @@ cline -T abc123def
 # Resume a task with a follow-up message
 cline -T abc123def "Now add unit tests for the changes"
 
+# Resume the most recent task from the current directory
+cline --continue
+
 # Resume in plan mode to review before continuing
 cline -T abc123def -p "What's left to do?"
 

cli/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cline",
-	"version": "2.5.0",
+	"version": "2.8.0",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"main": "dist/lib.mjs",
 	"types": "dist/lib.d.ts",

cli/src/acp/index.ts

@@ -69,6 +69,8 @@ export interface AcpModeOptions {
 	config?: string
 	/** Working directory (default: process.cwd()) */
 	cwd?: string
+	/** Additional runtime hooks directory */
+	hooksDir?: string
 	/** Enable verbose/debug logging to stderr */
 	verbose?: boolean
 }
@@ -96,6 +98,7 @@ export async function runAcpMode(options: AcpModeOptions = {}): Promise<void> {
 	new AgentSideConnection((conn) => {
 		agent = new AcpAgent(conn, {
 			debug: Boolean(options.verbose),
+			hooksDir: options.hooksDir,
 		})
 		return agent
 	}, stream)

cli/src/agent/ClineAgent.ts

@@ -42,6 +42,7 @@ import { getProviderModelIdKey } from "@shared/storage/provider-keys"
 import { ClineEndpoint } from "@/config.js"
 import { Controller } from "@/core/controller"
 import { getAvailableSlashCommands } from "@/core/controller/slash/getAvailableSlashCommands"
+import { setRuntimeHooksDir } from "@/core/storage/disk"
 import { StateManager } from "@/core/storage/StateManager"
 import { AuthHandler } from "@/hosts/external/AuthHandler.js"
 import { ExternalCommentReviewController } from "@/hosts/external/ExternalCommentReviewController.js"
@@ -140,6 +141,7 @@ export class ClineAgent implements acp.Agent {
 
 	constructor(options: ClineAgentOptions) {
 		this.options = options
+		setRuntimeHooksDir(options.hooksDir)
 		this.ctx = initializeCliContext({ clineDir: options.clineDir })
 	}
 

cli/src/agent/public-types.ts

@@ -71,6 +71,8 @@ export interface ClineAgentOptions {
 	debug?: boolean
 	/** Cline Config Directory (defaults to ~/.cline) */
 	clineDir?: string
+	/** Additional runtime hooks directory */
+	hooksDir?: string
 }
 
 /**
@@ -79,6 +81,8 @@ export interface ClineAgentOptions {
 export interface AcpAgentOptions {
 	/** Whether debug logging is enabled */
 	debug?: boolean
+	/** Additional runtime hooks directory */
+	hooksDir?: string
 }
 
 // ============================================================

cli/src/components/App.resize-initial-prompt.test.tsx

@@ -0,0 +1,136 @@
+import { Text } from "ink"
+import { render } from "ink-testing-library"
+import React from "react"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { App } from "./App"
+
+const CLEAR_SEQUENCE = "\x1b[2J\x1b[3J\x1b[H"
+
+function setTerminalSize(columns: number, rows: number) {
+	Object.defineProperty(process.stdout, "columns", {
+		configurable: true,
+		writable: true,
+		value: columns,
+	})
+
+	Object.defineProperty(process.stdout, "rows", {
+		configurable: true,
+		writable: true,
+		value: rows,
+	})
+}
+
+function hasClearSequenceCall(calls: unknown[][]): boolean {
+	return calls.some((call) => call[0] === CLEAR_SEQUENCE)
+}
+
+vi.mock("./ChatView", () => ({
+	ChatView: ({ controller, initialPrompt, initialImages }: any) => {
+		React.useEffect(() => {
+			if (initialPrompt || (initialImages && initialImages.length > 0)) {
+				controller?.initTask(initialPrompt || "", initialImages)
+			}
+		}, [])
+
+		return React.createElement(Text, null, "ChatView")
+	},
+}))
+
+vi.mock("./TaskJsonView", () => ({
+	TaskJsonView: () => React.createElement(Text, null, "TaskJsonView"),
+}))
+
+vi.mock("./HistoryView", () => ({
+	HistoryView: () => React.createElement(Text, null, "HistoryView"),
+}))
+
+vi.mock("./ConfigView", () => ({
+	ConfigView: () => React.createElement(Text, null, "ConfigView"),
+}))
+
+vi.mock("./AuthView", () => ({
+	AuthView: () => React.createElement(Text, null, "AuthView"),
+}))
+
+vi.mock("../context/TaskContext", () => ({
+	TaskContextProvider: ({ children }: any) => children,
+}))
+
+vi.mock("../context/StdinContext", () => ({
+	StdinProvider: ({ children }: any) => children,
+}))
+
+describe("App startup prompt resize behavior", () => {
+	beforeEach(() => {
+		vi.useFakeTimers()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+		vi.restoreAllMocks()
+		delete (process.stdout as any).columns
+		delete (process.stdout as any).rows
+	})
+
+	it("does not replay initialPrompt after a width resize", async () => {
+		const initTask = vi.fn()
+		setTerminalSize(120, 40)
+
+		const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(((...args: any[]) => {
+			const callback = args.find((arg) => typeof arg === "function")
+			if (callback) {
+				callback()
+			}
+			return true
+		}) as any)
+
+		const { unmount } = render(
+			<App controller={{ initTask }} initialPrompt="hello" isRawModeSupported={true} view="welcome" />,
+		)
+
+		await vi.advanceTimersByTimeAsync(0)
+		expect(initTask).toHaveBeenCalledTimes(1)
+		writeSpy.mockClear()
+
+		setTerminalSize(121, 40)
+		process.stdout.emit("resize")
+		await vi.advanceTimersByTimeAsync(350)
+		await vi.advanceTimersByTimeAsync(0)
+
+		expect(initTask).toHaveBeenCalledTimes(1)
+		expect(hasClearSequenceCall(writeSpy.mock.calls as unknown[][])).toBe(true)
+
+		unmount()
+	})
+
+	it("does not remount on height-only resize", async () => {
+		const initTask = vi.fn()
+		setTerminalSize(120, 40)
+
+		const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(((...args: any[]) => {
+			const callback = args.find((arg) => typeof arg === "function")
+			if (callback) {
+				callback()
+			}
+			return true
+		}) as any)
+
+		const { unmount } = render(
+			<App controller={{ initTask }} initialPrompt="hello" isRawModeSupported={true} view="welcome" />,
+		)
+
+		await vi.advanceTimersByTimeAsync(0)
+		expect(initTask).toHaveBeenCalledTimes(1)
+		writeSpy.mockClear()
+
+		setTerminalSize(120, 45)
+		process.stdout.emit("resize")
+		await vi.advanceTimersByTimeAsync(350)
+		await vi.advanceTimersByTimeAsync(0)
+
+		expect(initTask).toHaveBeenCalledTimes(1)
+		expect(hasClearSequenceCall(writeSpy.mock.calls as unknown[][])).toBe(false)
+
+		unmount()
+	})
+})

cli/src/components/App.tsx

@@ -3,14 +3,15 @@
  * Routes between different views (task, history, config)
  */
 
-import { Box } from "ink"
-import React, { ReactNode, useCallback, useState } from "react"
+import { Box, useApp } from "ink"
+import React, { ReactNode, useCallback, useEffect, useState } from "react"
 import { StdinProvider } from "../context/StdinContext"
 import { TaskContextProvider } from "../context/TaskContext"
 import { useTerminalSize } from "../hooks/useTerminalSize"
 import { AuthView } from "./AuthView"
 import { ChatView } from "./ChatView"
 import { ConfigView } from "./ConfigView"
+import { ErrorBoundary } from "./ErrorBoundary"
 import { HistoryView } from "./HistoryView"
 import { TaskJsonView } from "./TaskJsonView"
 
@@ -90,7 +91,17 @@ interface AppProps {
 	isRawModeSupported?: boolean
 }
 
-export const App: React.FC<AppProps> = ({
+export const App: React.FC<AppProps> = (props) => {
+	const { exit } = useApp()
+
+	return (
+		<ErrorBoundary exit={exit}>
+			<InternalApp {...props} />
+		</ErrorBoundary>
+	)
+}
+
+const InternalApp: React.FC<AppProps> = ({
 	view: initialView,
 	taskId,
 	verbose = false,
@@ -135,6 +146,17 @@ export const App: React.FC<AppProps> = ({
 	const { resizeKey } = useTerminalSize()
 	const [currentView, setCurrentView] = useState<ViewType>(initialView)
 	const [selectedTaskId, setSelectedTaskId] = useState<string | undefined>(taskId)
+	const [pendingInitialPrompt, setPendingInitialPrompt] = useState<string | undefined>(initialPrompt)
+	const [pendingInitialImages, setPendingInitialImages] = useState<string[] | undefined>(initialImages)
+
+	useEffect(() => {
+		if (!pendingInitialPrompt && (!pendingInitialImages || pendingInitialImages.length === 0)) {
+			return
+		}
+
+		setPendingInitialPrompt(undefined)
+		setPendingInitialImages(undefined)
+	}, [pendingInitialPrompt, pendingInitialImages])
 
 	const handleSelectTask = useCallback((taskId: string) => {
 		setSelectedTaskId(taskId)
@@ -242,8 +264,8 @@ export const App: React.FC<AppProps> = ({
 					) : (
 						<ChatView
 							controller={controller}
-							initialImages={initialImages}
-							initialPrompt={initialPrompt}
+							initialImages={pendingInitialImages}
+							initialPrompt={pendingInitialPrompt}
 							onComplete={onComplete}
 							onError={onError}
 							onExit={onWelcomeExit}

cli/src/components/ChatView.test.tsx

@@ -12,7 +12,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 import { ChatView } from "./ChatView"
 
 // Helper to wait for async state updates
-const delay = (ms: number = 60) => new Promise((resolve) => setTimeout(resolve, ms))
+const delay = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms))
 
 // Type for our exit mock function
 type ExitMockFn = ReturnType<typeof vi.fn> & (() => void)
@@ -126,12 +126,16 @@ vi.mock("../utils/file-search", () => ({
 	searchWorkspaceFiles: vi.fn(async () => []),
 }))
 
-vi.mock("../utils/slash-commands", () => ({
-	extractSlashQuery: vi.fn(() => ({ inSlashMode: false, query: "", slashIndex: -1 })),
-	filterCommands: vi.fn(() => []),
-	insertSlashCommand: vi.fn((text: string) => text),
-	sortCommandsWorkflowsFirst: vi.fn((cmds: unknown[]) => cmds),
-}))
+vi.mock("../utils/slash-commands", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../utils/slash-commands")>()
+	return {
+		...actual,
+		extractSlashQuery: vi.fn(() => ({ inSlashMode: false, query: "", slashIndex: -1 })),
+		filterCommands: vi.fn(() => []),
+		insertSlashCommand: vi.fn((text: string) => text),
+		sortCommandsWorkflowsFirst: vi.fn((cmds: unknown[]) => cmds),
+	}
+})
 
 vi.mock("../utils/input", () => ({
 	isMouseEscapeSequence: vi.fn(() => false),

cli/src/components/ChatView.tsx

@@ -108,7 +108,6 @@ import type { ClineAsk, ClineMessage } from "@shared/ExtensionMessage"
 import { getApiMetrics, getLastApiReqTotalTokens } from "@shared/getApiMetrics"
 import { EmptyRequest, StringRequest } from "@shared/proto/cline/common"
 import type { SlashCommandInfo } from "@shared/proto/cline/slash"
-import { CLI_ONLY_COMMANDS } from "@shared/slashCommands"
 import { getProviderDefaultModelId, getProviderModelIdKey } from "@shared/storage"
 import type { Mode } from "@shared/storage/types"
 import { execSync } from "child_process"
@@ -137,7 +136,14 @@ import {
 } from "../utils/file-search"
 import { isMouseEscapeSequence } from "../utils/input"
 import { jsonParseSafe, parseImagesFromInput } from "../utils/parser"
-import { extractSlashQuery, filterCommands, insertSlashCommand, sortCommandsWorkflowsFirst } from "../utils/slash-commands"
+import {
+	createCliOnlySlashCommands,
+	extractSlashQuery,
+	filterCommands,
+	getStandaloneSlashCommandToExecute,
+	insertSlashCommand,
+	sortCommandsWorkflowsFirst,
+} from "../utils/slash-commands"
 import { waitFor } from "../utils/timeout"
 import { isFileEditTool, parseToolFromMessage } from "../utils/tools"
 import { shutdownEvent } from "../vscode-shim"
@@ -403,7 +409,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 	const PASTE_UPDATE_DEBOUNCE_MS = 50 // Debounce visual updates to avoid flicker
 
 	// Slash command state
-	const [availableCommands, setAvailableCommands] = useState<SlashCommandInfo[]>([])
+	const [availableCommands, setAvailableCommands] = useState<SlashCommandInfo[]>(() => createCliOnlySlashCommands())
 	const [selectedSlashIndex, setSelectedSlashIndex] = useState(0)
 	const [slashMenuDismissed, setSlashMenuDismissed] = useState(false)
 	const lastSlashIndexRef = useRef<number>(-1)
@@ -614,16 +620,15 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			try {
 				const response = await getAvailableSlashCommands(ctrl, EmptyRequest.create())
 				const cliCommands = response.commands.filter((cmd) => cmd.cliCompatible !== false)
-				// Add CLI-only commands (like /settings) that are handled locally
-				const cliOnlyCommands: SlashCommandInfo[] = CLI_ONLY_COMMANDS.map((cmd) => ({
-					name: cmd.name,
-					description: cmd.description || "",
-					section: cmd.section || "default",
-					cliCompatible: true,
-				}))
+				// Add CLI-only commands (like /settings) that are handled locally.
+				// Seed these synchronously on first render so locally handled commands like
+				// /q and /exit are immediately available, even before the async command
+				// fetch completes. This avoids a race that can make the quit command tests
+				// flaky on slower Windows CI runners.
+				const cliOnlyCommands = createCliOnlySlashCommands()
 				setAvailableCommands([...cliOnlyCommands, ...sortCommandsWorkflowsFirst(cliCommands)])
 			} catch {
-				// Fallback: commands will be empty, menu won't show
+				// Keep CLI-only commands available even if backend command loading fails.
 			}
 		}
 		loadCommands()
@@ -843,6 +848,77 @@ export const ChatView: React.FC<ChatViewProps> = ({
 		}, 150)
 	}, [inkExit, onExit])
 
+	const handleCliOnlySlashCommand = useCallback(
+		(commandName: string): boolean => {
+			if (commandName === "help") {
+				setActivePanel({ type: "help" })
+				setTextInput("")
+				setCursorPos(0)
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "settings") {
+				setActivePanel({ type: "settings" })
+				setTextInput("")
+				setCursorPos(0)
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "models") {
+				const apiConfig = StateManager.get().getApiConfiguration()
+				const provider =
+					mode === "act"
+						? apiConfig.actModeApiProvider || apiConfig.planModeApiProvider
+						: apiConfig.planModeApiProvider || apiConfig.actModeApiProvider
+				const initialMode = !provider ? undefined : provider === "cline" ? "featured-models" : "model-picker"
+				const initialModelKey = mode === "act" ? "actModelId" : "planModelId"
+				setActivePanel({ type: "settings", initialMode, initialModelKey })
+				setTextInput("")
+				setCursorPos(0)
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "history") {
+				setActivePanel({ type: "history" })
+				setTextInput("")
+				setCursorPos(0)
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "skills") {
+				setActivePanel({ type: "skills" })
+				setTextInput("")
+				setCursorPos(0)
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "clear") {
+				void clearViewAndResetTask()
+				setSelectedSlashIndex(0)
+				setSlashMenuDismissed(true)
+				return true
+			}
+
+			if (commandName === "exit" || commandName === "q") {
+				handleExit()
+				return true
+			}
+
+			return false
+		},
+		[clearViewAndResetTask, handleExit, mode, setCursorPos, setTextInput],
+	)
+
 	// Get button config based on the last message state
 	const buttonConfig = useMemo(() => {
 		const lastMsg = messages[messages.length - 1] as ClineMessage | undefined
@@ -1102,6 +1178,17 @@ export const ChatView: React.FC<ChatViewProps> = ({
 
 		const inSlashMenu = slashInfo.inSlashMode && filteredCommands.length > 0 && !slashMenuDismissed
 		const inFileMenu = mentionInfo.inMentionMode && fileResults.length > 0 && !inSlashMenu
+		const standaloneSlashCommand = getStandaloneSlashCommandToExecute({
+			prompt,
+			inSlashMode: slashInfo.inSlashMode,
+			hasSlashMenu: inSlashMenu,
+			hasPendingAsk: !!pendingAsk,
+			isSpinnerActive,
+		})
+
+		if (key.return && standaloneSlashCommand && handleCliOnlySlashCommand(standaloneSlashCommand)) {
+			return
+		}
 
 		// 5. Slash command menu navigation (takes priority over file menu)
 		if (inSlashMenu) {
@@ -1116,64 +1203,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			if (key.tab || key.return) {
 				const cmd = filteredCommands[selectedSlashIndex]
 				if (cmd) {
-					// Handle CLI-only commands locally
-					if (cmd.name === "help") {
-						setActivePanel({ type: "help" })
-						setTextInput("")
-						setCursorPos(0)
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "settings") {
-						setActivePanel({ type: "settings" })
-						setTextInput("")
-						setCursorPos(0)
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "models") {
-						const apiConfig = StateManager.get().getApiConfiguration()
-						// Use current mode's provider to determine picker type
-						const provider =
-							mode === "act"
-								? apiConfig.actModeApiProvider || apiConfig.planModeApiProvider
-								: apiConfig.planModeApiProvider || apiConfig.actModeApiProvider
-						const initialMode = !provider ? undefined : provider === "cline" ? "featured-models" : "model-picker"
-						// Set model for current mode (plan or act)
-						const initialModelKey = mode === "act" ? "actModelId" : "planModelId"
-						setActivePanel({ type: "settings", initialMode, initialModelKey })
-						setTextInput("")
-						setCursorPos(0)
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "history") {
-						setActivePanel({ type: "history" })
-						setTextInput("")
-						setCursorPos(0)
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "skills") {
-						setActivePanel({ type: "skills" })
-						setTextInput("")
-						setCursorPos(0)
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "clear") {
-						clearViewAndResetTask()
-						setSelectedSlashIndex(0)
-						setSlashMenuDismissed(true)
-						return
-					}
-					if (cmd.name === "exit" || cmd.name === "q") {
-						handleExit()
+					if (handleCliOnlySlashCommand(cmd.name)) {
 						return
 					}
 					const newText = insertSlashCommand(textInput, slashInfo.slashIndex, cmd.name)

cli/src/components/ConfigView.test.tsx

@@ -84,6 +84,16 @@ describe("ConfigView", () => {
 			)
 			expect(lastFrame()).toContain("Global Settings")
 		})
+
+		it("hides Hooks tab when hooks are disabled", () => {
+			const { lastFrame } = render(<ConfigView {...defaultProps} hooksEnabled={false} skillsEnabled={true} />)
+			expect(lastFrame()).not.toContain("Hooks")
+		})
+
+		it("shows Hooks tab when hooks are enabled", () => {
+			const { lastFrame } = render(<ConfigView {...defaultProps} hooksEnabled={true} skillsEnabled={true} />)
+			expect(lastFrame()).toContain("Hooks")
+		})
 	})
 
 	describe("value formatting", () => {

cli/src/components/ErrorBoundary.tsx

@@ -0,0 +1,51 @@
+import { Box, Text } from "ink"
+import React from "react"
+import { ErrorService } from "@/services/error"
+import { StaticRobotFrame } from "./AsciiMotionCli"
+
+type Props = React.PropsWithChildren<{ exit: (error?: Error) => void }>
+
+async function onReactError(props: Props, error: Error, errorInfo: React.ErrorInfo) {
+	try {
+		await ErrorService.get().captureException(error, { context: "ErrorBoundary", errorInfo })
+		await ErrorService.get().dispose()
+	} catch {
+		// Ignore errors
+	} finally {
+		props.exit(error)
+	}
+}
+
+export class ErrorBoundary extends React.Component<Props, { hasError: boolean }> {
+	override state = { hasError: false }
+
+	constructor(props: Props) {
+		super(props)
+	}
+
+	override componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+		onReactError(this.props, error, errorInfo)
+	}
+
+	static getDerivedStateFromError() {
+		return { hasError: true }
+	}
+
+	override render() {
+		if (this.state.hasError) {
+			return (
+				<Box flexDirection="column" height="100%" key="header" width="100%">
+					<StaticRobotFrame />
+					<Text> </Text>
+					<Text bold color="white">
+						Something went wrong. We're sorry.
+					</Text>
+					<Text color="white">Please check the logs for more details.</Text>
+					<Text> </Text>
+				</Box>
+			)
+		}
+
+		return this.props.children
+	}
+}

cli/src/components/ModelPicker.tsx

@@ -62,6 +62,8 @@ import {
 	sapAiCoreModels,
 	vertexDefaultModelId,
 	vertexModels,
+	wandbDefaultModelId,
+	wandbModels,
 	xaiDefaultModelId,
 	xaiModels,
 } from "@/shared/api"
@@ -101,6 +103,7 @@ export const providerModels: Record<string, { models: Record<string, unknown>; d
 	sambanova: { models: sambanovaModels, defaultId: sambanovaDefaultModelId },
 	sapaicore: { models: sapAiCoreModels, defaultId: sapAiCoreDefaultModelId },
 	vertex: { models: vertexModels, defaultId: vertexDefaultModelId },
+	wandb: { models: wandbModels, defaultId: wandbDefaultModelId },
 	xai: { models: xaiModels, defaultId: xaiDefaultModelId },
 	zai: { models: internationalZAiModels, defaultId: internationalZAiDefaultModelId },
 }

cli/src/components/QuitCommand.test.tsx

@@ -1,112 +1,38 @@
-import { render } from "ink-testing-library"
-// biome-ignore lint/correctness/noUnusedImports: React must be in scope for JSX in this test file.
-import React from "react"
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { CLI_ONLY_COMMANDS } from "@shared/slashCommands"
+import { describe, expect, it } from "vitest"
+import { filterCommands, getStandaloneSlashCommandName, getStandaloneSlashCommandToExecute } from "../utils/slash-commands"
 
-// Mock ink's useApp
-const mockExit = vi.fn()
-vi.mock("ink", async (importOriginal) => {
-	const actual = await importOriginal<typeof import("ink")>()
-	return {
-		...actual,
-		useApp: () => ({ exit: mockExit }),
-	}
-})
-
-// Mock child_process
-vi.mock("child_process", () => ({
-	execSync: vi.fn().mockReturnValue(""),
-	exec: vi.fn(),
+const cliOnlySlashCommands = CLI_ONLY_COMMANDS.map((cmd) => ({
+	name: cmd.name,
+	description: cmd.description || "",
+	section: cmd.section || "default",
+	cliCompatible: true,
 }))
 
-// Mock dependencies
-vi.mock("@/core/controller/slash/getAvailableSlashCommands", () => ({
-	getAvailableSlashCommands: vi.fn().mockResolvedValue({ commands: [] }),
-}))
-
-vi.mock("@/core/storage/StateManager", () => ({
-	StateManager: {
-		get: () => ({
-			getGlobalSettingsKey: vi.fn().mockReturnValue("act"),
-			getGlobalStateKey: vi.fn().mockReturnValue([]),
-			getApiConfiguration: vi.fn().mockReturnValue({}),
-		}),
-	},
-}))
-
-vi.mock("@/services/telemetry", () => ({
-	telemetryService: {
-		captureHostEvent: vi.fn(),
-	},
-}))
-
-vi.mock("@shared/services/Session", () => ({
-	Session: {
-		get: () => ({
-			getStats: vi.fn().mockReturnValue({}),
-		}),
-	},
-}))
-
-vi.mock("../context/TaskContext", () => ({
-	useTaskContext: () => ({
-		controller: {},
-		clearState: vi.fn(),
-	}),
-	useTaskState: () => ({
-		clineMessages: [],
-	}),
-}))
-
-vi.mock("../hooks/useStateSubscriber", () => ({
-	useIsSpinnerActive: () => ({ isActive: false, startTime: 0 }),
-}))
-
-import { ChatView } from "./ChatView"
-
-// Helper to wait for async state updates
-const delay = (ms = 60) => new Promise((resolve) => setTimeout(resolve, ms))
-
 describe("Quit Command (/q and /exit)", () => {
-	const mockOnExit = vi.fn()
+	it("prioritizes /q as the selected slash command for an exact q query", () => {
+		const result = filterCommands(cliOnlySlashCommands, "q")
 
-	beforeEach(() => {
-		vi.clearAllMocks()
+		expect(result[0]?.name).toBe("q")
 	})
 
-	it("should exit the application when /q is selected from slash menu", async () => {
-		const { stdin } = render(<ChatView onExit={mockOnExit} />)
-		await delay()
-
-		// Type /q
-		stdin.write("/q")
-		await delay()
-
-		// Press Enter
-		stdin.write("\r")
-
-		// handleExit has a 150ms timeout
-		await delay(200)
-
-		expect(mockExit).toHaveBeenCalled()
-		expect(mockOnExit).toHaveBeenCalled()
+	it("detects /q as a standalone slash command", () => {
+		expect(getStandaloneSlashCommandName("/q")).toBe("q")
 	})
 
-	it("should exit the application when /exit is selected from slash menu", async () => {
-		const { stdin } = render(<ChatView onExit={mockOnExit} />)
-		await delay()
+	it("detects /exit as a standalone slash command", () => {
+		expect(getStandaloneSlashCommandName("/exit")).toBe("exit")
+	})
 
-		// Type /exit
-		stdin.write("/exit")
-		await delay()
-
-		// Press Enter
-		stdin.write("\r")
-
-		// handleExit has a 150ms timeout
-		await delay(200)
-
-		expect(mockExit).toHaveBeenCalled()
-		expect(mockOnExit).toHaveBeenCalled()
+	it("resolves /q to direct execution when no slash menu is active", () => {
+		expect(
+			getStandaloneSlashCommandToExecute({
+				prompt: "/q",
+				inSlashMode: true,
+				hasSlashMenu: false,
+				hasPendingAsk: false,
+				isSpinnerActive: false,
+			}),
+		).toBe("q")
 	})
 })

cli/src/components/SkillsPanelContent.test.tsx

@@ -120,7 +120,9 @@ describe("SkillsPanelContent", () => {
 			await delay()
 
 			// Navigate down to marketplace (past the one skill)
-			stdin.write("\x1B[B") // Down arrow
+			// Use vim-style navigation here because it's more deterministic in the
+			// full suite than raw arrow escape sequences on Windows.
+			stdin.write("j")
 			await delay()
 
 			stdin.write("\r") // Enter

cli/src/hooks/useTerminalSize.ts

@@ -26,6 +26,9 @@ import { useCallback, useEffect, useRef, useState } from "react"
  *    to unmount and remount everything from scratch. This resets Ink's internal tracking
  *    AND re-renders Static content since the components are brand new instances.
  *
+ * We only run this full recovery when terminal width changes. Height-only resizes do not
+ * affect wrapping in the same way and should not restart the task view.
+ *
  * Gemini CLI does the same thing in AppContainer.tsx: debounce 300ms, then
  * stdout.write(ansiEscapes.clearTerminal) + setHistoryRemountKey(prev => prev + 1).
  *
@@ -41,6 +44,8 @@ export function useTerminalSize() {
 	})
 	const [resizeKey, setResizeKey] = useState(0)
 	const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+	const previousColumnsRef = useRef(process.stdout.columns || 80)
+	const pendingWidthRefreshRef = useRef(false)
 
 	const refreshAfterResize = useCallback(() => {
 		// Clear terminal + scrollback to wipe stale content from old width
@@ -56,17 +61,33 @@ export function useTerminalSize() {
 
 	useEffect(() => {
 		function updateSize() {
+			const nextColumns = process.stdout.columns || 80
+			const nextRows = process.stdout.rows || 24
+			const didWidthChange = nextColumns !== previousColumnsRef.current
+			previousColumnsRef.current = nextColumns
+
 			setSize({
-				columns: process.stdout.columns || 80,
-				rows: process.stdout.rows || 24,
+				columns: nextColumns,
+				rows: nextRows,
 			})
 
+			if (didWidthChange) {
+				pendingWidthRefreshRef.current = true
+			}
+
+			if (!pendingWidthRefreshRef.current) {
+				return
+			}
+
 			// Debounce: wait 300ms after last resize event to do full recovery
 			if (debounceRef.current) {
 				clearTimeout(debounceRef.current)
 			}
 			debounceRef.current = setTimeout(() => {
-				refreshAfterResize()
+				if (pendingWidthRefreshRef.current) {
+					refreshAfterResize()
+					pendingWidthRefreshRef.current = false
+				}
 				debounceRef.current = null
 			}, 300)
 		}
@@ -76,6 +97,7 @@ export function useTerminalSize() {
 			if (debounceRef.current) {
 				clearTimeout(debounceRef.current)
 			}
+			pendingWidthRefreshRef.current = false
 		}
 	}, [refreshAfterResize])
 

cli/src/index.test.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander"
-import { beforeEach, describe, expect, it } from "vitest"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { captureUnhandledException } from "."
 
 /**
  * Tests for CLI command parsing and structure
@@ -25,6 +26,7 @@ describe("CLI Commands", () => {
 			.option("-a, --act", "Run in act mode")
 			.option("-p, --plan", "Run in plan mode")
 			.option("-y, --yolo", "Enable yolo mode")
+			.option("--auto-approve-all", "Enable auto-approve all")
 			.option("-m, --model <model>", "Model to use")
 			.option("-i, --images <paths...>", "Image file paths")
 			.option("-v, --verbose", "Show verbose output")
@@ -33,6 +35,9 @@ describe("CLI Commands", () => {
 			.option("--thinking [tokens]", "Enable extended thinking")
 			.option("--reasoning-effort <effort>", "Reasoning effort")
 			.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes")
+			.option("--double-check-completion", "Reject first completion attempt to force re-verification")
+			.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
+			.option("--hooks-dir <path>", "Additional hooks directory")
 			.action(() => {})
 
 		program
@@ -62,6 +67,22 @@ describe("CLI Commands", () => {
 			.option("--config <path>", "Configuration directory")
 			.action(() => {})
 
+		const mcpCommand = program.command("mcp").description("Manage MCP servers")
+		mcpCommand
+			.command("add")
+			.description("Add an MCP server shortcut")
+			.argument("<name>", "MCP server name")
+			.argument("[targetOrCommand...]", "Command args for stdio, or URL for remote")
+			.option("--type <type>", "Transport type", "stdio")
+			.option("-c, --cwd <path>", "Working directory")
+			.option("--config <path>", "Configuration directory")
+			.action(() => {})
+
+		program
+			.command("kanban")
+			.description("Run npx kanban --agent cline")
+			.action(() => {})
+
 		// Default command for interactive mode
 		program
 			.argument("[prompt]", "Task prompt")
@@ -72,6 +93,11 @@ describe("CLI Commands", () => {
 			.option("--thinking [tokens]", "Enable extended thinking")
 			.option("--reasoning-effort <effort>", "Reasoning effort")
 			.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes")
+			.option("--double-check-completion", "Reject first completion attempt to force re-verification")
+			.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
+			.option("--hooks-dir <path>", "Additional hooks directory")
+			.option("--auto-approve-all", "Enable auto-approve all")
+			.option("--kanban", "Run npx kanban --agent cline")
 			.action(() => {})
 	})
 
@@ -108,6 +134,13 @@ describe("CLI Commands", () => {
 			expect(taskCmd.opts().yolo).toBe(true)
 		})
 
+		it("should parse --auto-approve-all flag", () => {
+			const taskCmd = program.commands.find((c) => c.name() === "task")!
+			const args = ["test prompt", "--auto-approve-all"]
+			taskCmd.parse(args, { from: "user" })
+			expect(taskCmd.opts().autoApproveAll).toBe(true)
+		})
+
 		it("should parse --model option", () => {
 			const taskCmd = program.commands.find((c) => c.name() === "task")!
 			const args = ["test prompt", "--model", "claude-sonnet-4-20250514"]
@@ -171,6 +204,27 @@ describe("CLI Commands", () => {
 			expect(taskCmd.opts().maxConsecutiveMistakes).toBe("999")
 		})
 
+		it("should parse --hooks-dir option", () => {
+			const taskCmd = program.commands.find((c) => c.name() === "task")!
+			const args = ["test prompt", "--hooks-dir", "/tmp/hooks"]
+			taskCmd.parse(args, { from: "user" })
+			expect(taskCmd.opts().hooksDir).toBe("/tmp/hooks")
+		})
+
+		it("should parse --double-check-completion flag", () => {
+			const taskCmd = program.commands.find((c) => c.name() === "task")!
+			const args = ["test prompt", "--double-check-completion"]
+			taskCmd.parse(args, { from: "user" })
+			expect(taskCmd.opts().doubleCheckCompletion).toBe(true)
+		})
+
+		it("should parse --auto-condense flag", () => {
+			const taskCmd = program.commands.find((c) => c.name() === "task")!
+			const args = ["test prompt", "--auto-condense"]
+			taskCmd.parse(args, { from: "user" })
+			expect(taskCmd.opts().autoCondense).toBe(true)
+		})
+
 		it("should parse short flags", () => {
 			const taskCmd = program.commands.find((c) => c.name() === "task")!
 			const args = ["test prompt", "-a", "-v", "-m", "gpt-4"]
@@ -237,6 +291,13 @@ describe("CLI Commands", () => {
 		})
 	})
 
+	describe("kanban command", () => {
+		it("should parse kanban command", () => {
+			const args = ["node", "cli", "kanban"]
+			program.parse(args)
+		})
+	})
+
 	describe("auth command", () => {
 		it("should parse auth command", () => {
 			const args = ["node", "cli", "auth"]
@@ -281,6 +342,32 @@ describe("CLI Commands", () => {
 		})
 	})
 
+	describe("mcp command", () => {
+		it("should parse mcp add stdio syntax", () => {
+			const args = ["node", "cli", "mcp", "add", "kanban", "--", "kanban", "mcp"]
+			program.parse(args)
+		})
+
+		it("should parse mcp add remote http syntax", () => {
+			const args = ["node", "cli", "mcp", "add", "linear", "https://mcp.linear.app/mcp", "--type", "http"]
+			program.parse(args)
+		})
+
+		it("should default mcp add type to stdio", () => {
+			const mcpCmd = program.commands.find((c) => c.name() === "mcp")!
+			const addCmd = mcpCmd.commands.find((c) => c.name() === "add")!
+			addCmd.parse(["kanban", "--", "kanban", "mcp"], { from: "user" })
+			expect(addCmd.opts().type).toBe("stdio")
+		})
+
+		it("should parse mcp add type option", () => {
+			const mcpCmd = program.commands.find((c) => c.name() === "mcp")!
+			const addCmd = mcpCmd.commands.find((c) => c.name() === "add")!
+			addCmd.parse(["linear", "https://mcp.linear.app/mcp", "--type", "http"], { from: "user" })
+			expect(addCmd.opts().type).toBe("http")
+		})
+	})
+
 	describe("default command (interactive mode)", () => {
 		it("should parse optional prompt argument", () => {
 			const args = ["node", "cli", "do something"]
@@ -321,6 +408,21 @@ describe("CLI Commands", () => {
 			program.parse(["node", "cli", "--max-consecutive-mistakes", "7"])
 			expect(program.opts().maxConsecutiveMistakes).toBe("7")
 		})
+
+		it("should parse --hooks-dir option", () => {
+			program.parse(["node", "cli", "--hooks-dir", "/tmp/hooks"])
+			expect(program.opts().hooksDir).toBe("/tmp/hooks")
+		})
+
+		it("should parse --auto-approve-all flag", () => {
+			program.parse(["node", "cli", "--auto-approve-all"])
+			expect(program.opts().autoApproveAll).toBe(true)
+		})
+
+		it("should parse --kanban flag", () => {
+			program.parse(["node", "cli", "--kanban"])
+			expect(program.opts().kanban).toBe(true)
+		})
 	})
 
 	describe("command structure", () => {
@@ -330,6 +432,8 @@ describe("CLI Commands", () => {
 			expect(commandNames).toContain("history")
 			expect(commandNames).toContain("config")
 			expect(commandNames).toContain("auth")
+			expect(commandNames).toContain("mcp")
+			expect(commandNames).toContain("kanban")
 		})
 
 		it("should have correct aliases", () => {
@@ -410,3 +514,42 @@ describe("getProviderModelIdKey", () => {
 		expect(getProviderModelIdKey("unknown-provider", "act")).toBeNull()
 	})
 })
+
+const mockCaptureException = vi.fn().mockResolvedValue(undefined)
+const mockDispose = vi.fn().mockResolvedValue(undefined)
+
+vi.mock("@/services/error/ErrorService", () => {
+	return {
+		ErrorService: {
+			get: () => ({
+				captureException: mockCaptureException,
+				dispose: mockDispose,
+			}),
+		},
+	}
+})
+
+describe("captureUnhandledException", () => {
+	beforeEach(() => {
+		vi.resetAllMocks()
+	})
+
+	it("captures unhandled exceptions", async () => {
+		const testError = new Error("Test unhandled exception")
+
+		await captureUnhandledException(testError, "unhandledRejection")
+
+		expect(mockCaptureException).toHaveBeenCalledWith(testError, { context: "unhandledRejection" })
+		expect(mockDispose).toHaveBeenCalled()
+	})
+
+	it("does not throw if captureException fails", async () => {
+		mockCaptureException.mockRejectedValueOnce(new Error("Capture failed"))
+
+		const testError = new Error("Test unhandled exception")
+
+		await expect(captureUnhandledException(testError, "unhandledRejection")).resolves.not.toThrow()
+		expect(mockCaptureException).toHaveBeenCalledWith(testError, { context: "unhandledRejection" })
+		expect(mockDispose).not.toHaveBeenCalled()
+	})
+})

cli/src/index.ts

@@ -2,6 +2,7 @@
  * Cline CLI - TypeScript implementation with React Ink
  */
 
+import { spawn } from "node:child_process"
 import { exit } from "node:process"
 import type { ApiProvider } from "@shared/api"
 import { Command } from "commander"
@@ -9,6 +10,8 @@ import { render } from "ink"
 import React from "react"
 import { ClineEndpoint } from "@/config"
 import type { Controller } from "@/core/controller"
+import { getHooksEnabledSafe } from "@/core/hooks/hooks-utils"
+import { setRuntimeHooksDir } from "@/core/storage/disk"
 import { StateManager } from "@/core/storage/StateManager"
 import { AuthHandler } from "@/hosts/external/AuthHandler"
 import { HostProvider } from "@/hosts/host-provider"
@@ -32,6 +35,7 @@ import { CliWebviewProvider } from "./controllers/CliWebviewProvider"
 import { isAuthConfigured } from "./utils/auth"
 import { restoreConsole, suppressConsoleUnlessVerbose } from "./utils/console"
 import { printInfo, printWarning } from "./utils/display"
+import { addMcpServerShortcut, type McpAddOptions } from "./utils/mcp"
 import { selectOutputMode } from "./utils/mode-selection"
 import { parseImagesFromInput, processImagePaths } from "./utils/parser"
 import { CLINE_CLI_DIR, getCliBinaryPath } from "./utils/path"
@@ -39,6 +43,7 @@ import { readStdinIfPiped } from "./utils/piped"
 import { runPlainTextTask } from "./utils/plain-text-task"
 import { applyProviderConfig } from "./utils/provider-config"
 import { getValidCliProviders, isValidCliProvider } from "./utils/providers"
+import { findMostRecentTaskForWorkspace } from "./utils/task-history"
 import { autoUpdateOnStartup, checkForUpdates } from "./utils/update"
 import { initializeCliContext } from "./vscode-context"
 import { CLI_LOG_FILE, shutdownEvent, window } from "./vscode-shim"
@@ -53,18 +58,23 @@ suppressConsoleUnlessVerbose()
 interface TaskOptions {
 	act?: boolean
 	plan?: boolean
+	kanban?: boolean
 	model?: string
 	verbose?: boolean
 	cwd?: string
+	continue?: boolean
 	config?: string
 	thinking?: boolean | string
 	reasoningEffort?: string
 	maxConsecutiveMistakes?: string
 	yolo?: boolean
+	autoApproveAll?: boolean
 	doubleCheckCompletion?: boolean
+	autoCondense?: boolean
 	timeout?: string
 	json?: boolean
 	stdinWasPiped?: boolean
+	hooksDir?: string
 }
 
 let telemetryDisposed = false
@@ -133,46 +143,43 @@ function normalizeMaxConsecutiveMistakes(value?: string): number | undefined {
 function applyTaskOptions(options: TaskOptions): void {
 	// Apply mode flag
 	if (options.plan) {
-		StateManager.get().setGlobalState("mode", "plan")
+		StateManager.get().setSessionOverride("mode", "plan")
 		telemetryService.captureHostEvent("mode_flag", "plan")
 	} else if (options.act) {
-		StateManager.get().setGlobalState("mode", "act")
+		StateManager.get().setSessionOverride("mode", "act")
 		telemetryService.captureHostEvent("mode_flag", "act")
 	}
 
 	// Apply model override if specified
 	if (options.model) {
-		const selectedMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
+		const selectedMode = (StateManager.get().getGlobalSettingsKey("mode") ?? "act") as "act" | "plan"
 		const providerKey = selectedMode === "act" ? "actModeApiProvider" : "planModeApiProvider"
 		const currentProvider = StateManager.get().getGlobalSettingsKey(providerKey) as ApiProvider
 		const modelKey = getProviderModelIdKey(currentProvider, selectedMode)
 		if (modelKey) {
-			StateManager.get().setGlobalState(modelKey, options.model)
+			StateManager.get().setSessionOverride(modelKey, options.model)
 		}
 		telemetryService.captureHostEvent("model_flag", options.model)
 	}
 
+	const currentMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
+
 	// Set thinking budget based on --thinking flag (boolean or number)
-	let thinkingBudget = 0
-	if (options.thinking) {
+	if (options.thinking !== undefined) {
+		let thinkingBudget = 1024
 		if (typeof options.thinking === "string") {
 			const parsed = Number.parseInt(options.thinking, 10)
 			if (Number.isNaN(parsed) || parsed < 0) {
 				printWarning(`Invalid --thinking value '${options.thinking}'. Using default 1024.`)
-				thinkingBudget = 1024
 			} else {
 				thinkingBudget = parsed
 			}
-		} else {
-			thinkingBudget = 1024
 		}
-	}
-	const currentMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
-	setModeScopedState(currentMode, (mode) => {
-		const thinkingKey = mode === "act" ? "actModeThinkingBudgetTokens" : "planModeThinkingBudgetTokens"
-		StateManager.get().setGlobalState(thinkingKey, thinkingBudget)
-	})
-	if (options.thinking) {
+
+		setModeScopedState(currentMode, (mode) => {
+			const thinkingKey = mode === "act" ? "actModeThinkingBudgetTokens" : "planModeThinkingBudgetTokens"
+			StateManager.get().setSessionOverride(thinkingKey, thinkingBudget)
+		})
 		telemetryService.captureHostEvent("thinking_flag", "true")
 	}
 
@@ -180,14 +187,14 @@ function applyTaskOptions(options: TaskOptions): void {
 	if (reasoningEffort !== undefined) {
 		setModeScopedState(currentMode, (mode) => {
 			const reasoningKey = mode === "act" ? "actModeReasoningEffort" : "planModeReasoningEffort"
-			StateManager.get().setGlobalState(reasoningKey, reasoningEffort)
+			StateManager.get().setSessionOverride(reasoningKey, reasoningEffort)
 		})
 		telemetryService.captureHostEvent("reasoning_effort_flag", reasoningEffort)
 	}
 
 	const maxConsecutiveMistakes = normalizeMaxConsecutiveMistakes(options.maxConsecutiveMistakes)
 	if (maxConsecutiveMistakes !== undefined) {
-		StateManager.get().setGlobalState("maxConsecutiveMistakes", maxConsecutiveMistakes)
+		StateManager.get().setSessionOverride("maxConsecutiveMistakes", maxConsecutiveMistakes)
 		telemetryService.captureHostEvent("max_consecutive_mistakes_flag", String(maxConsecutiveMistakes))
 	}
 
@@ -198,11 +205,22 @@ function applyTaskOptions(options: TaskOptions): void {
 		telemetryService.captureHostEvent("yolo_flag", "true")
 	}
 
+	// Set auto-approve-all as a session-scoped override so CLI flag does not
+	// persist user settings to disk.
+	if (options.autoApproveAll) {
+		StateManager.get().setSessionOverride("autoApproveAllToggled", true)
+		telemetryService.captureHostEvent("auto_approve_all_flag", "true")
+	}
+
 	// Set double-check completion based on flag
 	if (options.doubleCheckCompletion) {
-		StateManager.get().setGlobalState("doubleCheckCompletionEnabled", true)
+		StateManager.get().setSessionOverride("doubleCheckCompletionEnabled", true)
 		telemetryService.captureHostEvent("double_check_completion_flag", "true")
 	}
+
+	if (options.autoCondense) {
+		StateManager.get().setSessionOverride("useAutoCondense", true)
+	}
 }
 
 /**
@@ -233,6 +251,36 @@ function getPlainTextModeReason(options: TaskOptions): string {
 	return getModeSelection(options).reason
 }
 
+function getNpxCommand(): string {
+	return process.platform === "win32" ? "npx.cmd" : "npx"
+}
+
+function runKanbanAlias(): void {
+	const child = spawn(getNpxCommand(), ["-y", "kanban", "--agent", "cline"], {
+		stdio: "inherit",
+	})
+
+	child.on("error", () => {
+		printWarning("Failed to run 'npx kanban --agent cline'. Make sure npx is installed and available in PATH.")
+		exit(1)
+	})
+
+	child.on("close", (code) => {
+		exit(code ?? 1)
+	})
+}
+
+async function addMcpServer(name: string, targetOrCommand: string[] = [], options: McpAddOptions): Promise<void> {
+	try {
+		const result = await addMcpServerShortcut(name, targetOrCommand, options)
+		const transportLabel = result.transportType === "streamableHttp" ? "http" : result.transportType
+		printInfo(`Added MCP server '${result.serverName}' (${transportLabel}) to ${result.settingsPath}`)
+	} catch (error) {
+		printWarning(error instanceof Error ? error.message : "Failed to add MCP server.")
+		exit(1)
+	}
+}
+
 /**
  * Run a task in plain text mode (no Ink UI).
  * Handles auth check, task execution, cleanup, and exit.
@@ -316,6 +364,42 @@ async function drainStdout(): Promise<void> {
 	})
 }
 
+export async function captureUnhandledException(reason: Error, context: string) {
+	try {
+		// ErrorService may not be initialized yet (e.g., error occurred before initializeCli())
+		// so we guard with a try/get pattern rather than letting ErrorService.get() throw
+		let errorService: ErrorService | null = null
+		try {
+			errorService = ErrorService.get()
+		} catch {
+			// ErrorService not yet initialized; skip capture
+		}
+		if (errorService) {
+			await errorService.captureException(reason, { context })
+			// dispose flushes any pending error captures to ensure they're sent before the process exits
+			return errorService.dispose()
+		}
+	} catch {
+		// Ignore errors during shutdown to avoid an infinite loop
+		Logger.info("Error capturing unhandled exception. Proceeding with shutdown.")
+	}
+}
+
+const EXIT_TIMEOUT_MS = 3000
+function onUnhandledException(reason: unknown, context: string) {
+	Logger.error("Unhandled exception:", reason)
+	const finalError = reason instanceof Error ? reason : new Error(String(reason))
+
+	restoreConsole()
+	console.error(finalError)
+
+	setTimeout(() => process.exit(1), EXIT_TIMEOUT_MS)
+
+	captureUnhandledException(finalError, context).finally(() => {
+		process.exit(1)
+	})
+}
+
 function setupSignalHandlers() {
 	const shutdown = async (signal: string) => {
 		if (isShuttingDown) {
@@ -353,7 +437,11 @@ function setupSignalHandlers() {
 				} catch {
 					// StateManager may not be initialized yet
 				}
-				await ErrorService.get().dispose()
+				try {
+					await ErrorService.get().dispose()
+				} catch {
+					// ErrorService may not be initialized yet
+				}
 				await disposeTelemetryServices()
 			}
 		} catch {
@@ -375,9 +463,14 @@ function setupSignalHandlers() {
 			Logger.info("Suppressed unhandled rejection due to abort:", message)
 			return
 		}
-		// For other unhandled rejections, log to file via Logger (if available)
+
+		// For other unhandled rejections, capture the exception and log to file via Logger (if available)
 		// This won't show in terminal but will be in log files for debugging
-		Logger.error("Unhandled rejection:", reason)
+		onUnhandledException(reason, "unhandledRejection")
+	})
+
+	process.on("uncaughtException", (reason: unknown) => {
+		onUnhandledException(reason, "uncaughtException")
 	})
 }
 
@@ -394,6 +487,7 @@ interface CliContext {
 interface InitOptions {
 	config?: string
 	cwd?: string
+	hooksDir?: string
 	verbose?: boolean
 	enableAuth?: boolean
 }
@@ -403,6 +497,7 @@ interface InitOptions {
  */
 async function initializeCli(options: InitOptions): Promise<CliContext> {
 	const workspacePath = options.cwd || process.cwd()
+	setRuntimeHooksDir(options.hooksDir)
 	const { extensionContext, storageContext, DATA_DIR, EXTENSION_DIR } = initializeCliContext({
 		clineDir: options.config,
 		workspaceDir: workspacePath,
@@ -504,6 +599,11 @@ async function runTask(prompt: string, options: TaskOptions & { images?: string[
 	// Task without prompt starts in interactive mode
 	telemetryService.captureHostEvent("task_command", prompt ? "task" : "interactive")
 
+	// Capture piped stdin telemetry now that HostProvider is initialized
+	if (options.stdinWasPiped) {
+		telemetryService.captureHostEvent("piped", "detached")
+	}
+
 	// Apply shared task options (mode, model, thinking, yolo)
 	applyTaskOptions(options)
 	await StateManager.get().flushPendingState()
@@ -596,7 +696,7 @@ async function showConfig(options: { config?: string }) {
 			dataDir: ctx.dataDir,
 			globalState: stateManager.getAllGlobalStateEntries(),
 			workspaceState: stateManager.getAllWorkspaceStateEntries(),
-			hooksEnabled: true,
+			hooksEnabled: getHooksEnabledSafe(stateManager.getGlobalSettingsKey("hooksEnabled")),
 			skillsEnabled: true,
 			isRawModeSupported: checkRawModeSupport(),
 		}),
@@ -728,6 +828,7 @@ program
 	.option("-a, --act", "Run in act mode")
 	.option("-p, --plan", "Run in plan mode")
 	.option("-y, --yolo", "Enable yes/yolo mode (auto-approve actions)")
+	.option("--auto-approve-all", "Enable auto-approve all actions while keeping interactive mode")
 	.option("-t, --timeout <seconds>", "Optional timeout in seconds (applies only when provided)")
 	.option("-m, --model <model>", "Model to use for the task")
 	.option("-v, --verbose", "Show verbose output")
@@ -738,6 +839,8 @@ program
 	.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes before halting in yolo mode")
 	.option("--json", "Output messages as JSON instead of styled text")
 	.option("--double-check-completion", "Reject first completion attempt to force re-verification")
+	.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
+	.option("--hooks-dir <path>", "Path to additional hooks directory for runtime hook injection")
 	.option("-T, --taskId <id>", "Resume an existing task by ID")
 	.action((prompt, options) => {
 		if (options.taskId) {
@@ -773,6 +876,18 @@ program
 	.option("--config <path>", "Path to Cline configuration directory")
 	.action(runAuth)
 
+const mcpCommand = program.command("mcp").description("Manage MCP servers")
+
+mcpCommand
+	.command("add")
+	.description("Add an MCP server shortcut to cline_mcp_settings.json")
+	.argument("<name>", "MCP server name")
+	.argument("[targetOrCommand...]", "For stdio: use -- <command> [args]. For http/sse: provide <url>.")
+	.option("--type <type>", "Transport type: stdio (default), http, or sse", "stdio")
+	.option("-c, --cwd <path>", "Working directory for config resolution")
+	.option("--config <path>", "Path to Cline configuration directory")
+	.action(addMcpServer)
+
 program
 	.command("version")
 	.description("Show Cline CLI version number")
@@ -784,6 +899,8 @@ program
 	.option("-v, --verbose", "Show verbose output")
 	.action(() => checkForUpdates(CLI_VERSION))
 
+program.command("kanban").description("Run npx kanban --agent cline").action(runKanbanAlias)
+
 // Dev command with subcommands
 const devCommand = program.command("dev").description("Developer tools and utilities")
 
@@ -808,8 +925,8 @@ function findTaskInHistory(taskId: string): HistoryItem | null {
  * Resume an existing task by ID
  * Loads the task and optionally prefills the input with a prompt
  */
-async function resumeTask(taskId: string, options: TaskOptions & { initialPrompt?: string }) {
-	const ctx = await initializeCli({ ...options, enableAuth: true })
+async function resumeTask(taskId: string, options: TaskOptions & { initialPrompt?: string }, existingContext?: CliContext) {
+	const ctx = existingContext || (await initializeCli({ ...options, enableAuth: true }))
 
 	// Validate task exists
 	const historyItem = findTaskInHistory(taskId)
@@ -822,6 +939,11 @@ async function resumeTask(taskId: string, options: TaskOptions & { initialPrompt
 
 	telemetryService.captureHostEvent("resume_task_command", options.initialPrompt ? "with_prompt" : "interactive")
 
+	// Capture piped stdin telemetry now that HostProvider is initialized
+	if (options.stdinWasPiped) {
+		telemetryService.captureHostEvent("piped", "detached")
+	}
+
 	// Apply shared task options (mode, model, thinking, yolo)
 	applyTaskOptions(options)
 	await StateManager.get().flushPendingState()
@@ -856,16 +978,35 @@ async function resumeTask(taskId: string, options: TaskOptions & { initialPrompt
 	)
 }
 
+async function continueTask(options: TaskOptions) {
+	const ctx = await initializeCli({ ...options, enableAuth: true })
+	const historyItem = findMostRecentTaskForWorkspace(StateManager.get().getGlobalStateKey("taskHistory"), ctx.workspacePath)
+
+	if (!historyItem) {
+		printWarning(`No previous task found for ${ctx.workspacePath}`)
+		printInfo("Start a new task or use 'cline history' to browse previous tasks.")
+		await disposeCliContext(ctx)
+		exit(1)
+	}
+
+	return resumeTask(historyItem.id, options, ctx)
+}
+
 /**
  * Show welcome prompt and wait for user input
  * If auth is not configured, show auth flow first
  */
-async function showWelcome(options: { verbose?: boolean; cwd?: string; config?: string; thinking?: boolean }) {
+async function showWelcome(options: TaskOptions) {
 	const ctx = await initializeCli({ ...options, enableAuth: true })
 
 	// Check if auth is configured
 	const hasAuth = await isAuthConfigured()
 
+	// Apply CLI task options in interactive startup too, so flags like
+	// --auto-approve-all and --yolo affect the initial TUI state.
+	applyTaskOptions(options)
+	await StateManager.get().flushPendingState()
+
 	let hadError = false
 
 	await runInkApp(
@@ -895,6 +1036,7 @@ program
 	.option("-a, --act", "Run in act mode")
 	.option("-p, --plan", "Run in plan mode")
 	.option("-y, --yolo", "Enable yolo mode (auto-approve actions)")
+	.option("--auto-approve-all", "Enable auto-approve all actions while keeping interactive mode")
 	.option("-t, --timeout <seconds>", "Optional timeout in seconds (applies only when provided)")
 	.option("-m, --model <model>", "Model to use for the task")
 	.option("-v, --verbose", "Show verbose output")
@@ -905,14 +1047,29 @@ program
 	.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes before halting in yolo mode")
 	.option("--json", "Output messages as JSON instead of styled text")
 	.option("--double-check-completion", "Reject first completion attempt to force re-verification")
+	.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
+	.option("--hooks-dir <path>", "Path to additional hooks directory for runtime hook injection")
 	.option("--acp", "Run in ACP (Agent Client Protocol) mode for editor integration")
+	.option("--kanban", "Run npx kanban --agent cline")
 	.option("-T, --taskId <id>", "Resume an existing task by ID")
+	.option("--continue", "Resume the most recent task from the current working directory")
 	.action(async (prompt, options) => {
+		if (options.kanban) {
+			if (prompt) {
+				printWarning("Use --kanban without a prompt.")
+				exit(1)
+			}
+
+			runKanbanAlias()
+			return
+		}
+
 		// Check for ACP mode first - this takes precedence over everything else
 		if (options.acp) {
 			await runAcpMode({
 				config: options.config,
 				cwd: options.cwd,
+				hooksDir: options.hooksDir,
 				verbose: options.verbose,
 			})
 			return
@@ -927,6 +1084,25 @@ program
 		// stdinInput has content means stdin was piped with data
 		const stdinWasPiped = stdinInput !== null
 
+		if (options.taskId && options.continue) {
+			printWarning("Use either --taskId or --continue, not both.")
+			exit(1)
+		}
+
+		if (options.continue) {
+			if (prompt) {
+				printWarning("Use --continue without a prompt.")
+				exit(1)
+			}
+			if (stdinWasPiped) {
+				printWarning("Use --continue without piped input.")
+				exit(1)
+			}
+
+			await continueTask(options)
+			return
+		}
+
 		// Error if stdin was piped but empty AND no prompt was provided
 		// This handles:
 		// - `echo "" | cline` -> error (empty stdin, no prompt)
@@ -947,8 +1123,6 @@ program
 				effectivePrompt = stdinInput
 			}
 
-			telemetryService.captureHostEvent("piped", "detached")
-
 			// Debug: show that we received piped input
 			if (options.verbose) {
 				process.stderr.write(`[debug] Received ${stdinInput.length} bytes from stdin\n`)
@@ -975,4 +1149,6 @@ program
 	})
 
 // Parse and run
-program.parse()
+if (process.env.VITEST !== "true") {
+	program.parse()
+}

cli/src/lib-import.test.ts

@@ -5,5 +5,5 @@ describe("library import side effects", () => {
 		const originalConsoleLog = console.log
 		await import("./exports")
 		expect(console.log).toBe(originalConsoleLog)
-	}, 10000)
+	}, 30000)
 })

cli/src/utils/mcp.test.ts

@@ -0,0 +1,63 @@
+import * as fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, describe, expect, it } from "vitest"
+import { addMcpServerShortcut } from "./mcp"
+
+const tempDirs: string[] = []
+
+async function createTempConfigDir(): Promise<string> {
+	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "cline-mcp-test-"))
+	tempDirs.push(dir)
+	return dir
+}
+
+type McpSettingsFile = {
+	mcpServers: Record<string, Record<string, unknown>>
+}
+
+async function readMcpSettings(configDir: string): Promise<McpSettingsFile> {
+	const settingsPath = path.join(configDir, "data", "settings", "cline_mcp_settings.json")
+	return JSON.parse(await fs.readFile(settingsPath, "utf-8")) as McpSettingsFile
+}
+
+afterEach(async () => {
+	for (const dir of tempDirs.splice(0, tempDirs.length)) {
+		await fs.rm(dir, { recursive: true, force: true })
+	}
+})
+
+describe("addMcpServerShortcut", () => {
+	it("writes stdio servers with type=stdio", async () => {
+		const configDir = await createTempConfigDir()
+
+		await addMcpServerShortcut("kanban", ["kanban", "mcp"], { config: configDir })
+		const settings = await readMcpSettings(configDir)
+
+		expect(settings.mcpServers.kanban).toEqual({
+			command: "kanban",
+			args: ["mcp"],
+			type: "stdio",
+		})
+	})
+
+	it("maps --type http to streamableHttp", async () => {
+		const configDir = await createTempConfigDir()
+
+		await addMcpServerShortcut("linear", ["https://mcp.linear.app/mcp"], { config: configDir, type: "http" })
+		const settings = await readMcpSettings(configDir)
+
+		expect(settings.mcpServers.linear).toEqual({
+			url: "https://mcp.linear.app/mcp",
+			type: "streamableHttp",
+		})
+	})
+
+	it("errors when URL is provided without --type http", async () => {
+		const configDir = await createTempConfigDir()
+
+		await expect(addMcpServerShortcut("linear", ["https://mcp.linear.app/mcp"], { config: configDir })).rejects.toThrow(
+			"Use --type http",
+		)
+	})
+})

cli/src/utils/mcp.ts

@@ -0,0 +1,159 @@
+import * as fs from "node:fs/promises"
+import path from "node:path"
+import { getMcpSettingsFilePath } from "@/core/storage/disk"
+import { ServerConfigSchema } from "@/services/mcp/schemas"
+import { initializeCliContext } from "../vscode-context"
+
+export interface McpAddOptions {
+	type?: string
+	config?: string
+	cwd?: string
+}
+
+export type McpAddTransportType = "stdio" | "streamableHttp" | "sse"
+
+export interface AddMcpServerResult {
+	serverName: string
+	transportType: McpAddTransportType
+	settingsPath: string
+}
+
+function normalizeMcpTransportType(value?: string): McpAddTransportType {
+	const normalized = (value || "stdio").trim().toLowerCase()
+
+	switch (normalized) {
+		case "stdio":
+			return "stdio"
+		case "http":
+		case "streamable-http":
+		case "streamablehttp":
+			return "streamableHttp"
+		case "sse":
+			return "sse"
+		default:
+			throw new Error(`Invalid MCP transport type '${value}'. Valid values: stdio, http, sse.`)
+	}
+}
+
+function parseMcpSettings(content: string, settingsPath: string): Record<string, unknown> {
+	const trimmedContent = content.trim()
+	if (!trimmedContent) {
+		return { mcpServers: {} }
+	}
+
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(content)
+	} catch {
+		throw new Error(`Invalid JSON in ${settingsPath}. Please fix the file and try again.`)
+	}
+
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error(`Invalid MCP settings file at ${settingsPath}. Expected a JSON object.`)
+	}
+
+	const settings = parsed as Record<string, unknown>
+	if (settings.mcpServers === undefined) {
+		settings.mcpServers = {}
+	}
+
+	if (!settings.mcpServers || typeof settings.mcpServers !== "object" || Array.isArray(settings.mcpServers)) {
+		throw new Error(`Invalid MCP settings file at ${settingsPath}. Expected 'mcpServers' to be an object.`)
+	}
+
+	return settings
+}
+
+function createMcpServerConfig(targetOrCommand: string[], transportType: McpAddTransportType): Record<string, unknown> {
+	if (transportType === "stdio") {
+		if (targetOrCommand.length < 1) {
+			throw new Error("Missing stdio command. Example: cline mcp add kanban -- kanban mcp")
+		}
+
+		// Guard against common mistake:
+		// `cline mcp add <name> <url>` without `--type http`
+		if (targetOrCommand.length === 1) {
+			const [value] = targetOrCommand
+			try {
+				const parsedUrl = new URL(value)
+				if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") {
+					throw new Error(
+						`Looks like you provided a URL for '${value}'. Use --type http, for example: cline mcp add <name> ${value} --type http`,
+					)
+				}
+			} catch (error) {
+				if (error instanceof Error && error.message.startsWith("Looks like you provided a URL")) {
+					throw error
+				}
+			}
+		}
+
+		const [command, ...args] = targetOrCommand
+		const config: Record<string, unknown> = {
+			command,
+			type: "stdio",
+		}
+
+		if (args.length > 0) {
+			config.args = args
+		}
+
+		ServerConfigSchema.parse(config)
+		return config
+	}
+
+	if (targetOrCommand.length !== 1) {
+		throw new Error(
+			"HTTP/SSE MCP servers require exactly one URL. Example: cline mcp add linear https://mcp.linear.app/mcp --type http",
+		)
+	}
+
+	const config = {
+		url: targetOrCommand[0],
+		type: transportType,
+	}
+
+	ServerConfigSchema.parse(config)
+	return config
+}
+
+export async function addMcpServerShortcut(
+	name: string,
+	targetOrCommand: string[] = [],
+	options: McpAddOptions,
+): Promise<AddMcpServerResult> {
+	const trimmedName = name.trim()
+	if (!trimmedName) {
+		throw new Error("Server name is required.")
+	}
+
+	const transportType = normalizeMcpTransportType(options.type)
+
+	const { DATA_DIR } = initializeCliContext({
+		clineDir: options.config,
+		workspaceDir: options.cwd || process.cwd(),
+	})
+
+	const settingsDirectoryPath = path.join(DATA_DIR, "settings")
+	await fs.mkdir(settingsDirectoryPath, { recursive: true })
+	const settingsPath = await getMcpSettingsFilePath(settingsDirectoryPath)
+
+	const content = await fs.readFile(settingsPath, "utf-8")
+	const settings = parseMcpSettings(content, settingsPath)
+	const mcpServers = settings.mcpServers as Record<string, unknown>
+
+	if (mcpServers[trimmedName]) {
+		throw new Error(`An MCP server named '${trimmedName}' already exists.`)
+	}
+
+	const serverConfig = createMcpServerConfig(targetOrCommand, transportType)
+	mcpServers[trimmedName] = serverConfig
+
+	await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8")
+
+	return {
+		serverName: trimmedName,
+		transportType,
+		settingsPath,
+	}
+}

cli/src/utils/provider-config.ts

@@ -7,6 +7,8 @@ import type { ApiProvider } from "@shared/api"
 import { getProviderModelIdKey, ProviderToApiKeyMap } from "@shared/storage"
 import { buildApiHandler } from "@/core/api"
 import type { Controller } from "@/core/controller"
+import { refreshOpenRouterModels } from "@/core/controller/models/refreshOpenRouterModels"
+import { refreshVercelAiGatewayModels } from "@/core/controller/models/refreshVercelAiGatewayModels"
 import { StateManager } from "@/core/storage/StateManager"
 import type { BedrockConfig } from "../components/BedrockSetup"
 import { getDefaultModelId } from "../components/ModelPicker"
@@ -40,14 +42,22 @@ export async function applyProviderConfig(options: ApplyProviderConfigOptions):
 		if (actModelKey) config[actModelKey] = finalModelId
 		if (planModelKey) config[planModelKey] = finalModelId
 
-		// For cline/openrouter, also set model info (required for getModel() to return correct model)
+		// Fetch model info from the provider API (not just disk cache) so headless
+		// CLI auth gets correct maxTokens, thinkingConfig, etc.
 		if ((providerId === "cline" || providerId === "openrouter") && controller) {
-			const openRouterModels = await controller.readOpenRouterModels()
+			const openRouterModels = await refreshOpenRouterModels(controller)
 			const modelInfo = openRouterModels?.[finalModelId]
 			if (modelInfo) {
 				stateManager.setGlobalState("actModeOpenRouterModelInfo", modelInfo)
 				stateManager.setGlobalState("planModeOpenRouterModelInfo", modelInfo)
 			}
+		} else if (providerId === "vercel-ai-gateway" && controller) {
+			const vercelModels = await refreshVercelAiGatewayModels(controller)
+			const modelInfo = vercelModels?.[finalModelId]
+			if (modelInfo) {
+				stateManager.setGlobalState("actModeVercelAiGatewayModelInfo", modelInfo)
+				stateManager.setGlobalState("planModeVercelAiGatewayModelInfo", modelInfo)
+			}
 		}
 	}
 

cli/src/utils/slash-commands.test.ts

@@ -0,0 +1,54 @@
+import type { SlashCommandInfo } from "@shared/proto/cline/slash"
+import { describe, expect, it } from "vitest"
+import { filterCommands, getStandaloneSlashCommandToExecute } from "./slash-commands"
+
+const createCommand = (name: string): SlashCommandInfo => ({
+	name,
+	description: `${name} command`,
+	section: "default",
+	cliCompatible: true,
+})
+
+describe("filterCommands", () => {
+	it("prioritizes exact matches ahead of fuzzy matches", () => {
+		const commands = [createCommand("help"), createCommand("history"), createCommand("q")]
+
+		const result = filterCommands(commands, "q")
+
+		expect(result.map((command) => command.name)[0]).toBe("q")
+	})
+
+	it("prioritizes prefix matches ahead of fuzzy matches", () => {
+		const commands = [createCommand("history"), createCommand("help"), createCommand("exit")]
+
+		const result = filterCommands(commands, "hi")
+
+		expect(result.map((command) => command.name)[0]).toBe("history")
+	})
+})
+
+describe("getStandaloneSlashCommandToExecute", () => {
+	it("ignores standalone execution when slash menu is visible", () => {
+		expect(
+			getStandaloneSlashCommandToExecute({
+				prompt: "/q",
+				inSlashMode: true,
+				hasSlashMenu: true,
+				hasPendingAsk: false,
+				isSpinnerActive: false,
+			}),
+		).toBeNull()
+	})
+
+	it("returns standalone command when enter should execute it directly", () => {
+		expect(
+			getStandaloneSlashCommandToExecute({
+				prompt: "/exit",
+				inSlashMode: false,
+				hasSlashMenu: false,
+				hasPendingAsk: false,
+				isSpinnerActive: false,
+			}),
+		).toBe("exit")
+	})
+})

cli/src/utils/slash-commands.ts

@@ -4,6 +4,7 @@
  */
 
 import type { SlashCommandInfo } from "@shared/proto/cline/slash"
+import { CLI_ONLY_COMMANDS } from "@shared/slashCommands"
 import { fuzzyFilter } from "./fuzzy-search"
 
 export interface SlashQueryInfo {
@@ -17,12 +18,29 @@ export interface VisibleWindow<T> {
 	startIndex: number
 }
 
+export interface StandaloneSlashCommandExecutionInput {
+	prompt: string
+	inSlashMode: boolean
+	hasSlashMenu: boolean
+	hasPendingAsk: boolean
+	isSpinnerActive: boolean
+}
+
+export function createCliOnlySlashCommands(): SlashCommandInfo[] {
+	return CLI_ONLY_COMMANDS.map((cmd) => ({
+		name: cmd.name,
+		description: cmd.description || "",
+		section: cmd.section || "default",
+		cliCompatible: true,
+	}))
+}
+
 /**
  * Calculate visible window for a scrollable list menu.
  * Centers the selected item in the visible window when possible.
  * Returns the visible items and the start index for selection tracking.
  */
-export function getVisibleWindow<T>(items: T[], selectedIndex: number, maxVisible: number = 5): VisibleWindow<T> {
+export function getVisibleWindow<T>(items: T[], selectedIndex: number, maxVisible = 5): VisibleWindow<T> {
 	if (items.length <= maxVisible) {
 		return { items, startIndex: 0 }
 	}
@@ -91,6 +109,42 @@ export function extractSlashQuery(text: string, cursorPosition?: number): SlashQ
 	}
 }
 
+/**
+ * Detect a standalone slash command (for example "/q" or "/exit")
+ * that should be executed immediately when enter is pressed.
+ */
+export function getStandaloneSlashCommandName(text: string): string | null {
+	const match = text.trim().match(/^\/([a-zA-Z0-9_.-]+)$/)
+	return match?.[1] ?? null
+}
+
+/**
+ * Resolve whether pressing Enter should execute a standalone CLI slash command.
+ * This keeps ChatView's key handling deterministic and easy to test.
+ */
+export function getStandaloneSlashCommandToExecute({
+	prompt,
+	inSlashMode,
+	hasSlashMenu,
+	hasPendingAsk,
+	isSpinnerActive,
+}: StandaloneSlashCommandExecutionInput): string | null {
+	const standaloneSlashCommand = getStandaloneSlashCommandName(prompt)
+	if (!standaloneSlashCommand) {
+		return null
+	}
+
+	if (hasPendingAsk || isSpinnerActive) {
+		return null
+	}
+
+	if (inSlashMode && hasSlashMenu) {
+		return null
+	}
+
+	return standaloneSlashCommand
+}
+
 /**
  * Filter commands using fuzzy matching
  */
@@ -98,7 +152,26 @@ export function filterCommands(commands: SlashCommandInfo[], query: string): Sla
 	if (!query) {
 		return commands
 	}
-	return fuzzyFilter(commands, query, (cmd) => cmd.name)
+
+	const normalizedQuery = query.toLowerCase()
+	const exactMatches: SlashCommandInfo[] = []
+	const prefixMatches: SlashCommandInfo[] = []
+	const remaining: SlashCommandInfo[] = []
+
+	for (const command of commands) {
+		const normalizedName = command.name.toLowerCase()
+		if (normalizedName === normalizedQuery) {
+			exactMatches.push(command)
+			continue
+		}
+		if (normalizedName.startsWith(normalizedQuery)) {
+			prefixMatches.push(command)
+			continue
+		}
+		remaining.push(command)
+	}
+
+	return [...exactMatches, ...prefixMatches, ...fuzzyFilter(remaining, query, (cmd) => cmd.name)]
 }
 
 /**

cli/src/utils/task-history.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest"
+import { findMostRecentTaskForWorkspace } from "./task-history"
+
+describe("findMostRecentTaskForWorkspace", () => {
+	it("returns the newest matching task for the workspace", () => {
+		const result = findMostRecentTaskForWorkspace(
+			[
+				{
+					id: "older",
+					ts: 100,
+					task: "Older task",
+					tokensIn: 0,
+					tokensOut: 0,
+					totalCost: 0,
+					cwdOnTaskInitialization: "/repo",
+				},
+				{
+					id: "newer",
+					ts: 200,
+					task: "Newer task",
+					tokensIn: 0,
+					tokensOut: 0,
+					totalCost: 0,
+					cwdOnTaskInitialization: "/repo",
+				},
+			],
+			"/repo",
+		)
+
+		expect(result?.id).toBe("newer")
+	})
+
+	it("falls back to shadowGitConfigWorkTree for older tasks", () => {
+		const result = findMostRecentTaskForWorkspace(
+			[
+				{
+					id: "legacy",
+					ts: 200,
+					task: "Legacy task",
+					tokensIn: 0,
+					tokensOut: 0,
+					totalCost: 0,
+					shadowGitConfigWorkTree: "/repo",
+				},
+			],
+			"/repo",
+		)
+
+		expect(result?.id).toBe("legacy")
+	})
+
+	it("returns null when there is no match", () => {
+		const result = findMostRecentTaskForWorkspace(
+			[
+				{
+					id: "other",
+					ts: 200,
+					task: "Other task",
+					tokensIn: 0,
+					tokensOut: 0,
+					totalCost: 0,
+					cwdOnTaskInitialization: "/other",
+				},
+			],
+			"/repo",
+		)
+
+		expect(result).toBeNull()
+	})
+})

cli/src/utils/task-history.ts

@@ -0,0 +1,27 @@
+import { HistoryItem } from "@shared/HistoryItem"
+import { arePathsEqual } from "@/utils/path"
+
+export function findMostRecentTaskForWorkspace(
+	taskHistory: HistoryItem[] | undefined,
+	workspacePath: string,
+): HistoryItem | null {
+	if (!taskHistory?.length) {
+		return null
+	}
+
+	return (
+		[...taskHistory]
+			.filter((item) => {
+				if (!item.ts || !item.task) {
+					return false
+				}
+
+				return Boolean(
+					(item.cwdOnTaskInitialization && arePathsEqual(item.cwdOnTaskInitialization, workspacePath)) ||
+						(item.shadowGitConfigWorkTree && arePathsEqual(item.shadowGitConfigWorkTree, workspacePath)),
+				)
+			})
+			.sort((a, b) => b.ts - a.ts)
+			.at(0) ?? null
+	)
+}

docs/api/authentication.mdx

@@ -0,0 +1,137 @@
+---
+title: "Authentication"
+sidebarTitle: "Authentication"
+description: "How to authenticate with the Cline API using API keys or account tokens."
+---
+
+Every request to the Cline API requires authentication via a Bearer token in the `Authorization` header.
+
+## Authentication Methods
+
+There are two ways to authenticate:
+
+| Method | Use case | How to get it |
+|--------|----------|---------------|
+| **API key** | Direct API calls, scripts, CI/CD | Create at [app.cline.bot](https://app.cline.bot) Settings > API Keys |
+| **Account auth token** | Cline extension and CLI | Generated automatically when you sign in |
+
+Both methods use the same header format:
+
+```bash
+Authorization: Bearer YOUR_TOKEN
+```
+
+## API Keys
+
+API keys are the recommended authentication method for programmatic access.
+
+### Creating a Key
+
+<Steps>
+  <Step title="Sign in">
+    Go to [app.cline.bot](https://app.cline.bot) and sign in.
+  </Step>
+  <Step title="Open API Keys">
+    Navigate to **Settings** > **API Keys**.
+  </Step>
+  <Step title="Create and copy">
+    Create a new key. Copy it immediately as you will not be able to see it again.
+  </Step>
+</Steps>
+
+### Deleting a Key
+
+You can revoke an API key at any time from the same Settings > API Keys page. Deleted keys stop working immediately.
+
+You can also manage keys programmatically through the [Enterprise API](/enterprise-solutions/api-reference#api-keys):
+
+```bash
+# List your keys
+curl https://api.cline.bot/api/v1/api-keys \
+  -H "Authorization: Bearer YOUR_TOKEN"
+
+# Delete a key
+curl -X DELETE https://api.cline.bot/api/v1/api-keys/KEY_ID \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+## Account Auth Tokens
+
+When you sign in to the Cline extension (VS Code, JetBrains) or CLI, an account auth token is generated and managed automatically. You do not need to handle these tokens manually.
+
+The Cline CLI uses these tokens when you authenticate via:
+
+```bash
+# Interactive sign-in
+cline auth
+
+# Or quick setup with an API key
+cline auth -p cline -k "YOUR_API_KEY" -m anthropic/claude-sonnet-4-6
+```
+
+See the [CLI Reference](/cline-cli/cli-reference#cline-auth) for all auth options.
+
+## Security Best Practices
+
+**Do:**
+- Store API keys in environment variables or a secrets manager
+- Use different keys for development and production
+- Rotate keys periodically
+- Delete keys you no longer use
+
+**Do not:**
+- Commit keys to version control
+- Share keys in chat or email
+- Embed keys in client-side code (browsers, mobile apps)
+- Log keys in application output
+
+### Using Environment Variables
+
+```bash
+# Set the key
+export CLINE_API_KEY="your_api_key_here"
+
+# Use it in requests
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model": "anthropic/claude-sonnet-4-6", "messages": [{"role": "user", "content": "Hello"}]}'
+```
+
+### Using a .env File
+
+```bash
+# .env (add to .gitignore)
+CLINE_API_KEY=your_api_key_here
+```
+
+```python
+import os
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key=os.environ["CLINE_API_KEY"],
+)
+```
+
+## Custom Headers
+
+The Cline API accepts optional headers for tracking and identification:
+
+| Header | Description |
+|--------|-------------|
+| `HTTP-Referer` | Your application's URL. Helps with usage tracking. |
+| `X-Title` | Your application's name. Appears in usage logs. |
+| `X-Task-ID` | A unique task identifier. Used internally by the Cline extension. |
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Getting Started" icon="rocket" href="/api/getting-started">
+    Create your first API key and make a request.
+  </Card>
+  <Card title="Enterprise API Keys" icon="building" href="/enterprise-solutions/api-reference#api-keys">
+    Manage API keys programmatically.
+  </Card>
+</CardGroup>

docs/api/chat-completions.mdx

@@ -0,0 +1,258 @@
+---
+title: "Chat Completions"
+sidebarTitle: "Chat Completions"
+description: "Full reference for the POST /chat/completions endpoint including all parameters, streaming, and tool calling."
+---
+
+The Chat Completions endpoint generates model responses from a conversation. It follows the [OpenAI Chat Completions](https://platform.openai.com/docs/api-reference/chat/create) format.
+
+## Endpoint
+
+```
+POST https://api.cline.bot/api/v1/chat/completions
+```
+
+## Request Headers
+
+| Header | Required | Description |
+|--------|----------|-------------|
+| `Authorization` | Yes | `Bearer YOUR_API_KEY` |
+| `Content-Type` | Yes | `application/json` |
+| `HTTP-Referer` | No | Your application URL (for usage tracking) |
+| `X-Title` | No | Your application name (for usage logs) |
+
+## Request Body
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `model` | string | Yes | | Model ID in `provider/model` format. See [Models](/api/models). |
+| `messages` | array | Yes | | Conversation messages. Each has `role` (`system`, `user`, `assistant`) and `content`. |
+| `stream` | boolean | No | `true` | Return the response as a stream of Server-Sent Events. |
+| `tools` | array | No | | Tool/function definitions in OpenAI format. |
+| `temperature` | number | No | Model default | Sampling temperature (0.0 to 2.0). Lower values are more deterministic. |
+
+### Message Format
+
+Each message in the `messages` array has this structure:
+
+```json
+{
+  "role": "user",
+  "content": "Your message here"
+}
+```
+
+**Roles:**
+
+| Role | Purpose |
+|------|---------|
+| `system` | Sets the model's behavior and persona. Place first in the array. |
+| `user` | The human's input. |
+| `assistant` | Previous model responses (for multi-turn conversations). |
+
+### Multi-Turn Conversation
+
+Include previous messages to maintain context:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {"role": "system", "content": "You are a helpful coding assistant."},
+    {"role": "user", "content": "What is a closure in JavaScript?"},
+    {"role": "assistant", "content": "A closure is a function that..."},
+    {"role": "user", "content": "Can you show me an example?"}
+  ]
+}
+```
+
+## Streaming Response
+
+When `stream: true` (the default), the response is a series of [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-Sent_Events):
+
+```
+data: {"id":"gen-abc123","choices":[{"delta":{"role":"assistant"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":"The capital"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":" of France"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":" is Paris."},"index":0,"finish_reason":"stop"}],"model":"anthropic/claude-sonnet-4-6","usage":{"prompt_tokens":14,"completion_tokens":8,"cost":0.000066}}
+
+data: [DONE]
+```
+
+Each `data:` line contains a JSON chunk. Key fields:
+
+| Field | Description |
+|-------|-------------|
+| `id` | Generation ID, consistent across all chunks |
+| `choices[0].delta.content` | The new text in this chunk |
+| `choices[0].delta.reasoning` | Reasoning/thinking content (for reasoning models) |
+| `choices[0].finish_reason` | `stop` when complete, `error` on failure |
+| `usage` | Token counts and cost (included in the final chunk) |
+
+### Usage Object
+
+The final chunk includes token usage and cost:
+
+```json
+{
+  "usage": {
+    "prompt_tokens": 25,
+    "completion_tokens": 42,
+    "prompt_tokens_details": {
+      "cached_tokens": 0
+    },
+    "cost": 0.000315
+  }
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `prompt_tokens` | Total input tokens |
+| `completion_tokens` | Total output tokens |
+| `prompt_tokens_details.cached_tokens` | Tokens served from cache (reduces cost) |
+| `cost` | Total cost in USD for this request |
+
+## Non-Streaming Response
+
+When `stream: false`, the response is a single JSON object:
+
+```json
+{
+  "id": "gen-abc123",
+  "model": "anthropic/claude-sonnet-4-6",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "The capital of France is Paris."
+      },
+      "finish_reason": "stop",
+      "index": 0
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 14,
+    "completion_tokens": 8
+  }
+}
+```
+
+## Tool Calling
+
+You can define tools that the model can call using the OpenAI function calling format:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {"role": "user", "content": "What's the weather in San Francisco?"}
+  ],
+  "tools": [
+    {
+      "type": "function",
+      "function": {
+        "name": "get_weather",
+        "description": "Get the current weather for a location",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "location": {
+              "type": "string",
+              "description": "City and state, e.g. San Francisco, CA"
+            }
+          },
+          "required": ["location"]
+        }
+      }
+    }
+  ]
+}
+```
+
+When the model decides to call a tool, the response includes a `tool_calls` array:
+
+```json
+{
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "tool_calls": [
+          {
+            "id": "call_abc123",
+            "type": "function",
+            "function": {
+              "name": "get_weather",
+              "arguments": "{\"location\": \"San Francisco, CA\"}"
+            }
+          }
+        ]
+      },
+      "finish_reason": "tool_calls"
+    }
+  ]
+}
+```
+
+To continue the conversation after a tool call, include the tool result:
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "What's the weather in San Francisco?"},
+    {"role": "assistant", "tool_calls": [{"id": "call_abc123", "type": "function", "function": {"name": "get_weather", "arguments": "{\"location\": \"San Francisco, CA\"}"}}]},
+    {"role": "tool", "tool_call_id": "call_abc123", "content": "{\"temperature\": 62, \"condition\": \"foggy\"}"},
+  ]
+}
+```
+
+## Reasoning Models
+
+Some models support extended thinking (reasoning). When using these models, the response may include reasoning content in the streaming delta:
+
+```json
+{"choices":[{"delta":{"reasoning":"Let me think about this step by step..."}}]}
+```
+
+Reasoning tokens are separate from the main content and appear in the `delta.reasoning` field. Some providers return encrypted reasoning blocks via `delta.reasoning_details` that can be passed back in subsequent requests to preserve the reasoning trace.
+
+<Note>
+  Not all models support reasoning. See [Models](/api/models) for which models have reasoning capabilities.
+</Note>
+
+## Complete Example
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "system", "content": "You are a concise assistant. Answer in one sentence."},
+      {"role": "user", "content": "Explain what an API is."}
+    ],
+    "stream": true
+  }'
+```
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models and their capabilities.
+  </Card>
+  <Card title="Errors" icon="triangle-exclamation" href="/api/errors">
+    Handle errors and implement retry logic.
+  </Card>
+  <Card title="SDK Examples" icon="code" href="/api/sdk-examples">
+    Use this endpoint from Python, Node.js, and more.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API key management and security practices.
+  </Card>
+</CardGroup>

docs/api/errors.mdx

@@ -0,0 +1,152 @@
+---
+title: "Errors"
+sidebarTitle: "Errors"
+description: "Error codes, error formats, mid-stream errors, and retry strategies for the Cline API."
+---
+
+The Cline API returns errors in a consistent JSON format. Understanding these errors helps you build reliable integrations.
+
+## Error Format
+
+All errors follow the OpenAI error format:
+
+```json
+{
+  "error": {
+    "code": 401,
+    "message": "Invalid API key",
+    "metadata": {}
+  }
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `code` | number/string | HTTP status code or error identifier |
+| `message` | string | Human-readable description of the error |
+| `metadata` | object | Additional context (provider details, request IDs) |
+
+## Error Codes
+
+### HTTP Errors
+
+These are returned as the HTTP response status code and in the error body:
+
+| Code | Name | Cause | What to do |
+|------|------|-------|------------|
+| `400` | Bad Request | Malformed request body, missing required fields | Check your JSON syntax and required parameters |
+| `401` | Unauthorized | Invalid or missing API key | Verify your API key in the `Authorization` header |
+| `402` | Payment Required | Insufficient credits | Add credits at [app.cline.bot](https://app.cline.bot) |
+| `403` | Forbidden | Key does not have access to this resource | Check key permissions |
+| `404` | Not Found | Invalid endpoint or model ID | Verify the URL and model ID format |
+| `429` | Too Many Requests | Rate limit exceeded | Wait and retry with exponential backoff |
+| `500` | Internal Server Error | Server-side issue | Retry after a short delay |
+| `502` | Bad Gateway | Upstream provider error | Retry after a short delay |
+| `503` | Service Unavailable | Service temporarily down | Retry after a short delay |
+
+### Mid-Stream Errors
+
+When streaming, errors can occur after the response has started. These appear as a chunk with `finish_reason: "error"`:
+
+```json
+{
+  "choices": [
+    {
+      "finish_reason": "error",
+      "error": {
+        "code": "context_length_exceeded",
+        "message": "The input exceeds the model's maximum context length."
+      }
+    }
+  ]
+}
+```
+
+Common mid-stream error codes:
+
+| Code | Meaning |
+|------|---------|
+| `context_length_exceeded` | Input tokens exceed the model's context window |
+| `content_filter` | Content was blocked by a safety filter |
+| `rate_limit` | Rate limit hit during generation |
+| `server_error` | Upstream provider failed during generation |
+
+<Warning>
+  Mid-stream errors do not produce an HTTP error code (the connection was already 200 OK). Always check `finish_reason` in your streaming handler.
+</Warning>
+
+## Retry Strategies
+
+### Exponential Backoff
+
+For transient errors (429, 500, 502, 503), retry with exponential backoff:
+
+```python
+import time
+import requests
+
+def call_api_with_retry(payload, max_retries=3):
+    for attempt in range(max_retries):
+        response = requests.post(
+            "https://api.cline.bot/api/v1/chat/completions",
+            headers={
+                "Authorization": "Bearer YOUR_API_KEY",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+
+        if response.status_code == 200:
+            return response.json()
+
+        if response.status_code in (429, 500, 502, 503):
+            delay = (2 ** attempt) + 1
+            print(f"Retrying in {delay}s (attempt {attempt + 1}/{max_retries})")
+            time.sleep(delay)
+            continue
+
+        # Non-retryable error
+        response.raise_for_status()
+
+    raise Exception("Max retries exceeded")
+```
+
+### When to Retry
+
+| Error | Retry? | Strategy |
+|-------|--------|----------|
+| `401 Unauthorized` | No | Fix your API key |
+| `402 Payment Required` | No | Add credits |
+| `429 Too Many Requests` | Yes | Exponential backoff (start at 1s) |
+| `500 Internal Server Error` | Yes | Retry once after 1s |
+| `502 Bad Gateway` | Yes | Retry up to 3 times with backoff |
+| `503 Service Unavailable` | Yes | Retry up to 3 times with backoff |
+| Mid-stream `error` | Depends | Retry the full request for transient errors |
+
+### Rate Limits
+
+If you hit rate limits frequently:
+
+- Add delays between requests
+- Reduce the number of concurrent requests
+- Contact support if you need higher limits
+
+## Debugging
+
+When reporting issues, include:
+
+1. The **error code and message** from the response
+2. The **model ID** you were using
+3. The **request ID** (from the `x-request-id` response header, if available)
+4. Whether the error was **immediate** (HTTP error) or **mid-stream** (finish_reason error)
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Endpoint reference with request and response schemas.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    Verify your API key is configured correctly.
+  </Card>
+</CardGroup>

docs/api/getting-started.mdx

@@ -0,0 +1,136 @@
+---
+title: "Getting Started"
+sidebarTitle: "Getting Started"
+description: "Create an API key and make your first request to the Cline API in under a minute."
+---
+
+This guide walks you through creating an API key and making your first Chat Completions request.
+
+## Prerequisites
+
+- A Cline account at [app.cline.bot](https://app.cline.bot)
+- `curl` or any HTTP client (Python, Node.js, etc.)
+
+## Create an API Key
+
+<Steps>
+  <Step title="Sign in to app.cline.bot">
+    Go to [app.cline.bot](https://app.cline.bot) and sign in with your account.
+  </Step>
+  <Step title="Navigate to API Keys">
+    Open **Settings** and select **API Keys**.
+  </Step>
+  <Step title="Create a new key">
+    Click **Create API Key**. Copy the key immediately. You will not be able to see it again after leaving this page.
+  </Step>
+</Steps>
+
+<Warning>
+  Treat your API key like a password. Do not commit it to version control or share it publicly.
+</Warning>
+
+## Make Your First Request
+
+Replace `YOUR_API_KEY` with the key you just created:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "user", "content": "What is the capital of France?"}
+    ],
+    "stream": false
+  }'
+```
+
+## Verify the Response
+
+You should get a JSON response like this:
+
+```json
+{
+  "id": "gen-abc123",
+  "model": "anthropic/claude-sonnet-4-6",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "The capital of France is Paris."
+      },
+      "finish_reason": "stop",
+      "index": 0
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 14,
+    "completion_tokens": 8
+  }
+}
+```
+
+The `choices[0].message.content` field contains the model's reply. The `usage` field shows how many tokens were consumed.
+
+## Try Streaming
+
+For real-time output, set `stream: true`. The response arrives as Server-Sent Events:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "user", "content": "Write a haiku about programming."}
+    ],
+    "stream": true
+  }'
+```
+
+Each chunk arrives as a `data:` line. The stream ends with `data: [DONE]`.
+
+## Try a Free Model
+
+To test without spending credits, use one of the [free models](/api/models#free-models):
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "minimax/minimax-m2.5",
+    "messages": [
+      {"role": "user", "content": "Hello! What can you help me with?"}
+    ],
+    "stream": false
+  }'
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `401 Unauthorized` | Check that your API key is correct and included in the `Authorization` header |
+| `402 Payment Required` | Your account has insufficient credits. Add credits at [app.cline.bot](https://app.cline.bot) |
+| Empty response | Make sure `messages` is a non-empty array with at least one user message |
+| Connection timeout | Verify your network can reach `api.cline.bot`. Check proxy settings if on a corporate network |
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    Learn about API keys, token scoping, and security practices.
+  </Card>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with all parameters and options.
+  </Card>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models and find the right one for your use case.
+  </Card>
+  <Card title="SDK Examples" icon="code" href="/api/sdk-examples">
+    Use the API from Python, Node.js, or the Cline CLI.
+  </Card>
+</CardGroup>

docs/api/models.mdx

@@ -0,0 +1,114 @@
+---
+title: "Models"
+sidebarTitle: "Models"
+description: "Available models, pricing tiers, free models, and how model IDs work in the Cline API."
+---
+
+The Cline API gives you access to models from multiple providers through a single endpoint. Model IDs follow the `provider/model-name` format, the same convention used by [OpenRouter](https://openrouter.ai).
+
+## Model ID Format
+
+Every model is identified by a string in the format:
+
+```
+provider/model-name
+```
+
+For example:
+- `anthropic/claude-sonnet-4-6` - Claude Sonnet 4.6 from Anthropic
+- `openai/gpt-4o` - GPT-4o from OpenAI
+- `google/gemini-2.5-pro` - Gemini 2.5 Pro from Google
+
+Pass this string as the `model` parameter in your [Chat Completions](/api/chat-completions) request.
+
+## Popular Models
+
+| Model ID | Provider | Context Window | Reasoning | Best For |
+|----------|----------|---------------|-----------|----------|
+| `anthropic/claude-sonnet-4-6` | Anthropic | 200K | Yes | General coding, analysis, complex tasks |
+| `anthropic/claude-sonnet-4-5` | Anthropic | 200K | Yes | Balanced performance and cost |
+| `openai/gpt-4o` | OpenAI | 128K | No | Multimodal tasks, fast responses |
+| `google/gemini-2.5-pro` | Google | 1M | Yes | Very long context, document analysis |
+| `deepseek/deepseek-chat` | DeepSeek | 64K | No | Cost-effective coding tasks |
+| `x-ai/grok-3` | xAI | 128K | Yes | Reasoning-heavy tasks |
+
+<Note>
+  Model availability and pricing change over time. Check [app.cline.bot](https://app.cline.bot) for the latest catalog.
+</Note>
+
+## Free Models
+
+These models are available at no cost. They are a good starting point for experimentation and lightweight tasks:
+
+| Model ID | Provider | Context Window |
+|----------|----------|---------------|
+| `minimax/minimax-m2.5` | MiniMax | 1M |
+| `kwaipilot/kat-coder-pro` | Kwaipilot | 32K |
+| `z-ai/glm-5` | Z-AI | 128K |
+
+Free models have the same API interface as paid models. Just use their model ID:
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "minimax/minimax-m2.5",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+## Reasoning Models
+
+Some models support extended thinking, where the model reasons through a problem before responding. When using these models:
+
+- Reasoning content appears in `delta.reasoning` during streaming
+- Some providers return encrypted reasoning blocks in `delta.reasoning_details`
+- Reasoning tokens are counted separately from output tokens
+
+Models with reasoning support include most Claude, Gemini 2.5, and Grok 3 models. Check the model's `supportsReasoning` capability in the model catalog.
+
+## Choosing a Model
+
+| If you need... | Consider |
+|----------------|----------|
+| Best coding performance | `anthropic/claude-sonnet-4-6` |
+| Long document analysis | `google/gemini-2.5-pro` (1M context) |
+| Fast, cheap responses | `deepseek/deepseek-chat` |
+| Free experimentation | `minimax/minimax-m2.5` |
+| Multi-modal (text + images) | `openai/gpt-4o` or `anthropic/claude-sonnet-4-6` |
+| Complex reasoning | Any model with reasoning support |
+
+For a deeper comparison of model capabilities and pricing, see the [Model Selection Guide](/core-features/model-selection-guide).
+
+## Image Support
+
+Models that support images accept base64-encoded image content in the `messages` array:
+
+```json
+{
+  "model": "anthropic/claude-sonnet-4-6",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "What's in this image?"},
+        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
+      ]
+    }
+  ]
+}
+```
+
+Not all models support images. Check the model's `supportsImages` capability before sending image content.
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Use these models in your API requests.
+  </Card>
+  <Card title="Model Selection Guide" icon="scale-balanced" href="/core-features/model-selection-guide">
+    In-depth comparison for choosing the right model.
+  </Card>
+</CardGroup>

docs/api/overview.mdx

@@ -0,0 +1,58 @@
+---
+title: "Cline API"
+sidebarTitle: "Overview"
+description: "Programmatic access to AI models through an OpenAI-compatible Chat Completions API."
+---
+
+Welcome to the Cline API documentation. Use the same models that power the Cline extension and CLI from any language, framework, or tool that speaks the OpenAI format.
+
+## What is the Cline API?
+
+The Cline API is an OpenAI-compatible Chat Completions endpoint. You authenticate once with a Cline API key and get access to models from Anthropic, OpenAI, Google, and more through a single base URL. No need to manage separate keys for each provider.
+
+```
+Your App  →  Cline API (api.cline.bot)  →  Anthropic / OpenAI / Google / etc.
+```
+
+<CardGroup cols={2}>
+  <Card title="Getting Started" icon="rocket" href="/api/getting-started">
+    Create an API key and make your first request in under a minute.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API keys, account tokens, key rotation, and security best practices.
+  </Card>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with request schemas, streaming, and tool calling.
+  </Card>
+  <Card title="SDK Examples" icon="code" href="/api/sdk-examples">
+    Ready-to-copy examples for Python, Node.js, curl, and the Cline CLI.
+  </Card>
+</CardGroup>
+
+## Explore the Reference
+
+<CardGroup cols={3}>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models, free tier options, reasoning support, and selection guidance.
+  </Card>
+  <Card title="Errors" icon="triangle-exclamation" href="/api/errors">
+    Error codes, mid-stream errors, retry strategies, and debugging tips.
+  </Card>
+  <Card title="Enterprise API" icon="building" href="/enterprise-solutions/api-reference">
+    Admin endpoints for managing users, organizations, billing, and API keys.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+Get your API key at [app.cline.bot](https://app.cline.bot) (Settings > API Keys), then follow the [Getting Started](/api/getting-started) guide.

docs/api/reference.mdx

@@ -0,0 +1,257 @@
+---
+title: "Cline API Reference"
+sidebarTitle: "API Reference"
+description: "Reference for the Cline Chat Completions API, an OpenAI-compatible endpoint for programmatic access."
+---
+
+The Cline API provides an OpenAI-compatible Chat Completions endpoint. You can use it from the Cline extension, the CLI, or any HTTP client that speaks the OpenAI format.
+
+## Base URL
+
+```
+https://api.cline.bot/api/v1
+```
+
+## Authentication
+
+All requests require a Bearer token in the `Authorization` header. You can use either:
+
+- **API key** created at [app.cline.bot](https://app.cline.bot) (Settings > API Keys)
+- **Account auth token** (used automatically by the Cline extension and CLI when you sign in)
+
+```bash
+Authorization: Bearer YOUR_API_KEY
+```
+
+### Getting an API Key
+
+<Steps>
+  <Step title="Go to app.cline.bot">
+    Open [app.cline.bot](https://app.cline.bot) and sign in.
+  </Step>
+  <Step title="Open Settings > API Keys">
+    Navigate to **Settings**, then **API Keys**.
+  </Step>
+  <Step title="Create and copy your key">
+    Create a new key and copy it. Store it securely. You will not be able to see it again.
+  </Step>
+</Steps>
+
+## Chat Completions
+
+Create a chat completion with streaming support. This endpoint follows the [OpenAI Chat Completions](https://platform.openai.com/docs/api-reference/chat/create) format.
+
+### Request
+
+```
+POST /chat/completions
+```
+
+**Headers:**
+
+| Header | Required | Description |
+|--------|----------|-------------|
+| `Authorization` | Yes | `Bearer YOUR_API_KEY` |
+| `Content-Type` | Yes | `application/json` |
+| `HTTP-Referer` | No | Your application URL |
+| `X-Title` | No | Your application name |
+
+**Body parameters:**
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `model` | string | Yes | Model ID in `provider/model` format (e.g., `anthropic/claude-sonnet-4-6`) |
+| `messages` | array | Yes | Array of message objects with `role` and `content` |
+| `stream` | boolean | No | Enable SSE streaming (default: `true`) |
+| `tools` | array | No | Tool definitions in OpenAI function calling format |
+| `temperature` | number | No | Sampling temperature |
+
+### Example Request
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [
+      {"role": "system", "content": "You are a helpful assistant."},
+      {"role": "user", "content": "Explain what a context window is in 2 sentences."}
+    ],
+    "stream": true
+  }'
+```
+
+### Response (Streaming)
+
+When `stream: true`, the response is a series of [Server-Sent Events](https://developer.mozilla.org/en-US/docs/Web/API/Server-Sent_Events). Each event contains a JSON chunk:
+
+```json
+data: {"id":"gen-abc123","choices":[{"delta":{"content":"A context"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: {"id":"gen-abc123","choices":[{"delta":{"content":" window is"},"index":0}],"model":"anthropic/claude-sonnet-4-6"}
+
+data: [DONE]
+```
+
+The final chunk includes a `usage` object with token counts and cost:
+
+```json
+{
+  "usage": {
+    "prompt_tokens": 25,
+    "completion_tokens": 42,
+    "prompt_tokens_details": {
+      "cached_tokens": 0
+    },
+    "cost": 0.000315
+  }
+}
+```
+
+### Response (Non-Streaming)
+
+When `stream: false`, the response is a single JSON object:
+
+```json
+{
+  "id": "gen-abc123",
+  "model": "anthropic/claude-sonnet-4-6",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "A context window is the maximum amount of text..."
+      },
+      "finish_reason": "stop",
+      "index": 0
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 25,
+    "completion_tokens": 42
+  }
+}
+```
+
+## Models
+
+Model IDs use the `provider/model-name` format, the same format used by [OpenRouter](https://openrouter.ai). Some examples:
+
+| Model ID | Description |
+|----------|-------------|
+| `anthropic/claude-sonnet-4-6` | Claude Sonnet 4.6 |
+| `anthropic/claude-sonnet-4-5` | Claude Sonnet 4.5 |
+| `google/gemini-2.5-pro` | Gemini 2.5 Pro |
+| `openai/gpt-4o` | GPT-4o |
+
+### Free Models
+
+The following models are available at no cost:
+
+| Model ID | Provider |
+|----------|----------|
+| `minimax/minimax-m2.5` | MiniMax |
+| `kwaipilot/kat-coder-pro` | Kwaipilot |
+| `z-ai/glm-5` | Z-AI |
+
+<Note>
+  Model availability and pricing may change. Check [app.cline.bot](https://app.cline.bot) for the latest list.
+</Note>
+
+## Error Handling
+
+Errors follow the OpenAI error format:
+
+```json
+{
+  "error": {
+    "code": 401,
+    "message": "Invalid API key",
+    "metadata": {}
+  }
+}
+```
+
+Common error codes:
+
+| Code | Meaning |
+|------|---------|
+| `401` | Invalid or missing API key |
+| `402` | Insufficient credits |
+| `429` | Rate limit exceeded |
+| `500` | Server error |
+| `error` (finish_reason) | Mid-stream error from the upstream model provider |
+
+## Using with Cline
+
+The easiest way to use the Cline API is through the Cline extension or CLI, which handle authentication and streaming for you.
+
+### VS Code / JetBrains
+
+Select **Cline** as your provider in the model picker dropdown. Sign in with your Cline account and your API key is managed automatically.
+
+### Cline CLI
+
+Configure the CLI with your API key in one command:
+
+```bash
+cline auth -p cline -k "YOUR_API_KEY" -m anthropic/claude-sonnet-4-6
+```
+
+Then run tasks normally:
+
+```bash
+cline "Write a one-line hello world in Python."
+```
+
+See the [CLI Reference](/cline-cli/cli-reference) for all available commands and options.
+
+## Using with Other Tools
+
+Because the Cline API is OpenAI-compatible, you can use it with any library or tool that supports custom OpenAI endpoints.
+
+### Python (OpenAI SDK)
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+response = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+print(response.choices[0].message.content)
+```
+
+### Node.js (OpenAI SDK)
+
+```typescript
+import OpenAI from "openai"
+
+const client = new OpenAI({
+  baseURL: "https://api.cline.bot/api/v1",
+  apiKey: "YOUR_API_KEY",
+})
+
+const response = await client.chat.completions.create({
+  model: "anthropic/claude-sonnet-4-6",
+  messages: [{ role: "user", content: "Hello!" }],
+})
+console.log(response.choices[0].message.content)
+```
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="CLI Reference" icon="terminal" href="/cline-cli/cli-reference">
+    Full command reference for the Cline CLI, including auth setup.
+  </Card>
+  <Card title="Enterprise API" icon="building" href="/enterprise-solutions/api-reference">
+    Admin endpoints for user management, organizations, billing, and API keys.
+  </Card>
+</CardGroup>

docs/api/sdk-examples.mdx

@@ -0,0 +1,275 @@
+---
+title: "SDK Examples"
+sidebarTitle: "SDK Examples"
+description: "Use the Cline API from Python, Node.js, curl, the Cline CLI, and the VS Code extension."
+---
+
+The Cline API is OpenAI-compatible, so any library or tool that works with OpenAI also works with the Cline API. Just change the base URL and API key.
+
+## curl
+
+### Non-Streaming
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "What is 2+2?"}],
+    "stream": false
+  }'
+```
+
+### Streaming
+
+```bash
+curl -X POST https://api.cline.bot/api/v1/chat/completions \
+  -H "Authorization: Bearer $CLINE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "anthropic/claude-sonnet-4-6",
+    "messages": [{"role": "user", "content": "Write a short poem about code."}],
+    "stream": true
+  }'
+```
+
+## Python
+
+### OpenAI SDK
+
+The [OpenAI Python SDK](https://github.com/openai/openai-python) works with the Cline API by setting `base_url`:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+# Non-streaming
+response = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "Explain recursion in one sentence."}],
+)
+print(response.choices[0].message.content)
+```
+
+### Streaming in Python
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+stream = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "Write a function to reverse a string in Python."}],
+    stream=True,
+)
+
+for chunk in stream:
+    content = chunk.choices[0].delta.content
+    if content:
+        print(content, end="", flush=True)
+print()
+```
+
+### Tool Calling in Python
+
+```python
+from openai import OpenAI
+import json
+
+client = OpenAI(
+    base_url="https://api.cline.bot/api/v1",
+    api_key="YOUR_API_KEY",
+)
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name"}
+                },
+                "required": ["location"],
+            },
+        },
+    }
+]
+
+response = client.chat.completions.create(
+    model="anthropic/claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
+    tools=tools,
+)
+
+# Check if the model wants to call a tool
+choice = response.choices[0]
+if choice.message.tool_calls:
+    tool_call = choice.message.tool_calls[0]
+    print(f"Tool: {tool_call.function.name}")
+    print(f"Args: {tool_call.function.arguments}")
+```
+
+### Using requests
+
+If you prefer not to use the OpenAI SDK:
+
+```python
+import requests
+
+response = requests.post(
+    "https://api.cline.bot/api/v1/chat/completions",
+    headers={
+        "Authorization": "Bearer YOUR_API_KEY",
+        "Content-Type": "application/json",
+    },
+    json={
+        "model": "anthropic/claude-sonnet-4-6",
+        "messages": [{"role": "user", "content": "Hello!"}],
+        "stream": False,
+    },
+)
+
+data = response.json()
+print(data["choices"][0]["message"]["content"])
+```
+
+## Node.js / TypeScript
+
+### OpenAI SDK
+
+The [OpenAI Node.js SDK](https://github.com/openai/openai-node) works with the Cline API by setting `baseURL`:
+
+```typescript
+import OpenAI from "openai"
+
+const client = new OpenAI({
+  baseURL: "https://api.cline.bot/api/v1",
+  apiKey: "YOUR_API_KEY",
+})
+
+// Non-streaming
+const response = await client.chat.completions.create({
+  model: "anthropic/claude-sonnet-4-6",
+  messages: [{ role: "user", content: "Explain async/await in one sentence." }],
+})
+console.log(response.choices[0].message.content)
+```
+
+### Streaming in Node.js
+
+```typescript
+import OpenAI from "openai"
+
+const client = new OpenAI({
+  baseURL: "https://api.cline.bot/api/v1",
+  apiKey: "YOUR_API_KEY",
+})
+
+const stream = await client.chat.completions.create({
+  model: "anthropic/claude-sonnet-4-6",
+  messages: [{ role: "user", content: "Write a haiku about TypeScript." }],
+  stream: true,
+})
+
+for await (const chunk of stream) {
+  const content = chunk.choices[0]?.delta?.content
+  if (content) {
+    process.stdout.write(content)
+  }
+}
+console.log()
+```
+
+### Using fetch
+
+```typescript
+const response = await fetch("https://api.cline.bot/api/v1/chat/completions", {
+  method: "POST",
+  headers: {
+    Authorization: "Bearer YOUR_API_KEY",
+    "Content-Type": "application/json",
+  },
+  body: JSON.stringify({
+    model: "anthropic/claude-sonnet-4-6",
+    messages: [{ role: "user", content: "Hello!" }],
+    stream: false,
+  }),
+})
+
+const data = await response.json()
+console.log(data.choices[0].message.content)
+```
+
+## Cline CLI
+
+The [Cline CLI](/cline-cli/cli-reference) is the fastest way to use the Cline API from your terminal. It handles authentication, streaming, and tool execution for you.
+
+### Setup
+
+```bash
+# Install
+npm install -g @anthropic-ai/cline
+
+# Authenticate with a Cline API key
+cline auth -p cline -k "YOUR_API_KEY" -m anthropic/claude-sonnet-4-6
+```
+
+### Run Tasks
+
+```bash
+# Simple prompt
+cline "Explain what a REST API is."
+
+# Pipe input
+cat README.md | cline "Summarize this document."
+
+# Use a specific model
+cline -m google/gemini-2.5-pro "Analyze this codebase."
+
+# YOLO mode for automation
+cline -y "Run tests and fix failures."
+```
+
+See the [CLI Reference](/cline-cli/cli-reference) for all commands and options.
+
+## VS Code / JetBrains
+
+The Cline extension handles the API integration for you:
+
+1. Open the Cline panel in your editor
+2. Select **Cline** as the provider in the model picker
+3. Sign in with your Cline account
+4. Start chatting or give Cline a task
+
+Your API key is managed automatically. No manual configuration needed.
+
+For setup instructions, see [Installing Cline](/getting-started/installing-cline) and [Authorizing with Cline](/getting-started/authorizing-with-cline).
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions" icon="message" href="/api/chat-completions">
+    Full endpoint reference with all parameters.
+  </Card>
+  <Card title="Authentication" icon="key" href="/api/authentication">
+    API key management and security practices.
+  </Card>
+  <Card title="Models" icon="brain" href="/api/models">
+    Browse available models.
+  </Card>
+  <Card title="CLI Reference" icon="terminal" href="/cline-cli/cli-reference">
+    Complete Cline CLI command reference.
+  </Card>
+</CardGroup>

docs/cline-cli/cli-reference.mdx

@@ -63,6 +63,9 @@ cline
 
 # Start a task directly
 cline "your prompt here"
+
+# Resume the latest task for the current directory
+cline --continue
 ```
 
 **Options:**
@@ -77,6 +80,7 @@ cline "your prompt here"
 | `--thinking` | Enable extended thinking with a 1024 token budget. |
 | `--json` | Output messages as JSON (one object per line). Forces plain text mode. |
 | `--timeout <seconds>` | Maximum execution time before the task is stopped. |
+| `--continue` | Resume the most recent task from the current working directory. |
 
 **Mode Behavior:**
 

docs/cline-cli/configuration.mdx

@@ -180,13 +180,23 @@ Cline CLI supports [MCP (Model Context Protocol)](/mcp/mcp-overview) servers, gi
 
 ### Setting Up MCP Servers
 
-To configure MCP servers for the CLI, create or edit the settings file at:
+You can add MCP servers from the CLI:
+
+```bash
+# STDIO server
+cline mcp add kanban -- kanban mcp
+
+# Remote HTTP server
+cline mcp add linear https://mcp.linear.app/mcp --type http
+```
+
+These commands update:
 
 ```
 ~/.cline/data/settings/cline_mcp_settings.json
 ```
 
-The file uses the same JSON format as the VS Code extension:
+You can still edit this file directly. It uses the same JSON format as the VS Code extension:
 
 ```json
 {
@@ -207,7 +217,7 @@ The file uses the same JSON format as the VS Code extension:
 For the full configuration reference including STDIO and SSE transport types, see [Adding and Configuring MCP Servers](/mcp/adding-and-configuring-servers).
 
 <Note>
-The CLI does not yet have a `/mcp` slash command for managing MCP servers interactively. For now, you'll need to edit the `cline_mcp_settings.json` file directly.
+The CLI does not yet have a `/mcp` slash command for interactive management inside the terminal UI. Use `cline mcp add` or edit `cline_mcp_settings.json` directly.
 </Note>
 
 ### Custom Config Directory

docs/cline-sdk/overview.md

@@ -1,3 +1,8 @@
+---
+title: "Cline SDK"
+description: "Embed Cline as a programmable coding agent in your Node.js applications using an ACP-compatible TypeScript API."
+---
+
 # Cline SDK
 
 The Cline SDK lets you embed Cline as a programmable coding agent in your Node.js applications. It exposes the same capabilities as the Cline CLI and VS Code extension — file editing, command execution, browser use, MCP servers — through a TypeScript API that conforms to the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/protocol/schema).
@@ -19,50 +24,72 @@ Requires Node.js 20+.
 ## Quick Start
 
 ```typescript
-import { ClineAgent } from "cline"
+import { ClineAgent } from "cline";
 
-const agent = new ClineAgent({ version: "1.0.0" })
+const CLINE_DIR = "/Users/username/.cline";
+const agent = new ClineAgent({ clineDir: CLINE_DIR });
 
 // 1. Initialize — negotiates capabilities
-await agent.initialize({
-  protocolVersion: 1,
-  clientCapabilities: {},
-})
+const initializeResponse = await agent.initialize({
+    protocolVersion: 1,
+    // these are the capabilities that the client (you) supports
+    // The cline agent may or may not use them, but it needs to know about them to make informed decisions about what tools to use.
+    clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true,
+    },
+});
 
-// 2. Authenticate (if using Cline-hosted models)
-await agent.authenticate({ methodId: "cline-oauth" })
+const { agentInfo, authMethods } = initializeResponse;
+console.log("Agent info:", agentInfo); // contains things like agent name and version
+console.log("Auth methods:", authMethods); // contains a list of supported authentication methods. More auth methods coming soon
 
-// 3. Create a session
+// 2. Authenticate if needed
+// If you skip this step, ClineAgent will look in CLINE_DIR for any existing credentials and authenticate with those
+await agent.authenticate({ methodId: "cline-oauth" });
+
+// 3. Create a session.
+// A session represents a conversation or task with the agent. You can have multiple sessions for different tasks or conversations.
 const { sessionId } = await agent.newSession({
-  cwd: process.cwd(),
-  mcpServers: [],
-})
+    cwd: process.cwd(),
+    mcpServers: [], // mcpServers field not supported yet, but exposed here to maintain conformance with acp protocol
+});
 
-// 4. Subscribe to streaming output
-const emitter = agent.emitterForSession(sessionId)
+// 4. Agent updates are sent via events. You can subscribe to these events to get real-time updates on the agent's progress, tool calls, and more.
+const emitter = agent.emitterForSession(sessionId);
 
 emitter.on("agent_message_chunk", (payload) => {
-  process.stdout.write(payload.content.text)
-})
-
+    process.stdout.write(
+        payload.content.type === "text"
+            ? payload.content.text
+            : `[${payload.content.type}]`,
+    );
+});
+emitter.on("agent_thought_chunk", (payload) => {
+    process.stdout.write(
+        payload.content.type === "text"
+            ? payload.content.text
+            : `[${payload.content.type}]`,
+    );
+});
 emitter.on("tool_call", (payload) => {
-  console.log(`[tool] ${payload.title}`)
-})
-
+    console.log(`[tool] ${payload.title}`);
+});
 emitter.on("error", (err) => {
-  console.error("[session error]", err)
-})
+    console.error("[session error]", err);
+});
 
 // 5. Send a prompt and wait for completion
 const { stopReason } = await agent.prompt({
-  sessionId,
-  prompt: [{ type: "text", text: "Create a hello world Express server" }],
-})
+    sessionId,
+    prompt: [{ type: "text", text: "Create a hello world Express server" }],
+});
 
-console.log("Done:", stopReason)
+console.log("Done:", stopReason);
 
 // 6. Clean up
-await agent.shutdown()
+await agent.shutdown();
+
 ```
 
 ## Core Concepts
@@ -78,7 +105,7 @@ initialize() → authenticate() → newSession() → prompt() ⇄ events → shu
 | Step | Method | Purpose |
 |------|--------|---------|
 | Init | `initialize()` | Exchange protocol version and capabilities |
-| Auth | `authenticate()` | OAuth flow for Cline or OpenAI Codex accounts |
+| Auth | `authenticate()` | OAuth flow for Cline or OpenAI Codex accounts. Optional step if cline config directory already has credentials |
 | Session | `newSession()` | Create an isolated conversation context |
 | Prompt | `prompt()` | Send user messages; blocks until the turn ends |
 | Cancel | `cancel()` | Abort an in-progress prompt turn |
@@ -88,14 +115,12 @@ initialize() → authenticate() → newSession() → prompt() ⇄ events → shu
 
 ### Sessions
 
-A session is an independent conversation with its own task history, working directory, and MCP server connections. You can run multiple sessions concurrently.
+A session is an independent conversation with its own task history and working directory. You can run multiple sessions concurrently.
 
 ```typescript
 const { sessionId, modes, models } = await agent.newSession({
   cwd: "/path/to/project",
-  mcpServers: [
-    { name: "my-server", command: "npx", args: ["-y", "my-mcp-server"] },
-  ],
+  mcpServers: [], // mcpServers field not supported yet, but exposed here to maintain conformance with acp protocol
 })
 ```
 
@@ -160,9 +185,7 @@ await agent.prompt({
 | Value | Meaning |
 |-------|---------|
 | `"end_turn"` | Agent finished normally (completed task or waiting for user input) |
-| `"cancelled"` | You called `cancel()` during the turn |
-| `"error"` | An unrecoverable error occurred |
-| `"max_tokens"` | Context window exhausted |
+| `"error"` | An error occurred |
 
 ### Streaming Events
 
@@ -220,7 +243,7 @@ The emitter supports `on`, `once`, `off`, and `removeAllListeners`.
 When the agent wants to execute a tool (edit a file, run a command, etc.), it requests permission. You **must** set a permission handler or all tool calls will be auto-rejected.
 
 ```typescript
-agent.setPermissionHandler((request, resolve) => {
+agent.setPermissionHandler(async (request) => {
   // request.toolCall — details about what the agent wants to do
   // request.options — available choices (allow_once, reject_once, etc.)
 
@@ -228,11 +251,11 @@ agent.setPermissionHandler((request, resolve) => {
   console.log("Options:", request.options.map(o => `${o.optionId} (${o.kind})`))
 
   // Auto-approve everything:
-  const allowOption = request.options.find(o => o.kind === "allow_once")
+  const allowOption = request.options.find(o => o.kind.includes("allow"))
   if (allowOption) {
-    resolve({ outcome: { outcome: "selected", optionId: allowOption.optionId } })
+    return { outcome: { outcome: "selected", optionId: allowOption.optionId } }
   } else {
-    resolve({ outcome: { outcome: "rejected" } })
+    return { outcome: { outcome: "rejected" } }
   }
 })
 ```
@@ -265,7 +288,7 @@ await agent.setSessionMode({ sessionId, modeId: "plan" })
 await agent.setSessionMode({ sessionId, modeId: "act" })
 ```
 
-The current mode is returned in `newSession()` and emitted via `current_mode_update` events.
+The current mode is returned in `newSession()`
 
 ### Model Selection
 
@@ -278,9 +301,9 @@ await agent.unstable_setSessionModel({
 })
 ```
 
-This sets the model for both plan and act modes. Available providers include `anthropic`, `openai-native`, `gemini`, `bedrock`, `deepseek`, `mistral`, `groq`, `xai`, and others.
+This sets the model for both plan and act modes. Available providers include `anthropic`, `openai-native`, `gemini`, `bedrock`, `deepseek`, `mistral`, `groq`, `xai`, and others. Model Ids can be found in the NewSessionResponse object after calling `agent.newSession(..)`
 
-> **Note:** This API is experimental and may change.
+> **Note:** This API is experimental and may change. 
 
 ### Authentication
 
@@ -296,7 +319,7 @@ await agent.authenticate({ methodId: "openai-codex-oauth" })
 
 Both methods open a browser window for the OAuth flow and block until authentication completes (5-minute timeout for Cline OAuth).
 
-For BYO (bring-your-own) API key providers, configure the key through the state manager before creating a session. The `authenticate()` call is not needed for BYO providers.
+For BYO (bring-your-own) API key providers, configure the key through the cline config directory before creating a session. The `authenticate()` call is not needed for BYO providers. We plan to support more auth providers in the near future.
 
 ### Cancellation
 
@@ -306,8 +329,6 @@ Cancel an in-progress prompt turn:
 await agent.cancel({ sessionId })
 ```
 
-The pending `prompt()` call will resolve with `{ stopReason: "cancelled" }`.
-
 ## API Reference
 
 ### Constructor
@@ -318,8 +339,6 @@ new ClineAgent(options: ClineAgentOptions)
 
 ```typescript
 interface ClineAgentOptions {
-  /** Version string for your application (required) */
-  version: string
   /** Enable debug logging (default: false) */
   debug?: boolean
   /** Custom Cline config directory (default: ~/.cline) */
@@ -331,7 +350,6 @@ The `clineDir` option lets you isolate configuration and task history per-applic
 
 ```typescript
 const agent = new ClineAgent({
-  version: "1.0.0",
   clineDir: "/tmp/my-app-cline",
 })
 ```
@@ -434,7 +452,7 @@ await agent.setSessionMode({ sessionId, modeId: "plan" })
 
 #### `unstable_setSessionModel(params): Promise<SetSessionModelResponse>`
 
-Change the model for the session. Model ID format: `"provider/modelId"`.
+Change the model for the session. Model ID format depends on the inference provider. See NewSessionResponse object to get modelIds.
 
 ```typescript
 await agent.unstable_setSessionModel({
@@ -451,6 +469,14 @@ Authenticate with a provider. Opens a browser window for OAuth flow.
 await agent.authenticate({ methodId: "cline-oauth" })
 ```
 
+Current methodIds we support:
+
+| methodId             | Description                   |
+| -------------------- | ----------------------------- |
+| `cline-oauth`        | use cline inference provider  |
+| `openai-codex-oauth` | use your chatgpt subscription |
+| more coming soon!... |                               |
+
 #### `shutdown(): Promise<void>`
 
 Clean up all resources. Call this when done.
@@ -490,116 +516,122 @@ for (const [sessionId, session] of agent.sessions) {
 ## Full Example: Auto-Approve Agent
 
 ```typescript
-import { ClineAgent } from "cline"
+import { ClineAgent } from "cline";
 
-async function runTask(task: string, cwd: string) {
-  const agent = new ClineAgent({ version: "1.0.0" })
+async function runTask(taskPrompt: string, cwd: string) {
+    const agent = new ClineAgent({ clineDir: "/Users/maxpaulus/.cline" });
 
-  await agent.initialize({
-    protocolVersion: 1,
-    clientCapabilities: {},
-  })
+    await agent.initialize({
+        protocolVersion: 1,
+        clientCapabilities: {},
+    });
 
-  const { sessionId } = await agent.newSession({ cwd, mcpServers: [] })
+    const { sessionId } = await agent.newSession({ cwd, mcpServers: [] });
 
-  // Auto-approve all tool calls
-  agent.setPermissionHandler((request, resolve) => {
-    const allow = request.options.find(o => o.kind === "allow_once")
-    resolve({
-      outcome: allow
-        ? { outcome: "selected", optionId: allow.optionId }
-        : { outcome: "rejected" },
-    })
-  })
+    // Auto-approve all tool calls
+    agent.setPermissionHandler(async (request) => {
+        const allow = request.options.find((o) => o.kind === "allow_once");
+        return {
+            outcome: allow
+                ? { outcome: "selected", optionId: allow.optionId }
+                : { outcome: "cancelled" },
+        };
+    });
 
-  // Collect output
-  const output: string[] = []
-  const emitter = agent.emitterForSession(sessionId)
+    // Collect output
+    const output: string[] = [];
+    const emitter = agent.emitterForSession(sessionId);
 
-  emitter.on("agent_message_chunk", (p) => {
-    if (p.content.type === "text") output.push(p.content.text)
-  })
+    emitter.on("agent_message_chunk", (p) => {
+        if (p.content.type === "text") output.push(p.content.text);
+    });
 
-  emitter.on("tool_call", (p) => {
-    console.log(`[tool] ${p.title}`)
-  })
+    emitter.on("tool_call", (p) => {
+        console.log(`[tool] ${p.title}`);
+    });
 
-  const { stopReason } = await agent.prompt({
-    sessionId,
-    prompt: [{ type: "text", text: task }],
-  })
+    const { stopReason } = await agent.prompt({
+        sessionId,
+        prompt: [{ type: "text", text: taskPrompt }],
+    });
 
-  console.log("\n--- Agent Output ---")
-  console.log(output.join(""))
-  console.log(`\nStop reason: ${stopReason}`)
+    console.log("\n--- Agent Output ---");
+    console.log(output.join(""));
+    console.log(`\nStop reason: ${stopReason}`);
 
-  await agent.shutdown()
+    await agent.shutdown();
 }
 
-runTask("Create a README.md for this project", process.cwd())
+runTask("Create a README.md for this project", process.cwd());
 ```
 
 ## Full Example: Interactive Permission Flow
 
 ```typescript
-import { ClineAgent, type PermissionHandler } from "cline"
-import * as readline from "readline"
+import { ClineAgent, type PermissionHandler } from "cline";
+import * as readline from "readline";
 
-const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-const ask = (q: string) => new Promise<string>((res) => rl.question(q, res))
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+const ask = (q: string) => new Promise<string>((res) => rl.question(q, res));
 
-const interactivePermissions: PermissionHandler = async (request, resolve) => {
-  console.log(`\n⚠️  Permission: ${request.toolCall.title}`)
+const interactivePermissions: PermissionHandler = async (request) => {
+    console.log(`\n⚠️  Permission: ${request.toolCall.title}`);
 
-  for (const [i, opt] of request.options.entries()) {
-    console.log(`  ${i + 1}. [${opt.kind}] ${opt.name}`)
-  }
+    for (const [i, opt] of request.options.entries()) {
+        console.log(`  ${i + 1}. [${opt.kind}] ${opt.name}`);
+    }
 
-  const choice = await ask("Choose (number): ")
-  const idx = parseInt(choice, 10) - 1
-  const selected = request.options[idx]
+    const choice = await ask("Choose (number): ");
+    const idx = parseInt(choice, 10) - 1;
+    const selected = request.options[idx];
 
-  if (selected) {
-    resolve({ outcome: { outcome: "selected", optionId: selected.optionId } })
-  } else {
-    resolve({ outcome: { outcome: "rejected" } })
-  }
-}
+    if (selected) {
+        return {
+            outcome: { outcome: "selected", optionId: selected.optionId },
+        };
+    } else {
+        return { outcome: { outcome: "cancelled" } };
+    }
+};
 
 async function main() {
-  const agent = new ClineAgent({ version: "1.0.0" })
-  await agent.initialize({ protocolVersion: 1, clientCapabilities: {} })
+    const agent = new ClineAgent({});
+    await agent.initialize({ protocolVersion: 1, clientCapabilities: {} });
 
-  const { sessionId } = await agent.newSession({
-    cwd: process.cwd(),
-    mcpServers: [],
-  })
+    const { sessionId } = await agent.newSession({
+        cwd: process.cwd(),
+        mcpServers: [],
+    });
 
-  agent.setPermissionHandler(interactivePermissions)
+    agent.setPermissionHandler(interactivePermissions);
 
-  const emitter = agent.emitterForSession(sessionId)
-  emitter.on("agent_message_chunk", (p) => {
-    if (p.content.type === "text") process.stdout.write(p.content.text)
-  })
+    const emitter = agent.emitterForSession(sessionId);
+    emitter.on("agent_message_chunk", (p) => {
+        if (p.content.type === "text") process.stdout.write(p.content.text);
+    });
 
-  // Multi-turn conversation
-  while (true) {
-    const userInput = await ask("\n> ")
-    if (userInput === "exit") break
+    // Multi-turn conversation
+    while (true) {
+        const userInput = await ask("\n> ");
+        if (userInput === "exit") break;
 
-    const { stopReason } = await agent.prompt({
-      sessionId,
-      prompt: [{ type: "text", text: userInput }],
-    })
+        const { stopReason } = await agent.prompt({
+            sessionId,
+            prompt: [{ type: "text", text: userInput }],
+        });
 
-    console.log(`\n[${stopReason}]`)
-  }
+        console.log(`\n[${stopReason}]`);
+    }
 
-  await agent.shutdown()
-  rl.close()
+    await agent.shutdown();
+    rl.close();
 }
 
-main()
+main();
+
 ```
 
 ## Exported Types

docs/customization/hooks.mdx

@@ -143,16 +143,35 @@ echo '{"cancel":false}'
 
 <Steps>
   <Step title="Create the hook file">
-    Save the script above as `~/Documents/Cline/Hooks/file-logger` (macOS/Linux) or create it through the Hooks UI.
+    Save the script above as `~/Documents/Cline/Hooks/file-logger` or create it through the Hooks UI.
   </Step>
   <Step title="Make it executable">
-    Run `chmod +x ~/Documents/Cline/Hooks/file-logger` in your terminal.
+    On macOS/Linux, run `chmod +x ~/Documents/Cline/Hooks/file-logger`.
   </Step>
-  <Step title="Enable it">
+  <Step title="Enable it (macOS/Linux only)">
     In Cline's Hooks tab, find "file-logger" under PreToolUse hooks and toggle it on.
   </Step>
 </Steps>
 
+<Note>
+On Windows, hooks are executed with PowerShell and run whenever the hook file exists. In this
+foundation PR, hook enable/disable toggling is not yet supported on Windows.
+</Note>
+
+<Note>
+Coming next: JSON-backed hook enabled/disabled state across platforms, so toggle behavior is
+consistent on Windows, macOS, and Linux.
+</Note>
+
+<Note>
+Hook filenames are platform-specific:
+
+- **Windows**: only `HookName.ps1` is supported (PowerShell script files)
+- **macOS/Linux**: only extensionless `HookName` is supported (executable files like bash scripts or binaries)
+
+Wrong-platform naming is ignored by hook discovery.
+</Note>
+
 ### Test It
 
 Ask Cline to read any file in your project: "What's in package.json?"
@@ -190,9 +209,15 @@ Every hook receives a JSON object with common fields plus hook-specific data:
 ```json
 {
   "taskId": "abc123",
+  "hookName": "PreToolUse",
   "clineVersion": "3.17.0",
-  "timestamp": 1736654400000,
-  "workspacePath": "/path/to/project",
+  "timestamp": "1736654400000",
+  "workspaceRoots": ["/path/to/project"],
+  "userId": "user_123",
+  "model": {
+    "provider": "openrouter",
+    "slug": "anthropic/claude-sonnet-4.5"
+  },
   
   // Hook-specific field (name matches hook type in camelCase)
   "taskStart": {
@@ -201,6 +226,17 @@ Every hook receives a JSON object with common fields plus hook-specific data:
 }
 ```
 
+`model.provider` and `model.slug` are machine-stable identifiers for the active provider/model at hook execution time. If unavailable, Cline sends deterministic fallback values: `"unknown"`.
+
+<Note>
+Migration note for existing hook scripts:
+
+- `timestamp` is a string (milliseconds since epoch), not a number
+- `workspaceRoots` is an array of workspace root paths and replaces the old singular `workspacePath`
+
+If your scripts previously read `.workspacePath`, switch to `.workspaceRoots[0]` (or iterate all roots).
+</Note>
+
 The hook-specific field name matches the hook type:
 - `taskStart`, `taskResume`, `taskCancel`, `taskComplete` contain `{ task: string }`
 - `preToolUse` contains `{ tool: string, parameters: object }`
@@ -420,7 +456,7 @@ Inject project-specific information when a task begins:
 # TaskStart hook
 
 INPUT=$(cat)
-WORKSPACE=$(echo "$INPUT" | jq -r '.workspacePath')
+WORKSPACE=$(echo "$INPUT" | jq -r '.workspaceRoots[0] // empty')
 
 # Read project info if available
 if [[ -f "$WORKSPACE/.project-context" ]]; then
@@ -444,14 +480,17 @@ cline config set hooks-enabled=true
 ```
 
 <Note>
-CLI hooks are only supported on macOS and Linux.
+Windows hooks require PowerShell (`powershell.exe`) available on your PATH.
 </Note>
 
 ## Troubleshooting
 
 **Hook not running?**
-- Check that the file is executable (`chmod +x hookname`)
-- Verify the hook is enabled (toggle is on in the Hooks tab)
+- On macOS/Linux, check that the file is executable (`chmod +x hookname`)
+- On Windows, ensure PowerShell is available (`powershell -NoProfile -Command "$PSVersionTable.PSVersion"`)
+- On Windows, ensure the hook file is named `<HookName>.ps1` (for example `PreToolUse.ps1`)
+- On macOS/Linux, ensure the hook file uses extensionless `<HookName>` naming (for example `PreToolUse`)
+- On macOS/Linux, verify the hook is enabled (toggle is on in the Hooks tab)
 - Check that Hooks are enabled globally in Settings
 
 **Hook output not parsed?**

docs/docs.json

@@ -116,6 +116,7 @@
 							},
 							"cline-cli/configuration",
 							"cline-cli/acp-editor-integrations",
+							"cline-sdk/overview",
 							"cline-cli/cli-reference"
 						]
 					},
@@ -297,7 +298,36 @@
 									"enterprise-solutions/monitoring/telemetry",
 									"enterprise-solutions/monitoring/opentelemetry"
 								]
-							}
+							},
+							"enterprise-solutions/api-reference"
+						]
+					}
+				]
+			},
+			{
+				"tab": "API",
+				"icon": "code",
+				"groups": [
+					{
+						"group": "Cline API",
+						"pages": [
+							"api/overview",
+							"api/getting-started",
+							"api/authentication"
+						]
+					},
+					{
+						"group": "Endpoints",
+						"pages": [
+							"api/chat-completions"
+						]
+					},
+					{
+						"group": "Reference",
+						"pages": [
+							"api/models",
+							"api/errors",
+							"api/sdk-examples"
 						]
 					}
 				]
@@ -607,6 +637,10 @@
 		{
 			"source": "/features/skills",
 			"destination": "/customization/skills"
+		},
+		{
+			"source": "/api/reference",
+			"destination": "/api/overview"
 		}
 	],
 	"search": {

docs/enterprise-solutions/api-reference.mdx

@@ -0,0 +1,208 @@
+---
+title: "Enterprise API Reference"
+sidebarTitle: "API Reference"
+description: "REST API endpoints for managing users, organizations, billing, plans, and API keys."
+---
+
+The Enterprise API provides REST endpoints for account management, organization administration, billing, and API key management. These are separate from the [Chat Completions API](/api/reference), which handles model inference.
+
+## Base URL
+
+```
+https://api.cline.bot
+```
+
+## Authentication
+
+All endpoints require a Bearer token in the `Authorization` header:
+
+```bash
+Authorization: Bearer YOUR_AUTH_TOKEN
+```
+
+Use the same API key or account auth token described in the [public API reference](/api/reference#authentication).
+
+## Quick Example
+
+```bash
+# Get your user profile
+curl https://api.cline.bot/api/v1/users/me \
+  -H "Authorization: Bearer YOUR_AUTH_TOKEN"
+```
+
+```json
+{
+  "id": "user_abc123",
+  "email": "you@company.com",
+  "name": "Your Name",
+  "active_account_id": "org_xyz789"
+}
+```
+
+---
+
+## Users
+
+Manage user accounts, accept terms, check balances, view usage, and configure payment methods.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/me` | Get current user profile |
+| `PATCH` | `/api/v1/users/me` | Update current user profile |
+| `DELETE` | `/api/v1/users/me` | Delete current user account |
+| `POST` | `/api/v1/users/me/accept-terms` | Accept terms of service |
+| `GET` | `/api/v1/users/me/remote-config` | Get remote configuration for the current user |
+| `PUT` | `/api/v1/users/active-account` | Switch active account (personal or organization) |
+| `GET` | `/api/v1/users/{id}/balance` | Get credit balance |
+| `GET` | `/api/v1/users/{id}/usages` | Get usage history |
+
+### Payments and Credits
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/{id}/payments` | List payment history |
+| `GET` | `/api/v1/users/{id}/payments/{paymentId}` | Get payment details |
+| `GET` | `/api/v1/users/{id}/payments/{paymentId}/status` | Check payment status |
+| `GET` | `/api/v1/users/{id}/payments/provider/{paymentId}` | Get provider-side payment details |
+| `POST` | `/api/v1/users/credits/checkout` | Start a credit purchase checkout |
+| `POST` | `/api/v1/users/{id}/credits/purchase` | Purchase credits directly |
+
+### Billing Configuration
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/users/{id}/auto-top-up` | Get auto top-up settings |
+| `PUT` | `/api/v1/users/{id}/auto-top-up` | Configure auto top-up |
+| `GET` | `/api/v1/users/{id}/payment-method/default` | Get default payment method |
+| `POST` | `/api/v1/users/{id}/payment-method/setup-session` | Start payment method setup |
+| `GET` | `/api/v1/users/{id}/promotions` | List active promotions |
+
+---
+
+## Organizations
+
+Create and manage organizations. Organization admins can configure remote settings, manage members, and control billing.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/v1/organizations` | Create a new organization |
+| `GET` | `/api/v1/organizations/{id}` | Get organization details |
+| `PUT` | `/api/v1/organizations/{id}` | Update organization settings |
+| `DELETE` | `/api/v1/organizations/{id}` | Delete an organization |
+| `GET` | `/api/v1/organizations/{id}/api-keys` | List organization API keys |
+| `GET` | `/api/v1/organizations/{id}/remote-config` | Get remote config for the org |
+| `GET` | `/api/v1/organizations/{orgId}/metrics` | Get organization usage metrics |
+
+---
+
+## Organization Members
+
+Manage who has access to the organization and what role they hold.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/members` | List all members |
+| `DELETE` | `/api/v1/organizations/{orgId}/members` | Remove members |
+| `GET` | `/api/v1/organizations/{orgId}/members/available-roles` | List assignable roles |
+| `PUT` | `/api/v1/organizations/{orgId}/members/{memberId}/role` | Change a member's role |
+| `GET` | `/api/v1/organizations/{orgId}/members/{memberId}/usages` | Get a member's usage |
+
+<Tip>
+  For a walkthrough of member management in the UI, see [Managing Members](/enterprise-solutions/team-management/managing-members).
+</Tip>
+
+---
+
+## Organization Invites
+
+Invite new members to join your organization.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/invites` | List pending invites |
+| `POST` | `/api/v1/organizations/{orgId}/invites` | Send new invites |
+| `GET` | `/api/v1/organizations/{orgId}/invites/count` | Get invite count |
+| `DELETE` | `/api/v1/organizations/{orgId}/invites/{inviteId}` | Revoke an invite |
+| `POST` | `/api/v1/invites/accept` | Accept an invite (called by the invitee) |
+
+---
+
+## Organization Balance and Payments
+
+Manage credits and payments at the organization level. These mirror the user-level payment endpoints but operate on the organization's account.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/balance` | Get org credit balance |
+| `GET` | `/api/v1/organizations/{orgId}/payments` | List payment history |
+| `GET` | `/api/v1/organizations/{orgId}/payments/{paymentId}` | Get payment details |
+| `GET` | `/api/v1/organizations/{orgId}/payments/{paymentId}/status` | Check payment status |
+| `GET` | `/api/v1/organizations/{orgId}/payments/provider/{paymentId}` | Provider-side payment details |
+| `POST` | `/api/v1/organizations/{orgId}/credits/checkout` | Start credit checkout |
+| `POST` | `/api/v1/organizations/{orgId}/credits/purchase` | Purchase credits |
+| `GET` | `/api/v1/organizations/{orgId}/auto-top-up` | Get auto top-up config |
+| `PUT` | `/api/v1/organizations/{orgId}/auto-top-up` | Configure auto top-up |
+| `GET` | `/api/v1/organizations/{orgId}/payment-method/default` | Get default payment method |
+| `POST` | `/api/v1/organizations/{orgId}/payment-method/setup-session` | Start payment method setup |
+| `GET` | `/api/v1/organizations/{id}/promotions` | List active promotions |
+
+---
+
+## Organization Plans
+
+Subscribe to, upgrade, or cancel plans. Manage seat counts for your team.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/plans` | List all available plans |
+| `GET` | `/api/v1/organizations/{orgId}/plan` | Get current plan |
+| `GET` | `/api/v1/organizations/{orgId}/plan/history` | View plan change history |
+| `GET` | `/api/v1/organizations/{orgId}/plan/{planId}` | Get specific plan details |
+| `POST` | `/api/v1/organizations/{orgId}/plan` | Subscribe to a plan |
+| `PUT` | `/api/v1/organizations/{orgId}/plan/seats` | Update seat count |
+| `DELETE` | `/api/v1/organizations/{orgId}/plan/{planId}` | Cancel a plan |
+
+---
+
+## Organization Usage
+
+Track token consumption and costs across your organization.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/organizations/{orgId}/usages` | Get aggregated usage data |
+
+<Tip>
+  For dashboards and monitoring, see [Monitoring Overview](/enterprise-solutions/monitoring/overview) and [Telemetry](/enterprise-solutions/monitoring/telemetry).
+</Tip>
+
+---
+
+## API Keys
+
+Create and manage API keys for programmatic access. Keys created here work with both the [Chat Completions API](/api/reference) and the endpoints on this page.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/v1/api-keys` | List your API keys |
+| `POST` | `/api/v1/api-keys` | Create a new API key |
+| `DELETE` | `/api/v1/api-keys/{key_id}` | Delete an API key |
+
+---
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="Chat Completions API" icon="code" href="/api/reference">
+    The public inference API for sending prompts and receiving completions.
+  </Card>
+  <Card title="SSO Setup" icon="key" href="/enterprise-solutions/sso-setup">
+    Configure single sign-on for your organization.
+  </Card>
+  <Card title="Managing Members" icon="users" href="/enterprise-solutions/team-management/managing-members">
+    Add, remove, and manage member roles in the UI.
+  </Card>
+  <Card title="Monitoring" icon="chart-line" href="/enterprise-solutions/monitoring/overview">
+    Track usage, costs, and telemetry across your organization.
+  </Card>
+</CardGroup>

docs/provider-config/fireworks.mdx

@@ -18,18 +18,22 @@ Fireworks AI is a leading infrastructure platform for generative AI that focuses
 
 Cline supports the following Fireworks AI models:
 
--   `accounts/fireworks/models/kimi-k2-instruct-0905` (Default) - Kimi K2 with 262K context, prompt caching ($0.60/$2.50 per 1M tokens)
--   `accounts/fireworks/models/qwen3-235b-a22b-instruct-2507` - Latest Qwen3 thinking model (256K context, $0.22/$0.88 per 1M tokens)
--   `accounts/fireworks/models/qwen3-coder-480b-a35b-instruct` - Qwen3's most agentic code model (256K context, $0.45/$1.80 per 1M tokens)
--   `accounts/fireworks/models/deepseek-r1-0528` - DeepSeek R1 reasoning model (160K context, $3.00/$8.00 per 1M tokens)
--   `accounts/fireworks/models/deepseek-v3` - DeepSeek V3 general-purpose model (128K context, $0.90/$0.90 per 1M tokens)
+-   `accounts/fireworks/models/kimi-k2p5` (Default) - Kimi K2.5 flagship agentic model with multimodal support (262K context, prompt caching, $0.60/$3.00 per 1M tokens)
+-   `accounts/fireworks/models/qwen3-vl-30b-a3b-thinking` - Qwen3-VL reasoning model with image support (262K context, prompt caching, $0.15/$0.60 per 1M tokens)
+-   `accounts/fireworks/models/qwen3-vl-30b-a3b-instruct` - Qwen3-VL instruct model with image support (262K context, $0.15/$0.60 per 1M tokens)
+-   `accounts/fireworks/models/deepseek-v3p2` - DeepSeek V3.2 model (164K context, prompt caching, $0.56/$1.68 per 1M tokens)
+-   `accounts/fireworks/models/glm-4p7` - GLM-4.7 model (203K context, prompt caching, $0.60/$2.20 per 1M tokens)
+-   `accounts/fireworks/models/glm-5` - GLM-5 model (203K context, prompt caching, $1.00/$3.20 per 1M tokens)
+-   `accounts/fireworks/models/minimax-m2p5` - MiniMax M2.5 model (197K context, prompt caching, $0.30/$1.20 per 1M tokens)
+-   `accounts/fireworks/models/minimax-m2p1` - MiniMax M2.1 model (197K context, prompt caching, $0.30/$1.20 per 1M tokens)
+-   `accounts/fireworks/models/gpt-oss-120b` - OpenAI gpt-oss-120b model (131K context, prompt caching, $0.15/$0.60 per 1M tokens)
 
 ### Configuration in Cline
 
 1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
 2.  **Select Provider:** Choose "Fireworks" from the "API Provider" dropdown.
 3.  **Enter API Key:** Paste your Fireworks API key into the "Fireworks API Key" field.
-4.  **Enter Model ID:** Specify the model you want to use (e.g., "accounts/fireworks/models/llama-v3p1-70b-instruct").
+4.  **Enter Model ID:** Specify the model you want to use (e.g., "accounts/fireworks/models/kimi-k2p5").
 5.  **Configure Tokens:** Optionally set max completion tokens and context window size.
 
 ### Fireworks AI's Performance Focus

docs/provider-config/oracle-code-assist.mdx

@@ -5,7 +5,7 @@ description: "Learn how to configure and use Oracle Code Assist with Cline. Acce
 
 Oracle Code Assist provides AI-powered coding assistance through Oracle Cloud Infrastructure (OCI) Generative AI service.
 
-**Website:** [https://www.oracle.com/artificial-intelligence/code-assist/](https://www.oracle.com/artificial-intelligence/code-assist/)
+**Website:** [https://www.oracle.com/application-development/code-assist/](https://www.oracle.com/application-development/code-assist/)
 
 ### Getting Started
 

docs/remote-workspace-latency-technique-01-ephemeral-partial-persistence-plan.md

@@ -0,0 +1,479 @@
+# Technique Plan: Ephemeral Partial Persistence Split
+
+This document is the implementation plan for the **ephemeral partial persistence split** technique identified in `docs/remote-workspace-latency-branch-analysis-report.md` as the highest-impact improvement for remote-workspace user-perceived latency.
+
+The core idea is simple:
+
+> **Stop treating every streamed chunk as durable state that must be written to disk immediately.**
+
+That principle matters everywhere in this project, but it is especially important here. In remote workspace mode, partial updates are expensive not because the bytes are individually large, but because there are many of them and each one can pull in remote filesystem I/O, history recomputation, serialization work, and follow-on transport churn. For the user, this shows up as sluggish or jittery streaming, especially during long answers or large-file operations where the agent emits lots of progress text.
+
+This plan focuses on splitting **ephemeral UI mutations** from **durable persistence boundaries** while preserving crash recovery, history correctness, and the rest of Cline’s product behavior.
+
+## How To Use This Plan
+
+This plan should be executed **on a new development branch**, not by continuing to stack work directly onto `eve_troubleshooting-remote-workspaces`.
+
+That branch, `eve_troubleshooting-remote-workspaces`, should be treated as the **fully developed reference implementation** for this technique. In other words, the work described here is not speculative greenfield design work; it is a structured plan for re-deriving, validating, and extracting the technique from the already-working reference implementation into a smaller, more reviewable changeset.
+
+The most effective way to use this document is:
+
+1. read the goal and mental model for the step,
+2. inspect how the reference implementation branch already solved it,
+3. extract the minimum coherent version of that change into your own branch,
+4. run the tests and validation described here,
+5. compare behavior against the reference implementation when in doubt.
+
+Be smart about this. Do not re-invent behavior that already exists in the reference implementation unless there is a very clear reason to improve or simplify it. The branch already contains the end-state shape we want to learn from. Your job is to extract, verify, and explain the minimal version of that behavior safely.
+
+## Document Type, Audience, and Quality Bar
+
+This is an **extraction implementation plan**, not a greenfield design doc and not a PR description. It is intended for a **Staff+ level distributed systems / infrastructure engineer** who is extracting a production-worthy technique from a known-good integrated implementation.
+
+That means the quality bar is:
+
+- the plan should be executable with minimal ambiguity,
+- the reasoning behind each step should be legible to a strong reviewer,
+- and the extraction should preserve product behavior across the rest of Cline while improving remote-workspace latency.
+
+If a step in this plan would not help a strong engineer quickly answer “what exactly am I changing, why now, what must remain true, and how do I verify it?”, then the step is not detailed enough.
+
+## Artifact Stack and Dependency Position
+
+This doc sits in the broader artifact stack as follows:
+
+1. `docs/remote-workspace-latency-branch-analysis-report.md` explains **which techniques matter most and why**.
+2. This document explains **how to extract and implement one technique in a smaller branch/PR**.
+3. A later PR-slicing / execution phase should use this document to drive real implementation work.
+
+When using this plan, always begin by re-reading the branch analysis report so the extraction stays aligned with the larger prioritization and product intent.
+
+## Developer Operating Posture
+
+This plan is written for a Staff+-level engineer who is expected to use judgment, not just mechanically check boxes.
+
+While implementing each step:
+
+- actively compare your changes to `eve_troubleshooting-remote-workspaces`,
+- preserve the original user experience across non-remote product surfaces,
+- prefer coherent extraction over literal copy-paste,
+- and keep asking: **what hot-path work are we removing, and what correctness boundary are we preserving?**
+
+The most important meta-principle is still:
+
+> **Stop treating every streamed chunk as a durable, full-state, immediately-presented event.**
+
+For this technique specifically, the emphasis is on the **durable** part of that sentence.
+
+## Minimal Coherent Extraction Boundary
+
+The smallest coherent PR for this technique should usually include:
+
+- message-state ephemeral mutation APIs,
+- dirty tracking plus explicit flush support,
+- task callsite conversion for partial updates,
+- periodic safety flush,
+- and the minimum set of tests needed to prove correctness.
+
+What should **not** be split away from this technique if avoidable:
+
+- the dirty-bit / flush contract,
+- the durable-boundary logic for partial → complete transitions,
+- safety-flush lifecycle management,
+- and the tests that prove resume/abort correctness.
+
+If those pieces are separated too aggressively, reviewers will have a much harder time understanding whether the extraction is actually safe.
+
+## Common Failure Modes While Extracting
+
+Watch for these failure modes explicitly:
+
+- extracting the ephemeral APIs without converting the real hot-path callsites,
+- clearing the dirty bit too early,
+- leaving abort/resume paths on stale assumptions about immediate persistence,
+- making durable and ephemeral mutation paths diverge semantically,
+- and validating only happy-path streaming while missing crash-recovery or resume regressions.
+
+If any of those happen, the extraction may appear simpler while actually weakening the product.
+
+---
+
+## Why This Technique Matters
+
+When Cline is writing a large file, updating a long reasoning trace, or streaming many incremental tool/progress updates, the old behavior effectively says:
+
+1. mutate message state,
+2. save messages to disk,
+3. update task history,
+4. possibly trigger more UI/state work,
+5. repeat on the next partial chunk.
+
+That is the wrong clock boundary.
+
+The better mental model is:
+
+- **Streaming partials are animation state.** They exist to help the user perceive progress.
+- **Durable persistence is recovery state.** It exists so the task can survive restart, cancellation, or history resume.
+- **Those are related, but they are not the same thing.**
+
+So the goal here is to keep the UI feeling live while only persisting at meaningful boundaries plus an occasional safety flush.
+
+---
+
+## Success Criteria
+
+- Partial `say(...)` and `ask(...)` updates no longer synchronously persist on every mutation.
+- Durable persistence still occurs at semantic boundaries such as completion, cancel, tool completion, and request completion.
+- Long-running streams periodically safety-flush unsaved partial changes.
+- Resume-from-history and crash-recovery behavior remain correct and predictable.
+- Message-state behavior remains mutex-safe and consistent under concurrent tool / stream / abort activity.
+
+---
+
+## Files Most Likely to Change
+
+- `src/core/task/message-state.ts`
+- `src/core/task/index.ts`
+- `src/core/task/EphemeralMessageFlushScheduler.ts`
+- `src/test/message-state-handler.test.ts`
+- `src/core/task/__tests__/EphemeralMessageFlushScheduler.test.ts`
+- `src/core/task/__tests__/latency.test.ts`
+- possibly targeted resume / abort integration tests
+
+---
+
+## Step-by-Step Implementation Plan
+
+## Step 1 — Define the durability contract for message mutations
+
+### Goal
+
+Write down the architectural contract before changing behavior, so future developers know which updates are ephemeral and which are durable.
+
+### Mental model
+
+If developers cannot quickly answer “does this mutation need to survive a crash immediately?”, they will accidentally route new hot-path updates back through synchronous persistence. This step prevents future regression.
+
+### Work
+
+- [x] Add code comments near `MessageStateHandler` describing the distinction between ephemeral and durable mutations.
+- [x] Add code comments in `Task.say(...)` and `Task.ask(...)` documenting which partial flows are intentionally ephemeral.
+- [x] Define a durable-boundary checklist in comments or docstrings, including at minimum:
+  - [x] partial → complete transition
+  - [x] tool completion / tool result boundary
+  - [x] request completion
+  - [x] cancellation / abort
+  - [x] resume-related state changes
+  - [x] checkpoint-relevant events
+
+### Detailed code changes
+
+- In `src/core/task/message-state.ts`, add a short header comment near the class definition explaining:
+  - durable methods write immediately,
+  - ephemeral methods mutate in memory and emit change notifications,
+  - `flushClineMessagesAndUpdateHistory()` is the bridge between the two.
+- In `src/core/task/index.ts`, add comments above the partial-update branches in `say(...)` and `ask(...)` explaining why partial updates are not always durable.
+
+When doing this work, read the corresponding code in `eve_troubleshooting-remote-workspaces` first and copy the intent, not just the surface syntax. The point of this step is to make the extraction self-explanatory for future reviewers and maintainers.
+
+### Tests
+
+- [x] No behavioral tests required for comments alone.
+- [x] Ensure any snapshot/doc-based linting or type-check flow still passes.
+
+---
+
+## Step 2 — Add explicit ephemeral mutation APIs to `MessageStateHandler`
+
+### Goal
+
+Create first-class APIs for in-memory message changes that emit message-change notifications without synchronously persisting.
+
+### Mental model
+
+The presence of dedicated APIs changes developer behavior. If the only available mutation helper is a durable save path, then everything becomes durable by default. We want the inverse for streaming partials: durable only when intentionally requested.
+
+### Work
+
+- [x] Add `addToClineMessagesEphemeral(message)`.
+- [x] Add `updateClineMessageEphemeral(index, updates)`.
+- [x] Add internal dirty tracking for unsaved ephemeral changes.
+- [x] Ensure ephemeral methods emit the same `clineMessagesChanged` events and task UI deltas as durable methods.
+- [x] Ensure all of the above remain protected by the existing mutex.
+
+### Detailed code changes
+
+- In `src/core/task/message-state.ts`:
+- [x] Add a `hasDirtyEphemeralChanges` flag if it does not already exist.
+  - [x] In `addToClineMessagesEphemeral(...)`:
+    - [x] set `conversationHistoryIndex` and `conversationHistoryDeletedRange` exactly as durable add does,
+    - [x] mutate `clineMessages`,
+    - [x] mark dirty,
+    - [x] emit `clineMessagesChanged`.
+  - [x] In `updateClineMessageEphemeral(...)`:
+    - [x] validate index,
+    - [x] capture previous message,
+    - [x] mutate in place,
+    - [x] mark dirty,
+    - [x] emit `clineMessagesChanged`.
+  - [x] Keep delta emission behavior identical between ephemeral and durable changes so frontend live behavior stays consistent.
+
+The smart way to execute this step is to compare the durable and ephemeral codepaths side by side in the reference implementation branch and preserve the shared invariants exactly. The extraction should reduce write amplification, not create a shadow message-state model with slightly different semantics.
+
+### Tests
+
+- [x] Unit test: ephemeral add mutates in-memory state without calling persistence.
+- [x] Unit test: ephemeral update mutates in-memory state without calling persistence.
+- [x] Unit test: ephemeral mutation emits `clineMessagesChanged` with correct shape.
+- [x] Unit test: ephemeral mutation still emits task UI deltas when delta sync is enabled.
+- [x] Unit test: invalid index still throws in ephemeral update path.
+
+---
+
+## Step 3 — Add explicit flush behavior for previously-ephemeral changes
+
+### Goal
+
+Provide a single durable flush method that persists all dirty ephemeral changes and updates task history once.
+
+### Mental model
+
+We are not removing durability; we are **batching** durability at the right semantic times. The flush method is the “commit” for a burst of ephemeral UI activity.
+
+### Work
+
+- [x] Add `flushClineMessagesAndUpdateHistory()` if not already present.
+- [x] Make it a no-op when no ephemeral changes are dirty.
+- [x] Ensure it reuses the same internal persistence logic as durable mutations.
+
+### Detailed code changes
+
+- In `src/core/task/message-state.ts`:
+  - [x] Add `flushClineMessagesAndUpdateHistory()` guarded by `withStateLock(...)`.
+  - [x] If `hasDirtyEphemeralChanges` is false, return early.
+  - [x] Otherwise call `saveClineMessagesAndUpdateHistoryInternal()`.
+  - [x] Ensure `saveClineMessagesAndUpdateHistoryInternal()` clears the dirty flag only after successful save/update-history flow.
+
+This step is where the implementation starts to feel like a deliberate state machine rather than a collection of helper methods. Be smart about failure ordering here: if the code clears the dirty bit too early or conflates flush success with mutation success, recovery correctness will quietly degrade.
+
+### Tests
+
+- [x] Unit test: flush persists previously-ephemeral changes.
+- [x] Unit test: flush is a cheap no-op when there are no dirty changes.
+- [x] Unit test: task history reflects flushed content after prior ephemeral mutation.
+
+---
+
+## Step 4 — Switch streaming partial update callsites to ephemeral APIs
+
+### Goal
+
+Move the actual hot-path streaming mutations onto the new ephemeral methods.
+
+### Mental model
+
+The APIs only matter if the streaming loop uses them. This is the step that converts theory into latency improvement.
+
+### Work
+
+- [x] Audit all partial `say(...)` paths.
+- [x] Audit all partial `ask(...)` paths.
+- [x] Switch normal streaming partial updates from durable to ephemeral mutation methods.
+- [x] Keep complete/finalized messages on durable paths unless explicitly flushed immediately after ephemeral completion.
+
+### Detailed code changes
+
+- In `src/core/task/index.ts`, update `say(...)`:
+  - [x] partial update of existing partial `say` message should use `updateClineMessageEphemeral(...)`.
+  - [x] new partial `say` message insertion should use `addToClineMessagesEphemeral(...)` where appropriate.
+- In `src/core/task/index.ts`, update `ask(...)`:
+  - [x] partial update of existing partial `ask` message should use `updateClineMessageEphemeral(...)`.
+  - [x] new partial `ask` insertion should use `addToClineMessagesEphemeral(...)` where appropriate.
+- For reasoning/tool-progress-related live updates:
+  - [x] ensure they remain visible to the UI through message-change events / partial-message events,
+  - [x] but no longer synchronously persist each partial mutation.
+
+This is the step where it becomes easy to accidentally under-extract or over-extract. Use the reference implementation branch aggressively here. If a callsite was made ephemeral in `eve_troubleshooting-remote-workspaces`, understand why. If a callsite remained durable, understand why. Preserve that distinction intentionally.
+
+### Tests
+
+- [x] Integration-style test: many partial text updates do not trigger per-update durable saves.
+- [ ] Unit test: partial `say(...)` path still emits live UI updates while skipping persistence.
+- [ ] Unit test: partial `ask(...)` path still emits live UI updates while skipping persistence.
+
+---
+
+## Step 5 — Define and enforce durable flush boundaries
+
+### Goal
+
+Ensure the system persists at the correct semantic points so correctness is preserved.
+
+### Mental model
+
+This is the balancing step. We are intentionally reducing durability frequency, so we must be precise about where durability is still required.
+
+### Work
+
+- [x] Identify all partial → complete transitions.
+- [x] Flush at request completion.
+- [x] Flush on abort / cancellation.
+- [x] Flush when tool execution reaches a stable durable boundary.
+- [x] Flush when history / resume semantics require consistency.
+
+### Detailed code changes
+
+- In `src/core/task/index.ts`:
+  - [x] when `partial: false` finalizes a previously partial message, use durable `updateClineMessage(...)` or explicit flush right after ephemeral completion.
+  - [x] in request-finalization logic, call `flushClineMessagesAndUpdateHistory()` before or alongside final durable save path where needed.
+  - [x] in abort/cancel paths, ensure pending ephemeral changes are flushed before task shutdown is considered complete.
+  - [x] in resume-related flows, ensure history-visible state is not left behind dirty.
+
+This step is the heart of the technique. The way to think about it is: we are removing durability from the hot path only because we are reintroducing durability at the right semantic boundaries. If those boundaries are fuzzy, the technique is incomplete.
+
+### Tests
+
+- [x] Unit test: partial → complete transition results in durable persistence.
+- [ ] Integration test: abort during stream persists a recoverable state.
+- [x] Regression test: resume-from-history still works after deferred partial persistence.
+- [x] Regression test: tool result flows remain properly visible in history after finalization.
+
+---
+
+## Step 6 — Add the periodic safety-flush scheduler
+
+### Goal
+
+Bound the amount of live UI state that could be lost if the extension host crashes during a long-running stream.
+
+### Mental model
+
+The correct behavior is not “persist every partial” and not “never persist until the very end.” The practical middle ground is:
+
+- partials stay ephemeral during normal live streaming,
+- but dirty state gets checkpointed periodically at low frequency.
+
+### Work
+
+- [x] Add or finish `EphemeralMessageFlushScheduler`.
+- [x] Start it when a request begins streaming.
+- [x] Stop it when the request completes or aborts.
+- [x] Make it call `flushClineMessagesAndUpdateHistory()` on cadence only when dirty.
+
+### Detailed code changes
+
+- In `src/core/task/EphemeralMessageFlushScheduler.ts`:
+  - [x] ensure a single timer is active,
+  - [x] prevent overlap between flushes,
+  - [x] support clean start/stop/dispose semantics.
+- In `src/core/task/index.ts`:
+  - [x] start scheduler near request start,
+  - [x] stop scheduler in both success and error/finally paths,
+  - [x] make cadence conservative (for example ~1.5s) to preserve UX win while bounding recovery loss.
+
+Use the reference implementation’s chosen cadence and lifecycle wiring as the default starting point. Only diverge if you can clearly articulate why a different extraction improves isolation or reviewability without changing the core behavior.
+
+### Tests
+
+- [x] Unit test: scheduler flushes pending ephemeral changes on cadence.
+- [x] Unit test: scheduler does nothing when there is no dirty ephemeral state.
+- [x] Unit test: scheduler stops cleanly on request completion/abort.
+
+---
+
+## Step 7 — Validate large-file and long-stream scenarios explicitly
+
+### Goal
+
+Confirm that the technique helps exactly the user scenario we care about: long-running, high-churn operations such as writing or rewriting large files.
+
+### Mental model
+
+Large-file operations are effectively “progress-heavy” workloads. Even if the tool invocation itself is durable, the surrounding reasoning, progress, and partial text can create a huge amount of avoidable mutation churn.
+
+This is the direct answer to the large-file-write scenario: this technique helps because large-file operations tend to produce many small intermediate UI updates, and those should not all be treated like crash-critical persistence boundaries.
+
+### Work
+
+- [x] Add a targeted validation scenario for large streamed output / large-file write behavior.
+- [x] Confirm persistence flush count drops sharply versus baseline.
+- [x] Confirm the user still sees smooth progress and correct final durable state.
+
+### Detailed code changes
+
+- Extend existing latency validation or tests to simulate:
+  - [x] long streaming response,
+  - [x] tool progress and completion,
+  - [ ] large-file write workflow or equivalent sustained partial-update workload.
+- Use telemetry fields already added in latency instrumentation to compare:
+  - [ ] persistence flush count,
+  - [ ] save durations,
+  - [ ] chunk-to-webview timing.
+
+### Tests
+
+- [x] Performance/regression test: long stream causes far fewer persistence flushes than partial-update count.
+- [x] Validation harness comparison: baseline vs ephemeral-persistence-enabled variant.
+- [x] Regression test: final message history and resume state remain correct.
+
+Implementation note: the standalone validation harness at `scripts/validate-latency-scenarios.ts` is now wired to `npm run test:latency:validate` and completes successfully for local/remote plus enabled/disabled variants. In this standalone test environment, task-UI delta streaming is still absent (`taskDeltaCount: 0`), so the harness currently validates state/partial-message timing and completion behavior rather than delta-channel behavior.
+
+---
+
+## Step 8 — Rollout safeguards and developer controls
+
+### Goal
+
+Make the feature easy to disable, validate, and debug during rollout.
+
+### Mental model
+
+Hot-path changes need escape hatches. If behavior regresses in an edge case, the team should be able to isolate the feature quickly.
+
+### Work
+
+- [x] Keep or add env flag gating for ephemeral persistence behavior.
+- [x] Ensure telemetry can compare enabled vs disabled behavior.
+- [x] Add debug logging only if low-noise and useful.
+
+### Detailed code changes
+
+- In `src/core/task/latency.ts` / `.env.example`:
+  - [x] preserve `CLINE_DISABLE_EPHEMERAL_MESSAGE_PERSISTENCE` or equivalent.
+  - [x] document intended use for A/B validation.
+
+Treat the feature flag and validation path as first-class extraction requirements, not afterthoughts. Since the reference implementation already exists, the smoother development process is to keep comparison easy between “extracted technique enabled” and “feature disabled” modes.
+
+### Tests
+
+- [x] Unit test: disable flag routes behavior back to durable-per-update path where applicable.
+- [x] Validation harness variant: feature-disabled mode still behaves correctly.
+
+Implementation note: the validation harness includes an `ephemeral_disabled` variant for A/B runs and now verifies that the feature-disabled mode completes successfully in both local and remote hostbridge scenarios.
+
+---
+
+## Developer Checklist Summary
+
+- [x] Document the durability contract
+- [x] Add explicit ephemeral mutation APIs
+- [x] Add dirty tracking and explicit flush support
+- [x] Convert streaming partial callsites to ephemeral mutations
+- [x] Enforce durable flushes at semantic boundaries
+- [x] Add periodic safety flush scheduler
+- [x] Validate large-file / long-stream scenarios
+- [x] Preserve rollout flags and debugging support
+- [x] Run unit, integration, and validation-harness checks
+
+---
+
+## Final Mental Model Recap
+
+When implementing this technique, keep this in mind:
+
+- **Partial updates are for perception.**
+- **Durable saves are for recovery.**
+- **Doing recovery work on every animation step is what makes remote mode feel bad.**
+- **The fix is not to persist less carelessly; it is to persist more intentionally.**
+
+If this plan is implemented cleanly, large-file writes, long reasoning streams, and other high-churn tasks should feel markedly smoother in remote workspaces without sacrificing correctness.

evals/analysis/src/__tests__/classifier.test.ts

@@ -177,4 +177,22 @@ describe("FailureClassifier", () => {
 			expect(failures).toEqual([])
 		})
 	})
+
+	describe("YAML Safety (JSON_SCHEMA)", () => {
+		it("rejects patterns file with custom YAML tags", () => {
+			// Write a temp YAML file with a !!js/function tag
+			const fs = require("fs")
+			const path = require("path")
+			const os = require("os")
+			const tmpFile = path.join(os.tmpdir(), "unsafe-patterns.yaml")
+			fs.writeFileSync(
+				tmpFile,
+				`version: "1.0"\npatterns:\n  - name: !!js/function 'function(){ return "pwned" }'\n`,
+			)
+
+			expect(() => new FailureClassifier(tmpFile)).toThrow()
+
+			fs.unlinkSync(tmpFile)
+		})
+	})
 })

evals/analysis/src/classifier.ts

@@ -43,7 +43,7 @@ export class FailureClassifier {
 
 	private loadPatternsFromYaml(filePath: string): FailurePatternsConfig {
 		const content = fs.readFileSync(filePath, "utf-8")
-		const config = yaml.load(content) as FailurePatternsConfig
+		const config = yaml.load(content, { schema: yaml.JSON_SCHEMA }) as FailurePatternsConfig
 
 		if (!config.version || !config.patterns) {
 			throw new Error("Invalid patterns YAML: missing version or patterns")

evals/smoke-tests/run-smoke-tests.ts

@@ -11,15 +11,16 @@
  *   npx tsx evals/smoke-tests/run-smoke-tests.ts [options]
  *
  * Options:
- *   --provider <name>  Run tests for a specific provider (default: all configured)
  *   --trials <n>       Number of trials per test (default: 3)
  *   --scenario <name>  Run a specific scenario (default: all)
+ *   --model <id>       Override model for all scenarios
  *   --output <file>    Write JSON results to file
  */
 
 import { execSync, spawn } from "child_process"
 import * as fs from "fs"
 import * as path from "path"
+import * as dotenv from "dotenv"
 import { MetricsCalculator } from "../analysis/src/metrics"
 
 // Default provider and model for smoke tests
@@ -43,24 +44,23 @@ function checkClineCli(): boolean {
 // Use user's existing Cline config (already has auth configured)
 // For CI, this would be set up by the auth step before tests run
 const CLINE_CONFIG_DIR = path.join(process.env.HOME || "", ".cline")
+const configuredAuthCache = new Set<string>()
 
-// Configure authentication using CLINE_API_KEY environment variable
-// Returns success if auth is configured, error message otherwise
-function configureAuth(): { ok: boolean; error?: string } {
-	const apiKey = process.env.CLINE_API_KEY
-	if (!apiKey) {
-		return {
-			ok: false,
-			error: "CLINE_API_KEY environment variable not set",
-		}
-	}
-
+function configureAuth(options: { provider: string; apiKey: string; modelId: string; baseUrl?: string }): {
+	ok: boolean
+	error?: string
+} {
 	// Ensure config directory exists
 	fs.mkdirSync(CLINE_CONFIG_DIR, { recursive: true })
 
 	try {
 		// Run quick auth setup (non-interactive when all flags provided)
-		execSync(`cline auth --config "${CLINE_CONFIG_DIR}" -p ${DEFAULT_PROVIDER} -k "${apiKey}" -m "${DEFAULT_MODEL}"`, {
+		const args = [`cline auth --config "${CLINE_CONFIG_DIR}"`, `-p "${options.provider}"`, `-k "${options.apiKey}"`, `-m "${options.modelId}"`]
+		if (options.baseUrl) {
+			args.push(`-b "${options.baseUrl}"`)
+		}
+
+		execSync(args.join(" "), {
 			encoding: "utf-8",
 			timeout: 10000,
 			stdio: "pipe",
@@ -74,6 +74,22 @@ function configureAuth(): { ok: boolean; error?: string } {
 	}
 }
 
+function loadEnvFiles(): void {
+	const repoRoot = path.resolve(__dirname, "..", "..")
+	const envFiles = [path.join(repoRoot, ".env"), path.join(repoRoot, ".env.local")]
+	for (const envPath of envFiles) {
+		if (fs.existsSync(envPath)) {
+			dotenv.config({ path: envPath, override: false })
+		}
+	}
+}
+
+interface ScenarioAuthConfig {
+	apiKeyEnv?: string
+	baseUrlEnv?: string
+	modelId?: string
+}
+
 // Smoke test scenario definition
 interface SmokeScenario {
 	id: string
@@ -85,6 +101,9 @@ interface SmokeScenario {
 	expectedContent?: { file: string; contains: string }[] // Content checks
 	timeout: number // Seconds
 	models?: string[] // Optional: override default models for this scenario
+	provider?: string // Provider override (defaults to DEFAULT_PROVIDER)
+	requiredEnv?: string[] // Env vars required for this scenario to run
+	auth?: ScenarioAuthConfig // Optional auth overrides for provider-specific scenarios
 }
 
 // Load scenarios from disk
@@ -108,6 +127,54 @@ function loadScenarios(scenariosDir: string): SmokeScenario[] {
 	return scenarios
 }
 
+function getMissingEnvVars(requiredEnv: string[] | undefined): string[] {
+	if (!requiredEnv || requiredEnv.length === 0) {
+		return []
+	}
+	return requiredEnv.filter((key) => !process.env[key])
+}
+
+function getScenarioProvider(scenario: SmokeScenario): string {
+	return scenario.provider || DEFAULT_PROVIDER
+}
+
+function ensureScenarioAuth(scenario: SmokeScenario, modelId: string): { ok: boolean; error?: string } {
+	const provider = getScenarioProvider(scenario)
+	const authModelId = scenario.auth?.modelId || modelId
+	const apiKeyEnv = scenario.auth?.apiKeyEnv || (provider === DEFAULT_PROVIDER ? "CLINE_API_KEY" : undefined)
+	const apiKey = apiKeyEnv ? process.env[apiKeyEnv] : undefined
+	const baseUrl = scenario.auth?.baseUrlEnv ? process.env[scenario.auth.baseUrlEnv] : undefined
+	const authCacheKey = `${provider}|${authModelId}|${baseUrl || ""}|${apiKeyEnv || ""}`
+
+	if (apiKey) {
+		if (configuredAuthCache.has(authCacheKey)) {
+			return { ok: true }
+		}
+		const result = configureAuth({ provider, apiKey, modelId: authModelId, baseUrl })
+		if (result.ok) {
+			configuredAuthCache.add(authCacheKey)
+		}
+		return result
+	}
+
+	// For default provider, local developers can rely on existing ~/.cline auth.
+	if (provider === DEFAULT_PROVIDER) {
+		return { ok: true }
+	}
+
+	if (!apiKeyEnv) {
+		return {
+			ok: false,
+			error: `Provider '${provider}' requires auth.apiKeyEnv in scenario config or preconfigured credentials`,
+		}
+	}
+
+	return {
+		ok: false,
+		error: `Missing required auth env var '${apiKeyEnv}' for provider '${provider}'`,
+	}
+}
+
 // Run a single trial
 interface TrialResult {
 	passed: boolean
@@ -318,6 +385,8 @@ interface SmokeTestReport {
 
 // Main execution
 async function main() {
+	loadEnvFiles()
+
 	const args = process.argv.slice(2)
 
 	// Parse arguments
@@ -357,24 +426,6 @@ async function main() {
 		process.exit(1)
 	}
 
-	// Configure authentication if CLINE_API_KEY is set
-	// Otherwise use existing auth from ~/.cline
-	if (process.env.CLINE_API_KEY) {
-		console.log("Configuring authentication from CLINE_API_KEY...")
-		const authResult = configureAuth()
-		if (!authResult.ok) {
-			console.error("")
-			console.error("ERROR: Authentication failed")
-			console.error(`  ${authResult.error}`)
-			console.error("")
-			process.exit(1)
-		}
-		console.log("Authentication configured")
-	} else {
-		console.log("Using existing authentication from ~/.cline")
-	}
-	console.log("")
-
 	// Load scenarios
 	const scenariosDir = path.join(__dirname, "scenarios")
 	let scenarios = loadScenarios(scenariosDir)
@@ -392,12 +443,40 @@ async function main() {
 		}
 	}
 
+	const skippedByEnv: Array<{ id: string; missingEnv: string[] }> = []
+	if (selectedScenario) {
+		const missingEnv = getMissingEnvVars(scenarios[0].requiredEnv)
+		if (missingEnv.length > 0) {
+			console.error(`Scenario '${selectedScenario}' missing required env: ${missingEnv.join(", ")}`)
+			process.exit(1)
+		}
+	} else {
+		scenarios = scenarios.filter((scenario) => {
+			const missingEnv = getMissingEnvVars(scenario.requiredEnv)
+			if (missingEnv.length > 0) {
+				skippedByEnv.push({ id: scenario.id, missingEnv })
+				return false
+			}
+			return true
+		})
+	}
+
 	// Filter models
 	let models = MODELS
 	if (selectedModel) {
 		models = [selectedModel]
 	}
 
+	if (scenarios.length === 0) {
+		console.error("No runnable scenarios after env filtering")
+		if (skippedByEnv.length > 0) {
+			for (const skipped of skippedByEnv) {
+				console.error(`  - ${skipped.id}: missing ${skipped.missingEnv.join(", ")}`)
+			}
+		}
+		process.exit(1)
+	}
+
 	// Create results directory with timestamp
 	const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
 	const resultsBaseDir = path.join(__dirname, "results")
@@ -406,11 +485,17 @@ async function main() {
 
 	// Models are now always explicit
 	const resolvedModels = models
+	const providersInRun = [...new Set(scenarios.map((scenario) => getScenarioProvider(scenario)))]
 
 	console.log(`Running ${scenarios.length} scenarios × ${models.length} models × ${trials} trials`)
-	console.log(`Provider: ${DEFAULT_PROVIDER}`)
+	console.log(`Providers: ${providersInRun.join(", ")}`)
 	console.log(`Models: ${resolvedModels.join(", ")}`)
 	console.log(`Scenarios: ${scenarios.map((s) => s.id).join(", ")}`)
+	if (skippedByEnv.length > 0) {
+		console.log(
+			`Skipped by env: ${skippedByEnv.map((skipped) => `${skipped.id} (missing: ${skipped.missingEnv.join(", ")})`).join("; ")}`,
+		)
+	}
 	console.log(`Results: ${resultsDir}`)
 	console.log(`Parallel: ${parallel ? `yes (limit: ${parallelLimit})` : "no"}`)
 	console.log("")
@@ -420,7 +505,7 @@ async function main() {
 
 	// Build list of all scenario+model combinations
 	interface TestJob {
-		scenario: Scenario
+		scenario: SmokeScenario
 		modelId: string
 	}
 	const jobs: TestJob[] = []
@@ -437,6 +522,26 @@ async function main() {
 		const logDir = path.join(resultsDir, scenario.id, modelId)
 		fs.mkdirSync(logDir, { recursive: true })
 
+		const authResult = ensureScenarioAuth(scenario, modelId)
+		if (!authResult.ok) {
+			const trialResults = Array.from({ length: trials }, () => ({
+				passed: false,
+				error: authResult.error || "Scenario authentication failed",
+				durationMs: 0,
+				stdout: "",
+				stderr: "",
+			}))
+			return {
+				scenarioId: scenario.id,
+				scenarioName: scenario.name,
+				model: modelId,
+				modelId,
+				trials: trialResults,
+				metrics: metricsCalc.calculateTaskMetrics(trialResults.map((t) => t.passed)),
+				status: metricsCalc.getTaskStatus(trialResults.map((t) => t.passed)),
+			}
+		}
+
 		const trialResults: TrialResult[] = []
 		const trialWorkdirs: string[] = []
 
@@ -504,58 +609,23 @@ async function main() {
 		// Sequential execution
 		for (const job of jobs) {
 			console.log(`\n[${job.scenario.id}] ${job.scenario.name} (${job.modelId})`)
-			const logDir = path.join(resultsDir, job.scenario.id, job.modelId)
-			fs.mkdirSync(logDir, { recursive: true })
-
-			const trialResults: TrialResult[] = []
-			const trialWorkdirs: string[] = []
-
-			for (let t = 0; t < trials; t++) {
-				const trialWorkdir = path.join(logDir, `workspace-trial-${t + 1}`)
-				trialWorkdirs.push(trialWorkdir)
-				process.stdout.write(`  Trial ${t + 1}/${trials}... `)
-				const result = await runTrial(job.scenario, job.modelId, trialWorkdir)
-				trialResults.push(result)
-				console.log(result.passed ? "✓ PASS" : `✗ FAIL: ${result.error}`)
-			}
-
-			trialResults.forEach((result, t) => {
-				const trialNum = t + 1
-				const logContent =
-					`# Trial ${trialNum}\n` +
-					`Status: ${result.passed ? "PASS" : "FAIL"}\n` +
-					`Duration: ${result.durationMs}ms\n` +
-					(result.error ? `Error: ${result.error}\n` : "") +
-					`\n## STDOUT\n${result.stdout || "(empty)"}\n` +
-					`\n## STDERR\n${result.stderr || "(empty)"}\n`
-				fs.writeFileSync(path.join(logDir, `trial-${trialNum}.log`), logContent)
-			})
-
-			const trialBools = trialResults.map((t) => t.passed)
-			const metrics = metricsCalc.calculateTaskMetrics(trialBools)
-			const status = metricsCalc.getTaskStatus(trialBools)
-
-			results.push({
-				scenarioId: job.scenario.id,
-				scenarioName: job.scenario.name,
-				model: job.modelId,
-				modelId: job.modelId,
-				trials: trialResults,
-				metrics,
-				status,
+			const result = await runJob(job)
+			result.trials.forEach((trial, index) => {
+				console.log(`  Trial ${index + 1}/${trials}... ${trial.passed ? "✓ PASS" : `✗ FAIL: ${trial.error}`}`)
 			})
+			results.push(result)
 
 			// Display pass@k where k = actual trials (pass@3 is meaningless with fewer trials)
-			const passMetric = trials >= 3 ? metrics.passAt3 : metrics.passAt1
+			const passMetric = trials >= 3 ? result.metrics.passAt3 : result.metrics.passAt1
 			const passLabel = trials >= 3 ? "pass@3" : "pass@1"
-			console.log(`  Result: ${status.toUpperCase()} | ${passLabel}: ${(passMetric * 100).toFixed(0)}%`)
+			console.log(`  Result: ${result.status.toUpperCase()} | ${passLabel}: ${(passMetric * 100).toFixed(0)}%`)
 		}
 	}
 
 	// Generate report
 	const report: SmokeTestReport = {
 		timestamp: new Date().toISOString(),
-		provider: DEFAULT_PROVIDER,
+		provider: providersInRun.join(","),
 		models: resolvedModels,
 		scenarios: scenarios.map((s) => s.id),
 		trialsPerTest: trials,

evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/config.json

@@ -0,0 +1,28 @@
+{
+	"name": "Edit file with gpt-oss via OpenAI-compatible",
+	"description": "Reproduces openai-compatible gpt-oss file editing reliability when native tool calling is enabled",
+	"prompt": "Edit the file config.txt and change the line 'debug = false' to 'debug = true'. Prefer direct file-edit tools instead of shell command workarounds.",
+	"provider": "openai",
+	"models": [
+		"gpt-oss-120b"
+	],
+	"requiredEnv": [
+		"OPENAI_COMPAT_API_KEY",
+		"OPENAI_COMPAT_BASE_URL"
+	],
+	"auth": {
+		"apiKeyEnv": "OPENAI_COMPAT_API_KEY",
+		"baseUrlEnv": "OPENAI_COMPAT_BASE_URL",
+		"modelId": "gpt-oss-120b"
+	},
+	"expectedFiles": [
+		"config.txt"
+	],
+	"expectedContent": [
+		{
+			"file": "config.txt",
+			"contains": "debug = true"
+		}
+	],
+	"timeout": 180
+}

evals/smoke-tests/scenarios/08-openai-compat-gpt-oss-edit/template/config.txt

@@ -0,0 +1,11 @@
+# Application Configuration
+name = MyApp
+version = 1.0.0
+
+# Debug settings
+debug = false
+log_level = info
+
+# Server settings
+host = localhost
+port = 8080

locales/ar-sa/CONTRIBUTING.md

@@ -56,15 +56,10 @@
     - قم بتحديث الاختبارات الحالية إذا كانت تغييراتك تؤثر عليها
     - تضمين كل من اختبارات الوحدة واختبارات التكامل حيثما كان ذلك مناسبًا
 
-4. **إدارة الإصدار مع Changesets**
+4. **ملاحظات الإصدار وسجل التغييرات**
 
-    - أنشئ changeset لأي تغييرات واجهة المستخدم باستخدام `npm run changeset`
-    - اختر زيادة الإصدار المناسبة:
-        - `major` للتغييرات الكبيرة (1.0.0 → 2.0.0)
-        - `minor` للميزات الجديدة (1.0.0 → 1.1.0)
-        - `patch` لإصلاحات الأخطاء (1.0.0 → 1.0.1)
-    - اكتب رسائل changeset واضحة ووصفية تشرح التأثير
-    - لا تتطلب التغييرات في الوثائق فقط changesets
+    - لا يحتاج المساهمون إلى إنشاء ملفات changelog-entry ضمن PR.
+    - يتولى فريق الصيانة إدارة إصدار النسخ وتنسيق سجل التغييرات أثناء عملية الإصدار.
 
 5. **إرشادات الالتزام (Commit Guidelines)**
 
@@ -90,4 +85,4 @@
 
 من خلال إرسال طلب سحب، فإنك توافق على أن مساهماتك سيتم ترخيصها بنفس ترخيص المشروع ([Apache 2.0](LICENSE)).  
 
-تذكر: المساهمة في Cline لا تقتصر فقط على كتابة الكود - إنها تتعلق بأن تكون جزءًا من مجتمع يُشكل مستقبل التطوير بمساعدة الذكاء الاصطناعي. لنبنِ شيئًا رائعًا معًا! 🚀
+تذكر: المساهمة في Cline لا تقتصر فقط على كتابة الكود - إنها تتعلق بأن تكون جزءًا من مجتمع يُشكل مستقبل التطوير بمساعدة الذكاء الاصطناعي. لنبنِ شيئًا رائعًا معًا! 🚀

locales/ar-sa/README.md

@@ -163,27 +163,15 @@
 <details>
 <summary>إنشاء طلب سحب (Pull Request)</summary>
 
-1. قبل إنشاء PR، قم بإنشاء إدخال للتغييرات:
-    ```bash
-    npm run changeset
-    ```
-   سيطلب منك تحديد:
-   - نوع التغيير (رئيسي، ثانوي، إصلاح)
-     - `رئيسي` → تغييرات غير متوافقة (1.0.0 → 2.0.0)
-     - `ثانوي` → ميزات جديدة (1.0.0 → 1.1.0)
-     - `إصلاح` → إصلاحات للأخطاء (1.0.0 → 1.0.1)
-   - وصف التغييرات التي قمت بها  
+1. قم بعمل commit لتغييراتك.
 
-2. قم بحفظ التغييرات وملف `.changeset` الذي تم إنشاؤه  
+2. ادفع فرعك وأنشئ PR على GitHub. سيقوم CI بـ:
+   - تشغيل الاختبارات والفحوصات
 
-3. ادفع فرعك وأنشئ PR على GitHub. سيقوم CI بـ:
-   - تشغيل الاختبارات والفحوصات  
-   - سيقوم Changesetbot بإنشاء تعليق يوضح تأثير الإصدار  
-   - عند الدمج مع الفرع الرئيسي، سيقوم Changesetbot بإنشاء PR لحزم الإصدار  
-   - عند دمج PR لحزم الإصدار، سيتم نشر إصدار جديد  
+3. يتولى فريق الصيانة إدارة إصدار النسخ وتنسيق سجل التغييرات أثناء عملية الإصدار.
 
 </details>
 
 ## الرخصة
 
-[Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)
+[Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)

locales/ko/README.md

@@ -146,24 +146,12 @@ Cline이 작업을 진행하는 동안 확장 프로그램은 각 단계에서
 <details>
 <summary>Pull Request 생성 방법</summary>
 
-1. PR을 만들기 전, 변경 사항을 기록하는 changeset 항목을 생성:
-    ```bash
-    npm run changeset
-    ```
-   이후 프롬프트에서 다음 정보를 입력하세요:
-   - 변경 유형 (major, minor, patch)
-     - `major` → 호환되지 않는 변경 (1.0.0 → 2.0.0)
-     - `minor` → 새로운 기능 추가 (1.0.0 → 1.1.0)
-     - `patch` → 버그 수정 (1.0.0 → 1.0.1)
-   - 변경 사항 설명 입력
+1. 변경 사항을 커밋하세요.
 
-2. 변경 사항과 생성된 `.changeset` 파일을 커밋 후 브랜치를 푸시하고 GitHub에서 PR을 생성하세요.
-
-3. 브랜치를 푸시하고 GitHub에서 PR을 생성하세요. CI가 다음과 같은 작업을 수행합니다:
+2. 브랜치를 푸시하고 GitHub에서 PR을 생성하세요. CI가 다음과 같은 작업을 수행합니다:
    - 테스트 및 코드 검증 실행
-   - Changesetbot이 버전 변경 영향을 보여주는 코멘트를 생성
-   - 브랜치가 메인에 머지되면, Changesetbot이 버전 패키지 PR을 생성
-   - 버전 패키지 PR이 머지되면, 새로운 릴리즈가 게시됨
+
+3. 버전 관리 및 변경 로그 정리는 릴리스 과정에서 메인테이너가 처리합니다.
 
 </details>
 

locales/zh-tw/CONTRIBUTING.md

@@ -52,14 +52,9 @@
     - 若您的變更影響現有測試，請更新測試
     - 適當時包含單元測試與整合測試
 
-4. **使用 Changesets 管理版本**
-    - 使用 `npm run changeset` 為任何面向使用者的變更建立 changeset
-    - 選擇適當的版本升級：
-        - `major` 重大變更 (1.0.0 → 2.0.0)
-        - `minor` 新功能 (1.0.0 → 1.1.0)
-        - `patch` 錯誤修正 (1.0.0 → 1.0.1)
-    - 撰寫清晰且描述性的 changeset 訊息，說明影響
-    - 僅文件變更不需建立 changeset
+4. **版本與變更日誌說明**
+    - 貢獻者不需要在 PR 中建立 changelog-entry 檔案。
+    - 維護者會在發版流程中處理版本管理與變更日誌整理。
 
 5. **提交指引**
     - 撰寫清晰且描述性的提交訊息

locales/zh-tw/README.md

@@ -162,26 +162,12 @@ Cline 可以直接在您的編輯器中建立和編輯檔案，並顯示變更
 <details>
 <summary>建立 Pull Request</summary>
 
-1. 在建立 PR 前，產生一個 changeset 項目：
+1. 提交您的變更。
 
-    ```bash
-    npm run changeset
-    ```
-
-   這會提示您填寫：
-   - 變更類型（major、minor、patch）
-     - `major` → 重大變更（1.0.0 → 2.0.0）
-     - `minor` → 新功能（1.0.0 → 1.1.0）
-     - `patch` → 錯誤修正（1.0.0 → 1.0.1）
-   - 您的變更說明
-
-2. 提交您的變更和產生的 `.changeset` 檔案
-
-3. 推送您的分支並在 GitHub 上建立 PR。我們的 CI 會：
+2. 推送您的分支並在 GitHub 上建立 PR。我們的 CI 會：
    - 執行測試和檢查
-   - Changesetbot 會建立一個顯示版本影響的評論
-   - 當合併到 main 時，changesetbot 會建立一個 Version Packages PR
-   - 當 Version Packages PR 合併時，就會發布新版本
+
+3. 版本管理與變更日誌整理會由維護者在發版流程中處理。
 
 </details>
 

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.67.1",
+	"version": "3.73.0",
 	"icon": "assets/icons/icon.png",
 	"workspaces": [
 		".",
@@ -423,11 +423,13 @@
 		"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:latency:validate": "npx tsx scripts/validate-latency-scenarios.ts",
 		"test:tp-orchestrator": "npx tsx scripts/testing-platform-orchestrator.ts",
 		"e2e": "playwright test -c playwright.config.ts",
 		"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:cli:tui": "cd tests/e2e/cli && tui-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",
@@ -460,6 +462,7 @@
 	"devDependencies": {
 		"@biomejs/biome": "^2.3.14",
 		"@bufbuild/buf": "^1.54.0",
+		"@microsoft/tui-test": "0.0.1",
 		"@types/better-sqlite3": "^7.6.13",
 		"@types/chai": "^5.0.1",
 		"@types/clone-deep": "^4.0.4",

proto/cline/hooks.proto

@@ -14,6 +14,7 @@ message HookInput {
   string task_id = 4;
   repeated string workspace_roots = 5;
   string user_id = 6;
+  HookModelContext model = 7;
   oneof data {
     PreToolUseData pre_tool_use = 10;
     PostToolUseData post_tool_use = 11;
@@ -23,9 +24,15 @@ message HookInput {
     TaskCancelData task_cancel = 15;
     TaskCompleteData task_complete = 16;
     PreCompactData pre_compact = 17;
+    NotificationData notification = 18;
   }
 }
 
+message HookModelContext {
+  string provider = 1;
+  string slug = 2;
+}
+
 // Output message for all hooks
 message HookOutput {
   string context_modification = 1;
@@ -54,6 +61,14 @@ message UserPromptSubmitData {
   repeated string attachments = 2;
 }
 
+// Data for Notification hook
+message NotificationData {
+  string event = 1;
+  string source = 2;
+  string message = 3;
+  bool waiting_for_user_input = 4;
+}
+
 // Data for TaskStart hook
 message TaskStartData {
   map<string, string> task_metadata = 1;

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
@@ -283,6 +285,8 @@ message ModelsApiOptions {
   optional OcaModelInfo plan_mode_oca_model_info = 132;
   optional string plan_mode_aihubmix_model_id = 133;
   optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 134;
+  optional string plan_mode_cline_model_id = 135;
+  optional OpenRouterModelInfo plan_mode_cline_model_info = 136;
 
   // Act mode configurations
   optional ApiProvider act_mode_api_provider = 200;
@@ -320,6 +324,8 @@ message ModelsApiOptions {
   optional OcaModelInfo act_mode_oca_model_info = 232;
   optional string act_mode_aihubmix_model_id = 233;
   optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 234;
+  optional string act_mode_cline_model_id = 235;
+  optional OpenRouterModelInfo act_mode_cline_model_info = 236;
 }
 
 // Request for updating API configuration (legacy - uses combined configuration)
@@ -454,6 +460,7 @@ enum ApiProvider {
   AIHUBMIX = 38;
   NOUSRESEARCH = 39;
   OPENAI_CODEX = 40;
+  WANDB = 41;
 }
 
 enum ApiFormat {
@@ -592,6 +599,7 @@ message ModelsApiConfiguration {
   optional string aihubmix_app_code = 84;
   optional string nous_research_api_key = 85;
   optional bool azure_identity = 86;
+  optional string wandb_api_key = 87;
 
   // Plan mode configurations
   optional ApiProvider plan_mode_api_provider = 100;
@@ -634,6 +642,8 @@ message ModelsApiConfiguration {
   optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 137;
   optional string plan_mode_nous_research_model_id = 138;
   optional string gemini_plan_mode_thinking_level = 139;
+  optional string plan_mode_cline_model_id = 140;
+  optional OpenRouterModelInfo plan_mode_cline_model_info = 141;
 
   // Act mode configurations
   optional ApiProvider act_mode_api_provider = 200;
@@ -676,4 +686,6 @@ message ModelsApiConfiguration {
   optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 237;
   optional string act_mode_nous_research_model_id = 238;
   optional string gemini_act_mode_thinking_level = 239;
+  optional string act_mode_cline_model_id = 240;
+  optional OpenRouterModelInfo act_mode_cline_model_info = 241;
 }

proto/cline/state.proto

@@ -104,6 +104,7 @@ message Secrets {
   optional string oca_refresh_token = 42;
   optional string mcp_o_auth_secrets = 43;
   optional string cline_api_key = 44;
+  optional string wandb_api_key = 50;
   optional string openai_codex_oauth_credentials = 48;
 }
 
@@ -257,6 +258,7 @@ message Settings {
   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;
@@ -278,6 +280,10 @@ message Settings {
   optional bool worktrees_enabled = 172;
   optional bool auto_approve_all_toggled = 174;
   optional bool double_check_completion_enabled = 176;
+  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;
   map<string, string> open_ai_headers = 177;
 }
 
@@ -382,7 +388,6 @@ message UpdateTaskSettingsRequest {
 message UpdateSettingsRequest {
   reserved 15; // was openai_reasoning_effort (moved to mode-scoped reasoning effort)
   reserved 23; // was dictation_settings (dictation removed)
-  reserved 26; // was hooks_enabled (removed - now always enabled on macOS/Linux)
   reserved 38; // was skills_enabled (removed - now always enabled)
 
   Metadata metadata = 1;
@@ -406,6 +411,7 @@ message UpdateSettingsRequest {
   optional string default_terminal_profile = 21;
   optional bool yolo_mode_toggled = 22;
   optional bool multi_root_enabled = 25;
+  optional bool hooks_enabled = 26;
   optional string vscode_terminal_execution_mode = 27;
   optional int32 max_consecutive_mistakes = 28;
   optional bool subagents_enabled = 29;

scripts/build-proto.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 import chalk from "chalk"
-import { execSync } from "child_process"
+import { execFileSync, execSync } from "child_process"
+import fsSync from "fs"
 import * as fs from "fs/promises"
 import { globby } from "globby"
 import { createRequire } from "module"
@@ -12,7 +13,20 @@ import { main as generateHostBridgeClient } from "./generate-host-bridge-client.
 import { main as generateProtoBusSetup } from "./generate-protobus-setup.mjs"
 
 const require = createRequire(import.meta.url)
-const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
+const isWindows = process.platform === "win32"
+const GRPC_TOOLS_PROTOC = path.join(require.resolve("grpc-tools"), "../bin", isWindows ? "protoc.exe" : "protoc")
+// Legacy compatibility: some older/local Windows setups provision protoc into tmp-protoc.
+// Prefer that path when present, but fall back to the grpc-tools bundled binary used by CI/npm installs.
+const LEGACY_WINDOWS_PROTOC = path.resolve("tmp-protoc/bin/protoc.exe")
+const PROTOC = isWindows && fsSync.existsSync(LEGACY_WINDOWS_PROTOC) ? LEGACY_WINDOWS_PROTOC : GRPC_TOOLS_PROTOC
+
+if (!fsSync.existsSync(PROTOC)) {
+	const windowsHint = isWindows
+		? ` Neither ${LEGACY_WINDOWS_PROTOC} nor the grpc-tools bundled protoc at ${GRPC_TOOLS_PROTOC} exists.`
+		: ""
+	console.error(chalk.red(`protoc not found at ${PROTOC}.${windowsHint}`))
+	process.exit(1)
+}
 
 const PROTO_DIR = path.resolve("proto")
 const TS_OUT_DIR = path.resolve("src/shared/proto")
@@ -20,7 +34,6 @@ 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")
 
-const isWindows = process.platform === "win32"
 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")
@@ -62,16 +75,16 @@ async function compileProtos() {
 	tsProtoc(NICE_JS_OUT_DIR, protoFiles, ["outputServices=nice-grpc,useExactTypes=false", ...TS_PROTO_OPTIONS])
 
 	const descriptorFile = path.join(DESCRIPTOR_OUT_DIR, "descriptor_set.pb")
-	const descriptorProtocCommand = [
-		PROTOC,
-		`--proto_path="${PROTO_DIR}"`,
-		`--descriptor_set_out="${descriptorFile}"`,
+	const descriptorProtocArgs = [
+		`--proto_path=${PROTO_DIR}`,
+		`--descriptor_set_out=${descriptorFile}`,
 		"--include_imports",
 		...protoFiles,
-	].join(" ")
+	]
 	try {
 		log_verbose(chalk.cyan("Generating descriptor set..."))
-		execSync(descriptorProtocCommand, { stdio: "inherit" })
+		log_verbose(`${PROTOC} ${descriptorProtocArgs.join(" ")}`)
+		execFileSync(PROTOC, descriptorProtocArgs, { stdio: "inherit" })
 	} catch (error) {
 		console.error(chalk.red("Error generating descriptor set for proto file:"), error)
 		process.exit(1)
@@ -81,20 +94,18 @@ async function compileProtos() {
 	log_verbose(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))
 }
 
-async function tsProtoc(outDir, protoFiles, protoOptions) {
-	// Build the protoc command with proper path handling for cross-platform
-	const command = [
-		PROTOC,
-		`--proto_path="${PROTO_DIR}"`,
-		`--plugin=protoc-gen-ts_proto="${TS_PROTO_PLUGIN}"`,
-		`--ts_proto_out="${outDir}"`,
-		`--ts_proto_opt=${protoOptions.join(",")} `,
-		...protoFiles.map((s) => `"${s}"`),
-	].join(" ")
+function tsProtoc(outDir, protoFiles, protoOptions) {
+	const args = [
+		`--proto_path=${PROTO_DIR}`,
+		`--plugin=protoc-gen-ts_proto=${TS_PROTO_PLUGIN}`,
+		`--ts_proto_out=${outDir}`,
+		`--ts_proto_opt=${protoOptions.join(",")}`,
+		...protoFiles,
+	]
 	try {
 		log_verbose(chalk.cyan(`Generating TypeScript code in ${outDir} for:\n${protoFiles.join("\n")}...`))
-		log_verbose(command)
-		execSync(command, { stdio: "inherit" })
+		log_verbose(`${PROTOC} ${args.join(" ")}`)
+		execFileSync(PROTOC, args, { stdio: "inherit" })
 	} catch (error) {
 		console.error(chalk.red("Error generating TypeScript for proto files:"), error)
 		process.exit(1)

scripts/generate-state-proto.mjs

@@ -230,6 +230,40 @@ function snakeToCamel(str) {
 	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
 }
 
+/**
+ * Normalize a property key to the camelCase form parsed from proto field names.
+ * Example: "openai-codex-oauth-credentials" -> "openaiCodexOauthCredentials".
+ * We do this before looking up existing field numbers so regenerated proto fields
+ * reuse their old numbers instead of being treated as new fields.
+ */
+function normalizePropertyNameForProtoLookup(fieldName) {
+	return snakeToCamel(toProtoFieldName(fieldName))
+}
+
+/**
+ * Fail fast when two distinct property keys collapse to the same normalized lookup key.
+ * Collisions make field-number preservation ambiguous and can cause proto renumbering.
+ */
+function assertNoNormalizedFieldNameCollisions(fields) {
+	const normalizedToOriginalNames = new Map()
+
+	for (const field of fields) {
+		const normalizedName = normalizePropertyNameForProtoLookup(field.name)
+		const names = normalizedToOriginalNames.get(normalizedName) ?? new Set()
+		names.add(field.name)
+		normalizedToOriginalNames.set(normalizedName, names)
+	}
+
+	for (const [normalizedName, names] of normalizedToOriginalNames) {
+		if (names.size > 1) {
+			const sortedNames = [...names].sort()
+			throw new Error(
+				`Field-name collision after proto normalization: ${sortedNames.join(", ")} all normalize to "${normalizedName}". Rename one field to keep proto field-number mapping unambiguous.`,
+			)
+		}
+	}
+}
+
 /**
  * Parse field numbers from an existing proto message definition
  * Returns a map of camelCase field names to their field numbers
@@ -248,7 +282,8 @@ function parseProtoMessageFieldNumbers(protoContent, messageName) {
 	const messageBody = match[1]
 
 	// Match field definitions: optional/required/repeated type name = number;
-	const fieldRegex = /(?:optional|required|repeated)?\s*\w+\s+(\w+)\s*=\s*(\d+)\s*;/g
+	// Supports scalar/message types and map fields.
+	const fieldRegex = /(?:optional|required|repeated)?\s*(?:map<[^>]+>|[\w.]+)\s+(\w+)\s*=\s*(\d+)\s*;/g
 	const matches = messageBody.matchAll(fieldRegex)
 
 	for (const fieldMatch of matches) {
@@ -287,6 +322,8 @@ function assignFieldNumbers(fields, existingNumbers, startNumber = 1) {
 	const result = {}
 	let nextNumber = startNumber
 
+	assertNoNormalizedFieldNameCollisions(fields)
+
 	// Find the highest existing number
 	for (const num of Object.values(existingNumbers)) {
 		if (num >= nextNumber) {
@@ -296,8 +333,21 @@ function assignFieldNumbers(fields, existingNumbers, startNumber = 1) {
 
 	// Preserve existing assignments
 	for (const field of fields) {
-		if (existingNumbers[field.name] !== undefined) {
-			result[field.name] = existingNumbers[field.name]
+		// Normalize before lookup so keys like "openai-codex-oauth-credentials"
+		// reuse existing proto numbers instead of being treated as new fields.
+		const normalizedFieldName = normalizePropertyNameForProtoLookup(field.name)
+		const normalizedFieldNumber = existingNumbers[normalizedFieldName]
+		const rawFieldNumber = existingNumbers[field.name]
+
+		if (normalizedFieldNumber !== undefined && rawFieldNumber !== undefined && normalizedFieldNumber !== rawFieldNumber) {
+			throw new Error(
+				`Ambiguous proto field-number mapping for "${field.name}": normalized key "${normalizedFieldName}" -> ${normalizedFieldNumber}, raw key "${field.name}" -> ${rawFieldNumber}.`,
+			)
+		}
+
+		const existingFieldNumber = normalizedFieldNumber ?? rawFieldNumber
+		if (existingFieldNumber !== undefined) {
+			result[field.name] = existingFieldNumber
 		}
 	}
 

scripts/package-npm.mjs

@@ -12,7 +12,9 @@
  *   - cd cli && npm run build:production
  */
 
+import { fileURLToPath } from "node:url"
 import { execSync } from "child_process"
+import dotenv from "dotenv"
 import fs from "fs"
 import { cp } from "fs/promises"
 import path from "path"
@@ -21,10 +23,18 @@ const BUILD_DIR = "dist-standalone"
 const CLI_DIR = "cli"
 const IS_VERBOSE = process.argv.includes("-v") || process.argv.includes("--verbose")
 
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const rootDir = path.resolve(__dirname, "..")
+// Load .env from repo root
+dotenv.config({ path: path.join(rootDir, ".env") })
+
 async function main() {
 	console.log("🚀 Building Cline CLI NPM Package (TypeScript)\n")
 
 	await cleanBuildDir()
+	setupEnvironmentVariables()
+
 	await buildTypeScriptCli()
 	await copyCliDist()
 	await copyPackageJson()
@@ -36,6 +46,17 @@ async function main() {
 	console.log(`To publish: cd ${BUILD_DIR} && npm publish`)
 }
 
+function setupEnvironmentVariables() {
+	// Use a different API key for CLI error capturing, to redirect CLI errors to a different project
+	const cliErrorTrackingKey = process.env.CLI_ERROR_SERVICE_API_KEY
+	if (cliErrorTrackingKey) {
+		process.env.ERROR_SERVICE_API_KEY = cliErrorTrackingKey
+		// If we're sending to a different project, enable exception autocapture
+		process.env.ENABLE_ERROR_AUTOCAPTURE = "true"
+		log_verbose("Set ERROR_SERVICE_API_KEY for build")
+	}
+}
+
 /**
  * Clean the build directory
  */
@@ -59,7 +80,7 @@ async function buildTypeScriptCli() {
 	}
 
 	// Build production bundle
-	execSync("npm run build:production", { stdio: "inherit", cwd: CLI_DIR })
+	execSync("npm run build:production", { stdio: "inherit", cwd: CLI_DIR, env: process.env })
 	console.log("✓ TypeScript CLI built")
 }
 

scripts/validate-latency-scenarios.ts

@@ -0,0 +1,433 @@
+#!/usr/bin/env npx tsx
+
+import { type ChildProcess, spawn } from "node:child_process"
+import { once } from "node:events"
+import fs from "node:fs/promises"
+import net from "node:net"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { credentials } from "@grpc/grpc-js"
+import { AccountServiceClient } from "../src/generated/grpc-js/cline/account"
+import { StateServiceClient } from "../src/generated/grpc-js/cline/state"
+import { TaskServiceClient } from "../src/generated/grpc-js/cline/task"
+import { UiServiceClient } from "../src/generated/grpc-js/cline/ui"
+
+type ValidationMode = "local" | "remote"
+
+type ValidationVariant = {
+	name: string
+	env: Record<string, string>
+}
+
+type ScenarioResult = {
+	variant: string
+	mode: ValidationMode
+	newTaskRpcMs: number
+	firstStateMs: number | null
+	firstPartialMessageMs: number | null
+	firstTaskDeltaMs: number | null
+	completionMs: number | null
+	stateUpdateCount: number
+	partialMessageCount: number
+	taskDeltaCount: number
+	statePayloadBytes: number
+	taskDeltaPayloadBytes: number
+	messageCountAtCompletion: number | null
+	completed: boolean
+	error?: string
+}
+
+type StartedServer = {
+	child: ChildProcess
+	grpcPort: number
+	hostbridgePort: number
+	workspaceDir: string
+	getStderr: () => string
+}
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
+const PROJECT_ROOT = path.resolve(SCRIPT_DIR, "..")
+
+const variants: ValidationVariant[] = [
+	{ name: "default", env: {} },
+	{
+		name: "presentation_disabled",
+		env: {
+			CLINE_DISABLE_PRESENTATION_SCHEDULER: "true",
+		},
+	},
+	{
+		name: "ephemeral_disabled",
+		env: {
+			CLINE_DISABLE_EPHEMERAL_MESSAGE_PERSISTENCE: "true",
+		},
+	},
+	{
+		name: "delta_disabled",
+		env: {
+			CLINE_DISABLE_TASK_UI_DELTA_SYNC: "true",
+		},
+	},
+]
+
+async function waitForPort(port: number, timeoutMs = 20_000): Promise<void> {
+	const startedAt = Date.now()
+	while (Date.now() - startedAt < timeoutMs) {
+		try {
+			await new Promise<void>((resolve, reject) => {
+				const socket = net.connect(port, "127.0.0.1", () => {
+					socket.destroy()
+					resolve()
+				})
+				socket.on("error", reject)
+			})
+			return
+		} catch {
+			await new Promise((resolve) => setTimeout(resolve, 100))
+		}
+	}
+	throw new Error(`Timed out waiting for port ${port}`)
+}
+
+async function isPortBusy(port: number): Promise<boolean> {
+	try {
+		await new Promise<void>((resolve, reject) => {
+			const socket = net.connect(port, "127.0.0.1", () => {
+				socket.destroy()
+				resolve()
+			})
+			socket.on("error", reject)
+		})
+		return true
+	} catch {
+		return false
+	}
+}
+
+async function getFreePort(): Promise<number> {
+	return await new Promise((resolve, reject) => {
+		const server = net.createServer()
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address()
+			if (!address || typeof address === "string") {
+				server.close(() => reject(new Error("Unable to allocate port")))
+				return
+			}
+			const { port } = address
+			server.close((error) => {
+				if (error) {
+					reject(error)
+					return
+				}
+				resolve(port)
+			})
+		})
+		server.on("error", reject)
+	})
+}
+
+function unaryCall<T>(fn: (callback: (error: Error | null, response: T) => void) => void): Promise<T> {
+	return new Promise((resolve, reject) => {
+		fn((error, response) => {
+			if (error) {
+				reject(error)
+				return
+			}
+			resolve(response)
+		})
+	})
+}
+
+async function startServer(mode: ValidationMode, envOverrides: Record<string, string>): Promise<StartedServer> {
+	if (await isPortBusy(7777)) {
+		throw new Error(
+			"Cannot start latency validation harness because the mock API port 7777 is already in use. Stop the conflicting process and retry.",
+		)
+	}
+
+	const grpcPort = await getFreePort()
+	const hostbridgePort = await getFreePort()
+	const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "cline-latency-validate-"))
+	await fs.writeFile(path.join(workspaceDir, "test.ts"), 'export const name = "john"\n', "utf8")
+	const env: Record<string, string> = {
+		...process.env,
+		PROTOBUS_PORT: String(grpcPort),
+		HOSTBRIDGE_PORT: String(hostbridgePort),
+		WORKSPACE_DIR: workspaceDir,
+		E2E_TEST: "true",
+		CLINE_ENVIRONMENT: "local",
+		TEST_HOSTBRIDGE_REMOTE_NAME: mode === "remote" ? "ssh-remote" : "",
+		TEST_HOSTBRIDGE_PLATFORM: mode === "remote" ? "VS Code Remote" : "VS Code",
+		GRPC_RECORDER_ENABLED: "false",
+		...envOverrides,
+	}
+
+	const child = spawn("npx", ["tsx", path.join(PROJECT_ROOT, "scripts", "test-standalone-core-api-server.ts")], {
+		cwd: PROJECT_ROOT,
+		env,
+		stdio: ["ignore", "pipe", "pipe"],
+	})
+
+	child.stdout?.on("data", () => {
+		// Drain stdout so the spawned server cannot block on a full pipe buffer.
+	})
+
+	let stderr = ""
+	let exitedEarly = false
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString()
+	})
+	child.once("exit", () => {
+		exitedEarly = true
+	})
+
+	try {
+		await waitForPort(grpcPort)
+	} catch (error) {
+		if (exitedEarly) {
+			throw new Error(`Latency validation server exited before becoming ready.${stderr ? `\n${stderr.trim()}` : ""}`)
+		}
+		throw error
+	}
+	return { child, grpcPort, hostbridgePort, workspaceDir, getStderr: () => stderr }
+}
+
+async function stopServer(server: StartedServer) {
+	const { child, workspaceDir } = server
+	if (child.killed || child.exitCode !== null) {
+		await fs.rm(workspaceDir, { recursive: true, force: true })
+		return
+	}
+	child.kill("SIGINT")
+	try {
+		await Promise.race([once(child, "exit"), new Promise((resolve) => setTimeout(resolve, 5_000))])
+	} catch {
+		child.kill("SIGKILL")
+	}
+	await fs.rm(workspaceDir, { recursive: true, force: true })
+}
+
+async function runScenario(mode: ValidationMode, variant: ValidationVariant): Promise<ScenarioResult> {
+	const server = await startServer(mode, variant.env)
+	const address = `127.0.0.1:${server.grpcPort}`
+	const accountClient = new AccountServiceClient(address, credentials.createInsecure())
+	const stateClient = new StateServiceClient(address, credentials.createInsecure())
+	const taskClient = new TaskServiceClient(address, credentials.createInsecure())
+	const uiClient = new UiServiceClient(address, credentials.createInsecure())
+	const respondedAskTs = new Set<number>()
+
+	let currentTaskId: string | undefined
+	const startedAt = Date.now()
+	let firstStateMs: number | null = null
+	let firstPartialMessageMs: number | null = null
+	let firstTaskDeltaMs: number | null = null
+	let completionMs: number | null = null
+	let stateUpdateCount = 0
+	let partialMessageCount = 0
+	let taskDeltaCount = 0
+	let statePayloadBytes = 0
+	let taskDeltaPayloadBytes = 0
+	let messageCountAtCompletion: number | null = null
+	let completed = false
+	let lastMessagesSummary = ""
+
+	const stateStream = stateClient.subscribeToState({})
+	const partialStream = uiClient.subscribeToPartialMessage({})
+	type DeltaReadableStream = {
+		on(event: "data", listener: (event: { deltaJson?: string }) => void): DeltaReadableStream
+		on(event: "error", listener: (error: unknown) => void): DeltaReadableStream
+		cancel(): void
+	}
+	const deltaStreamFactory = (
+		uiClient as typeof uiClient & {
+			subscribeToTaskUiDeltas?: () => DeltaReadableStream
+		}
+	).subscribeToTaskUiDeltas
+	const deltaStream = deltaStreamFactory?.call(uiClient)
+	const activeStreams = [stateStream, partialStream, deltaStream].filter(
+		(stream): stream is Exclude<typeof stream, undefined> => stream !== undefined,
+	)
+
+	for (const stream of activeStreams) {
+		stream.on("error", (streamError: any) => {
+			if (streamError?.code === 1 || streamError?.details === "Cancelled on client") {
+				return
+			}
+			console.error("validation stream error", streamError)
+		})
+	}
+
+	stateStream.on("data", (response: { stateJson?: string }) => {
+		stateUpdateCount += 1
+		const stateJson = response.stateJson || "{}"
+		statePayloadBytes += Buffer.byteLength(stateJson, "utf8")
+		if (firstStateMs === null) {
+			firstStateMs = Date.now() - startedAt
+		}
+		try {
+			const state = JSON.parse(stateJson)
+			const activeTaskId = state.currentTaskItem?.id
+			if (activeTaskId) {
+				currentTaskId = activeTaskId
+			}
+			const clineMessages = Array.isArray(state.clineMessages) ? state.clineMessages : []
+			lastMessagesSummary = clineMessages
+				.slice(-5)
+				.map((message: any) => {
+					const kind = message.type === "ask" || message.type === 0 ? "ask" : "say"
+					const subtype = kind === "ask" ? message.ask : message.say
+					return `${kind}:${String(subtype)}:${String(message.text ?? "").slice(0, 60)}`
+				})
+				.join(" | ")
+			const lastMessage = clineMessages.at(-1)
+			const askType = lastMessage?.ask
+			const askTs = typeof lastMessage?.ts === "number" ? lastMessage.ts : undefined
+			const isAskMessage = lastMessage?.type === "ask" || lastMessage?.type === 0 || askType !== undefined
+			if (isAskMessage && askTs !== undefined && !respondedAskTs.has(askTs)) {
+				if (
+					askType === "tool" ||
+					askType === 5 ||
+					askType === "api_req_failed" ||
+					askType === 6 ||
+					askType === "completion_result" ||
+					askType === 4 ||
+					askType === "resume_completed_task" ||
+					askType === 8
+				) {
+					respondedAskTs.add(askTs)
+					void unaryCall((callback) =>
+						taskClient.askResponse(
+							{
+								metadata: undefined,
+								responseType: "yesButtonClicked",
+								text: "",
+								images: [],
+								files: [],
+							},
+							callback as any,
+						),
+					).catch((error) => {
+						console.error("validation askResponse error", error)
+					})
+				}
+			}
+			const hasCompletion = clineMessages.some(
+				(message: any) =>
+					message.ask === "completion_result" ||
+					message.ask === "resume_completed_task" ||
+					message.ask === 4 ||
+					message.ask === 8,
+			)
+			if (hasCompletion && completionMs === null) {
+				completionMs = Date.now() - startedAt
+				messageCountAtCompletion = clineMessages.length
+				completed = true
+			}
+		} catch {
+			// ignore parse errors in validation harness
+		}
+	})
+
+	partialStream.on("data", (message: { say?: string | number; text?: string }) => {
+		partialMessageCount += 1
+		if (
+			firstPartialMessageMs === null &&
+			(message.say === "text" || message.say === "reasoning" || message.say === 4 || message.say === 5)
+		) {
+			firstPartialMessageMs = Date.now() - startedAt
+		}
+	})
+
+	deltaStream?.on("data", (event: { deltaJson?: string }) => {
+		taskDeltaCount += 1
+		const deltaJson = event.deltaJson || ""
+		taskDeltaPayloadBytes += Buffer.byteLength(deltaJson, "utf8")
+		if (firstTaskDeltaMs === null) {
+			try {
+				const delta = JSON.parse(deltaJson)
+				if (delta.type?.startsWith("message_") || delta.type === "task_metadata_updated") {
+					firstTaskDeltaMs = Date.now() - startedAt
+				}
+			} catch {
+				// ignore parse errors
+			}
+		}
+	})
+
+	let newTaskRpcMs = 0
+	let error: string | undefined
+
+	try {
+		await unaryCall<{ value?: string }>((callback) => accountClient.accountLoginClicked({}, callback as any))
+		await unaryCall((callback) => accountClient.getUserOrganizations({}, callback as any))
+
+		const rpcStartedAt = Date.now()
+		const newTaskResponse = await unaryCall<{ value?: string }>((callback) =>
+			taskClient.newTask(
+				{
+					metadata: undefined,
+					text: "latency_validation",
+					images: [],
+					files: [],
+					taskSettings: undefined,
+				},
+				callback as any,
+			),
+		)
+		newTaskRpcMs = Date.now() - rpcStartedAt
+		currentTaskId = newTaskResponse.value || currentTaskId
+
+		const timeoutAt = Date.now() + 20_000
+		while (!completed && Date.now() < timeoutAt) {
+			await new Promise((resolve) => setTimeout(resolve, 100))
+		}
+		if (!completed) {
+			error = `Scenario timed out before completion. Last messages: ${lastMessagesSummary}`
+		}
+	} catch (scenarioError) {
+		error = scenarioError instanceof Error ? scenarioError.message : String(scenarioError)
+	}
+
+	stateStream.cancel()
+	partialStream.cancel()
+	deltaStream?.cancel()
+	accountClient.close()
+	stateClient.close()
+	taskClient.close()
+	uiClient.close()
+	await stopServer(server)
+
+	return {
+		variant: variant.name,
+		mode,
+		newTaskRpcMs,
+		firstStateMs,
+		firstPartialMessageMs,
+		firstTaskDeltaMs,
+		completionMs,
+		stateUpdateCount,
+		partialMessageCount,
+		taskDeltaCount,
+		statePayloadBytes,
+		taskDeltaPayloadBytes,
+		messageCountAtCompletion,
+		completed,
+		error,
+	}
+}
+
+async function main() {
+	const results: ScenarioResult[] = []
+	for (const mode of ["local", "remote"] as const) {
+		for (const variant of variants) {
+			results.push(await runScenario(mode, variant))
+		}
+	}
+	console.log(JSON.stringify({ results }, null, 2))
+}
+
+main().catch((error) => {
+	console.error(error)
+	process.exit(1)
+})

src/core/api/index.ts

@@ -42,6 +42,7 @@ 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"
@@ -97,6 +98,7 @@ function createHandlerForProvider(
 				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
 				thinkingBudgetTokens:
 					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
+				enableParallelToolCalling: options.enableParallelToolCalling,
 			})
 		case "bedrock":
 			return new AwsBedrockHandler({
@@ -253,7 +255,13 @@ function createHandlerForProvider(
 				vsCodeLmModelSelector:
 					mode === "plan" ? options.planModeVsCodeLmModelSelector : options.actModeVsCodeLmModelSelector,
 			})
-		case "cline":
+		case "cline": {
+			const clineModelId =
+				(mode === "plan" ? options.planModeClineModelId : options.actModeClineModelId) ||
+				(mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId)
+			const clineModelInfo =
+				(mode === "plan" ? options.planModeClineModelInfo : options.actModeClineModelInfo) ||
+				(mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo)
 			return new ClineHandler({
 				onRetryAttempt: options.onRetryAttempt,
 				clineAccountId: options.clineAccountId,
@@ -263,9 +271,11 @@ function createHandlerForProvider(
 				thinkingBudgetTokens:
 					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 				openRouterProviderSorting: options.openRouterProviderSorting,
-				openRouterModelId: mode === "plan" ? options.planModeOpenRouterModelId : options.actModeOpenRouterModelId,
-				openRouterModelInfo: mode === "plan" ? options.planModeOpenRouterModelInfo : options.actModeOpenRouterModelInfo,
+				openRouterModelId: clineModelId,
+				openRouterModelInfo: clineModelInfo,
+				enableParallelToolCalling: options.enableParallelToolCalling,
 			})
+		}
 		case "litellm":
 			return new LiteLlmHandler({
 				onRetryAttempt: options.onRetryAttempt,
@@ -443,6 +453,12 @@ function createHandlerForProvider(
 				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,

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

@@ -0,0 +1,119 @@
+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"])
+		})
+	})
+
+	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,
+			})
+		})
+	})
+})

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

@@ -1163,5 +1163,63 @@ describe("AwsBedrockHandler", () => {
 			// Turn 4: toolResult
 			formatted[3].content?.[0]?.toolResult?.toolUseId?.should.equal("call-2")
 		})
+
+		it("should silently skip thinking blocks without warnings", () => {
+			const h = new AwsBedrockHandler(mockOptions)
+			const conversation: any[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "thinking", thinking: "Let me reason about this...", signature: "sig123" },
+						{ type: "text", text: "Here is my response." },
+					],
+				},
+				{
+					role: "user",
+					content: [{ type: "text", text: "Thanks!" }],
+				},
+			]
+
+			const formatted = h["formatMessagesForConverseAPI"](conversation)
+
+			// Thinking block should be filtered out, only text remains
+			formatted[0].content?.should.have.length(1)
+			formatted[0].content?.[0]?.text?.should.equal("Here is my response.")
+			formatted[1].content?.[0]?.text?.should.equal("Thanks!")
+		})
+
+		it("should silently skip redacted_thinking blocks without warnings", () => {
+			const h = new AwsBedrockHandler(mockOptions)
+			const conversation: any[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "redacted_thinking", data: "encrypted_data_here" },
+						{ type: "text", text: "Response after redacted thinking." },
+					],
+				},
+			]
+
+			const formatted = h["formatMessagesForConverseAPI"](conversation)
+
+			// Redacted thinking block should be filtered out
+			formatted[0].content?.should.have.length(1)
+			formatted[0].content?.[0]?.text?.should.equal("Response after redacted thinking.")
+		})
+
+		it("should handle messages with only thinking blocks by producing empty content", () => {
+			const h = new AwsBedrockHandler(mockOptions)
+			const conversation: any[] = [
+				{
+					role: "assistant",
+					content: [{ type: "thinking", thinking: "Internal reasoning only", signature: "sig456" }],
+				},
+			]
+
+			const formatted = h["formatMessagesForConverseAPI"](conversation)
+
+			// All content filtered out
+			formatted[0].content?.should.have.length(0)
+		})
 	})
 })

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

@@ -226,6 +226,136 @@ describe("ClaudeCodeHandler", () => {
 		})
 	})
 
+	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({

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

@@ -1,6 +1,8 @@
 import "should"
 import { openRouterDefaultModelInfo } from "@shared/api"
 import sinon from "sinon"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { AuthService } from "@/services/auth/AuthService"
 import { ClineHandler } from "../cline"
 
 describe("ClineHandler", () => {
@@ -14,9 +16,14 @@ describe("ClineHandler", () => {
 		},
 	})
 
+	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 = Object.create(ClineHandler.prototype) as ClineHandler
-		;(handler as any).options = {}
+		const handler = createHandler({})
 		const fakeClient = {
 			chat: {
 				completions: {
@@ -56,4 +63,31 @@ describe("ClineHandler", () => {
 			},
 		])
 	})
+
+	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)
+	})
 })

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

@@ -52,4 +52,46 @@ describe("FireworksHandler", () => {
 			},
 		])
 	})
+
+	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,
+			},
+		])
+	})
 })

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

@@ -0,0 +1,190 @@
+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("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")
+	})
+})

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

@@ -1,7 +1,9 @@
 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"
 
@@ -246,4 +248,79 @@ describe("LiteLlmHandler", () => {
 			})
 		})
 	})
+
+	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)
+		})
+	})
 })

src/core/api/providers/__tests__/openrouter.test.ts

@@ -14,6 +14,8 @@ describe("OpenRouterHandler", () => {
 		},
 	})
 
+	const tools = [{ type: "function", function: { name: "read_file", description: "", parameters: { type: "object" } } }] as any
+
 	it("should handle usage-only chunks when delta is missing", async () => {
 		const handler = new OpenRouterHandler({
 			openRouterApiKey: "test-api-key",
@@ -57,4 +59,58 @@ describe("OpenRouterHandler", () => {
 			},
 		])
 	})
+
+	type ParallelToolCallsTestCase = {
+		modelId: string
+		enableParallelToolCalling: boolean
+		expectedParallelToolCalls: boolean
+	}
+
+	const parallelToolCallsTestCases: ParallelToolCallsTestCase[] = [
+		{
+			modelId: "openai/gpt-4o-mini",
+			enableParallelToolCalling: true,
+			expectedParallelToolCalls: true,
+		},
+		{
+			modelId: "openai/gpt-4o-mini",
+			enableParallelToolCalling: false,
+			expectedParallelToolCalls: false,
+		},
+		{
+			modelId: "google/gemini-3-flash-preview",
+			enableParallelToolCalling: true,
+			expectedParallelToolCalls: true,
+		},
+	]
+
+	for (const testCase of parallelToolCallsTestCases) {
+		const settingLabel = testCase.enableParallelToolCalling ? "enabled" : "disabled"
+		it(`should set parallel_tool_calls=${testCase.expectedParallelToolCalls} for ${testCase.modelId} when setting is ${settingLabel}`, async () => {
+			const handler = new OpenRouterHandler({
+				openRouterApiKey: "test-api-key",
+				enableParallelToolCalling: testCase.enableParallelToolCalling,
+			})
+			const createStub = sinon.stub().resolves(createAsyncIterable([]))
+			const fakeClient = {
+				chat: {
+					completions: {
+						create: createStub,
+					},
+				},
+			}
+			sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+			sinon.stub(handler, "getModel").returns({
+				id: testCase.modelId,
+				info: openRouterDefaultModelInfo,
+			})
+
+			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(testCase.expectedParallelToolCalls)
+		})
+	}
 })

src/core/api/providers/__tests__/wandb.test.ts

@@ -0,0 +1,42 @@
+import "should"
+import { openAiModelInfoSaneDefaults, wandbDefaultModelId, wandbModels } from "@shared/api"
+import { WandbHandler } from "../wandb"
+
+describe("WandbHandler", () => {
+	it("returns known catalog model metadata when model id is recognized", () => {
+		const modelId = "meta-llama/Llama-3.3-70B-Instruct"
+		const handler = new WandbHandler({
+			wandbApiKey: "test-api-key",
+			apiModelId: modelId,
+		})
+
+		const model = handler.getModel()
+
+		model.id.should.equal(modelId)
+		model.info.should.deepEqual(wandbModels[modelId])
+	})
+
+	it("passes through an explicit unknown model id instead of silently falling back", () => {
+		const unknownModelId = "moonshotai/Kimi-K2.5"
+		const handler = new WandbHandler({
+			wandbApiKey: "test-api-key",
+			apiModelId: unknownModelId,
+		})
+
+		const model = handler.getModel()
+
+		model.id.should.equal(unknownModelId)
+		model.info.should.deepEqual(openAiModelInfoSaneDefaults)
+	})
+
+	it("uses the default W&B model when no model id is configured", () => {
+		const handler = new WandbHandler({
+			wandbApiKey: "test-api-key",
+		})
+
+		const model = handler.getModel()
+
+		model.id.should.equal(wandbDefaultModelId)
+		model.info.should.deepEqual(wandbModels[wandbDefaultModelId])
+	})
+})

src/core/api/providers/anthropic.ts

@@ -1,7 +1,19 @@
 import { Anthropic } from "@anthropic-ai/sdk"
+import type {
+	MessageCreateParamsStreaming as BetaMessageCreateParamsStreaming,
+	BetaRawMessageStreamEvent,
+} from "@anthropic-ai/sdk/resources/beta/messages/messages"
 import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
+import type { MessageCreateParamsStreaming as AnthropicMessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages/messages"
 import { Stream as AnthropicStream } from "@anthropic-ai/sdk/streaming"
-import { AnthropicModelId, anthropicDefaultModelId, anthropicModels, CLAUDE_SONNET_1M_SUFFIX, ModelInfo } from "@shared/api"
+import {
+	ANTHROPIC_FAST_MODE_SUFFIX,
+	AnthropicModelId,
+	anthropicDefaultModelId,
+	anthropicModels,
+	CLAUDE_SONNET_1M_SUFFIX,
+	ModelInfo,
+} from "@shared/api"
 import { buildExternalBasicHeaders } from "@/services/EnvUtils"
 import { ClineStorageMessage } from "@/shared/messages/content"
 import { fetch } from "@/shared/net"
@@ -10,6 +22,8 @@ import { withRetry } from "../retry"
 import { sanitizeAnthropicMessages } from "../transform/anthropic-format"
 import { ApiStream } from "../transform/stream"
 
+export const ANTHROPIC_FAST_MODE_BETA = "fast-mode-2026-02-01"
+
 interface AnthropicHandlerOptions extends CommonApiHandlerOptions {
 	apiKey?: string
 	anthropicBaseUrl?: string
@@ -49,10 +63,30 @@ export class AnthropicHandler implements ApiHandler {
 		const client = this.ensureClient()
 
 		const model = this.getModel()
-		let stream: AnthropicStream<Anthropic.RawMessageStreamEvent>
+		let stream: AnthropicStream<Anthropic.RawMessageStreamEvent> | AsyncIterable<BetaRawMessageStreamEvent>
 
-		const modelId = model.id.endsWith(CLAUDE_SONNET_1M_SUFFIX) ? model.id.slice(0, -CLAUDE_SONNET_1M_SUFFIX.length) : model.id
-		const enable1mContextWindow = model.id.endsWith(CLAUDE_SONNET_1M_SUFFIX)
+		const useFastMode = model.id.endsWith(ANTHROPIC_FAST_MODE_SUFFIX)
+		const baseModelId = useFastMode ? model.id.slice(0, -ANTHROPIC_FAST_MODE_SUFFIX.length) : model.id
+		const modelId = baseModelId.endsWith(CLAUDE_SONNET_1M_SUFFIX)
+			? baseModelId.slice(0, -CLAUDE_SONNET_1M_SUFFIX.length)
+			: baseModelId
+		const enable1mContextWindow = baseModelId.endsWith(CLAUDE_SONNET_1M_SUFFIX)
+		const fastModeBetas = enable1mContextWindow
+			? [ANTHROPIC_FAST_MODE_BETA, "context-1m-2025-08-07"]
+			: [ANTHROPIC_FAST_MODE_BETA]
+		const createFastModeMessage = (
+			body: AnthropicMessageCreateParamsStreaming,
+		): Promise<AsyncIterable<BetaRawMessageStreamEvent>> => {
+			return (
+				client.beta.messages.create as unknown as (
+					params: BetaMessageCreateParamsStreaming & { speed: "fast" },
+				) => Promise<AsyncIterable<BetaRawMessageStreamEvent>>
+			)({
+				...body,
+				betas: fastModeBetas,
+				speed: "fast",
+			})
+		}
 
 		const budget_tokens = this.options.thinkingBudgetTokens || 0
 
@@ -62,48 +96,50 @@ export class AnthropicHandler implements ApiHandler {
 
 		if (model.info.supportsPromptCache) {
 			const anthropicMessages = sanitizeAnthropicMessages(messages, true)
+			const requestBody: AnthropicMessageCreateParamsStreaming = {
+				model: modelId,
+				thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
+				max_tokens: model.info.maxTokens || 8192,
+				// "Thinking isn’t compatible with temperature, top_p, or top_k modifications as well as forced tool use."
+				// (https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#important-considerations-when-using-extended-thinking)
+				temperature: reasoningOn ? undefined : 0,
+				system: [
+					{
+						text: systemPrompt,
+						type: "text",
+						cache_control: { type: "ephemeral" },
+					},
+				], // setting cache breakpoint for system prompt so new tasks can reuse it
+				messages: anthropicMessages,
+				// tools, // cache breakpoints go from tools > system > messages, and since tools dont change, we can just set the breakpoint at the end of system (this avoids having to set a breakpoint at the end of tools which by itself does not meet min requirements for haiku caching)
+				stream: true,
+				tools: nativeToolsOn ? tools : undefined,
+				// tool_choice options:
+				// - none: disables tool use, even if tools are provided. Claude will not call any tools.
+				// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
+				// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
+				// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
+				tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
+			}
 
-			stream = await client.messages.create(
-				{
-					model: modelId,
-					thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
-					max_tokens: model.info.maxTokens || 8192,
-					// "Thinking isn’t compatible with temperature, top_p, or top_k modifications as well as forced tool use."
-					// (https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#important-considerations-when-using-extended-thinking)
-					temperature: reasoningOn ? undefined : 0,
-					system: [
-						{
-							text: systemPrompt,
-							type: "text",
-							cache_control: { type: "ephemeral" },
-						},
-					], // setting cache breakpoint for system prompt so new tasks can reuse it
-					messages: anthropicMessages,
-					// tools, // cache breakpoints go from tools > system > messages, and since tools dont change, we can just set the breakpoint at the end of system (this avoids having to set a breakpoint at the end of tools which by itself does not meet min requirements for haiku caching)
-					stream: true,
-					tools: nativeToolsOn ? tools : undefined,
-					// tool_choice options:
-					// - none: disables tool use, even if tools are provided. Claude will not call any tools.
-					// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
-					// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
-					// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
-					tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
-				},
-				(() => {
-					// 1m context window beta header
-					if (enable1mContextWindow) {
-						return {
-							headers: {
-								"anthropic-beta": "context-1m-2025-08-07",
-							},
-						}
-					} else {
-						return undefined
-					}
-				})(),
-			)
+			stream = useFastMode
+				? await createFastModeMessage(requestBody)
+				: await client.messages.create(
+						requestBody,
+						(() => {
+							// 1m context window beta header
+							if (enable1mContextWindow) {
+								return {
+									headers: {
+										"anthropic-beta": "context-1m-2025-08-07",
+									},
+								}
+							}
+							return undefined
+						})(),
+					)
 		} else {
-			stream = await client.messages.create({
+			const requestBody: AnthropicMessageCreateParamsStreaming = {
 				model: modelId,
 				max_tokens: model.info.maxTokens || 8192,
 				temperature: 0,
@@ -112,7 +148,9 @@ export class AnthropicHandler implements ApiHandler {
 				tools: nativeToolsOn ? tools : undefined,
 				tool_choice: { type: "auto" },
 				stream: true,
-			})
+			}
+
+			stream = useFastMode ? await createFastModeMessage(requestBody) : await client.messages.create(requestBody)
 		}
 
 		const lastStartedToolCall = { id: "", name: "", arguments: "" }

src/core/api/providers/bedrock.ts

@@ -65,14 +65,18 @@ interface ContentBlockStart {
 	start?: {
 		type?: string
 		thinking?: string
+		signature?: string
 		toolUse?: ToolUseStart
 	}
 	contentBlock?: {
 		type?: string
 		thinking?: string
+		signature?: string
 	}
 	type?: string
 	thinking?: string
+	// Redacted thinking block data
+	data?: string
 }
 
 // Define types for stream response deltas
@@ -82,6 +86,7 @@ interface ContentBlockDelta {
 		type?: string
 		thinking?: string
 		text?: string
+		signature?: string
 		reasoningContent?: {
 			text?: string
 		}
@@ -102,7 +107,7 @@ interface ToolUseDelta {
 }
 
 // Define types for supported content types
-type SupportedContentType = "text" | "image" | "thinking"
+type SupportedContentType = "text" | "image" | "thinking" | "redacted_thinking" | "document"
 
 interface ContentItem {
 	type: SupportedContentType
@@ -628,6 +633,7 @@ export class AwsBedrockHandler implements ApiHandler {
 									yield {
 										type: "reasoning",
 										reasoning: reasoningBlock.text,
+										...(reasoningBlock.signature ? { signature: reasoningBlock.signature } : {}),
 									}
 								}
 							}
@@ -680,17 +686,33 @@ export class AwsBedrockHandler implements ApiHandler {
 						) {
 							if (blockIndex !== undefined) {
 								blockTypes.set(blockIndex, "reasoning")
+								// Capture signature if provided at block start
+								const signature = blockStart.start?.signature || blockStart.contentBlock?.signature || undefined
 								// Initialize content if provided
 								const initialContent =
 									blockStart.start?.thinking || blockStart.contentBlock?.thinking || blockStart.thinking || ""
-								if (initialContent) {
+								if (initialContent || signature) {
 									yield {
 										type: "reasoning",
-										reasoning: initialContent,
+										reasoning: initialContent || "",
+										...(signature ? { signature } : {}),
 									}
 								}
 							}
 						}
+
+						// Handle redacted thinking blocks
+						if (
+							blockStart.start?.type === "redacted_thinking" ||
+							blockStart.contentBlock?.type === "redacted_thinking" ||
+							blockStart.type === "redacted_thinking"
+						) {
+							yield {
+								type: "reasoning",
+								reasoning: "[Redacted thinking block]",
+								...(blockStart.data ? { redacted_data: blockStart.data } : {}),
+							}
+						}
 					}
 
 					// Handle content block delta - accumulate content by block index
@@ -707,8 +729,16 @@ export class AwsBedrockHandler implements ApiHandler {
 							const blockType = blockTypes.get(blockIndex)
 							const delta = chunk.contentBlockDelta.delta as ContentBlockDelta["delta"]
 
+							// Handle signature delta - used to send thinking block signatures
+							if (delta?.type === "signature_delta" && delta?.signature) {
+								yield {
+									type: "reasoning",
+									reasoning: "", // reasoning text already sent via thinking_delta
+									signature: delta.signature,
+								}
+							}
 							// Handle thinking delta (Anthropic SDK format)
-							if (delta?.type === "thinking_delta" || delta?.thinking) {
+							else if (delta?.type === "thinking_delta" || delta?.thinking) {
 								const thinkingContent = delta.thinking || delta.text || ""
 								if (thinkingContent) {
 									yield {
@@ -959,6 +989,12 @@ export class AwsBedrockHandler implements ApiHandler {
 							}
 						}
 
+						// Skip thinking blocks - Bedrock Converse API handles thinking via
+						// the thinking config parameter, not by replaying blocks in history
+						if (item.type === "thinking" || item.type === "redacted_thinking") {
+							return null
+						}
+
 						if (item.type === "tool_result") {
 							const content = (() => {
 								if (typeof item.content === "string") {

src/core/api/providers/claude-code.ts

@@ -2,6 +2,7 @@ import { filterMessagesForClaudeCode } from "@/integrations/claude-code/message-
 import { runClaudeCode } from "@/integrations/claude-code/run"
 import { ClaudeCodeModelId, claudeCodeDefaultModelId, claudeCodeModels } from "@/shared/api"
 import { ClineStorageMessage } from "@/shared/messages/content"
+import { Logger } from "@/shared/services/Logger"
 import { type ApiHandler, CommonApiHandlerOptions } from ".."
 import { withRetry } from "../retry"
 import { type ApiStream, ApiStreamUsageChunk } from "../transform/stream"
@@ -58,20 +59,47 @@ export class ClaudeCodeHandler implements ApiHandler {
 				continue
 			}
 
-			if (chunk.type === "system" && chunk.subtype === "init") {
-				// Based on my tests, subscription usage sets the `apiKeySource` to "none"
-				isPaidUsage = chunk.apiKeySource !== "none"
+			// Handle system init messages
+			if (chunk.type === "system" && "subtype" in chunk) {
+				if (chunk.subtype === "init") {
+					// Based on my tests, subscription usage sets the `apiKeySource` to "none"
+					isPaidUsage = (chunk as any).apiKeySource !== "none"
+				}
+				// Also handles legacy rate_limit_event format (type: "system", subtype: "rate_limit_event")
+				// by falling through — no special handling needed.
+				continue
+			}
+
+			// Handle rate_limit_event (newer CLI format: top-level type)
+			if (chunk.type === "rate_limit_event") {
+				// Rate limit events are informational. Log them but don't yield anything.
+				// If the rate limit blocks the response, the stream will end without
+				// assistant messages and the task loop will handle the empty response.
+				Logger.log("Claude Code rate limit event:", JSON.stringify(chunk))
+				continue
+			}
+
+			// Skip user messages (tool results from Claude Code's own tool execution)
+			if (chunk.type === "user") {
 				continue
 			}
 
 			if (chunk.type === "assistant" && "message" in chunk) {
 				const message = chunk.message
 
-				if (message.stop_reason !== null) {
-					const content = "text" in message.content[0] ? message.content[0] : undefined
+				// Check for error field on the message (newer CLI format)
+				if (message.error) {
+					const firstContent = message.content?.[0]
+					const errorText = firstContent && "text" in firstContent ? firstContent.text : undefined
+					throw new Error(errorText ?? `Claude Code error: ${message.error}`)
+				}
 
-					const isError = content && content.text.startsWith(`API Error`)
-					if (isError) {
+				if (message.stop_reason !== null) {
+					const firstContent = message.content?.[0]
+					const content = firstContent && "text" in firstContent ? firstContent : undefined
+
+					// Check if content exists before accessing its properties
+					if (content && content.text.startsWith(`API Error`)) {
 						// Error messages are formatted as: `API Error: <<status code>> <<json>>`
 						const errorMessageStart = content.text.indexOf("{")
 						const errorMessage = content.text.slice(errorMessageStart)
@@ -126,6 +154,21 @@ export class ClaudeCodeHandler implements ApiHandler {
 								},
 							}
 							break
+						default: {
+							// Handle unknown content block types gracefully.
+							// Newer Anthropic models or CLI versions may introduce new content types
+							// (e.g., server_tool_use, mcp_tool_use). Log them instead of silently dropping.
+							const unknownBlock = content as { type: string; text?: string }
+							Logger.warn(`Unhandled content type in Claude Code response: ${unknownBlock.type}`)
+							// If the unknown block has a text-like field, try to yield it as text
+							if (typeof unknownBlock.text === "string") {
+								yield {
+									type: "text",
+									text: unknownBlock.text,
+								}
+							}
+							break
+						}
 					}
 				}
 
@@ -142,10 +185,24 @@ export class ClaudeCodeHandler implements ApiHandler {
 			}
 
 			if (chunk.type === "result" && "result" in chunk) {
+				if (chunk.is_error) {
+					throw new Error(`Claude Code returned an error: ${chunk.result}`)
+				}
+
 				usage.totalCost = isPaidUsage ? chunk.total_cost_usd : 0
 
 				yield usage
+				continue
 			}
+
+			// ErrorMessage — log it explicitly and skip
+			if ((chunk as any).type === "error") {
+				Logger.warn("Claude Code emitted an error-type chunk:", JSON.stringify(chunk))
+				continue
+			}
+
+			// Any completely unrecognized chunk type — log and skip
+			Logger.warn(`Unrecognized Claude Code chunk type: ${(chunk as any).type}`)
 		}
 	}
 

src/core/api/providers/cline.ts

@@ -28,6 +28,7 @@ interface ClineHandlerOptions extends CommonApiHandlerOptions {
 	openRouterModelInfo?: ModelInfo
 	clineAccountId?: string
 	clineApiKey?: string
+	enableParallelToolCalling?: boolean
 }
 
 const CLINE_FREE_MODELS = ["minimax/minimax-m2.5", "kwaipilot/kat-coder-pro", "z-ai/glm-5"]
@@ -121,6 +122,7 @@ export class ClineHandler implements ApiHandler {
 				this.options.thinkingBudgetTokens,
 				this.options.openRouterProviderSorting,
 				tools,
+				this.options.enableParallelToolCalling,
 			)
 
 			const toolCallProcessor = new ToolCallProcessor()

src/core/api/providers/fireworks.ts

@@ -83,14 +83,20 @@ export class FireworksHandler implements ApiHandler {
 			}
 
 			if (chunk.usage) {
+				const usage = chunk.usage as OpenAI.CompletionUsage & {
+					prompt_cache_hit_tokens?: number
+					prompt_cache_miss_tokens?: number
+					prompt_tokens_details?: {
+						cached_tokens?: number
+					}
+				}
 				yield {
 					type: "usage",
-					inputTokens: chunk.usage.prompt_tokens || 0, // (deepseek reports total input AND cache reads/writes, see context caching: https://api-docs.deepseek.com/guides/kv_cache) where the input tokens is the sum of the cache hits/misses, while anthropic reports them as separate tokens. This is important to know for 1) context management truncation algorithm, and 2) cost calculation (NOTE: we report both input and cache stats but for now set input price to 0 since all the cost calculation will be done using cache hits/misses)
-					outputTokens: chunk.usage.completion_tokens || 0,
-					// @ts-expect-error-next-line
-					cacheReadTokens: chunk.usage.prompt_cache_hit_tokens || 0,
-					// @ts-expect-error-next-line
-					cacheWriteTokens: chunk.usage.prompt_cache_miss_tokens || 0,
+					inputTokens: usage.prompt_tokens || 0,
+					outputTokens: usage.completion_tokens || 0,
+					// Fireworks can return cache hits either as prompt_cache_hit_tokens or prompt_tokens_details.cached_tokens.
+					cacheReadTokens: usage.prompt_cache_hit_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0,
+					cacheWriteTokens: usage.prompt_cache_miss_tokens || 0,
 				}
 			}
 		}

src/core/api/providers/gemini.ts

@@ -9,6 +9,7 @@ import {
 	ThinkingLevel,
 } from "@google/genai"
 import { GeminiModelId, geminiDefaultModelId, geminiModels, ModelInfo } from "@shared/api"
+import { GEMINI_FLASH_MAX_OUTPUT_TOKENS, isGeminiFlashModel } from "@utils/model-utils"
 import { buildExternalBasicHeaders } from "@/services/EnvUtils"
 import { telemetryService } from "@/services/telemetry"
 import { ClineStorageMessage } from "@/shared/messages/content"
@@ -45,6 +46,18 @@ function mapReasoningEffortToGeminiThinkingLevel(effort: string): ThinkingLevel
 	}
 }
 
+function getGeminiMaxOutputTokens(modelId: string, modelMaxTokens?: number): number | undefined {
+	if (!isGeminiFlashModel(modelId)) {
+		return undefined
+	}
+
+	if (modelMaxTokens && modelMaxTokens > 0) {
+		return Math.min(modelMaxTokens, GEMINI_FLASH_MAX_OUTPUT_TOKENS)
+	}
+
+	return GEMINI_FLASH_MAX_OUTPUT_TOKENS
+}
+
 /**
  * Handler for Google's Gemini API with optimized caching strategy and accurate cost accounting.
  *
@@ -136,6 +149,9 @@ export class GeminiHandler implements ApiHandler {
 		const client = this.ensureClient()
 		const { id: modelId, info } = this.getModel()
 		const contents = messages.map(convertAnthropicMessageToGemini)
+		// Gemini may emit multiple function calls under the same responseId and without functionCall.id.
+		// Track a local sequence so each emitted tool call has a stable unique ID.
+		const responseToolCallCount = new Map<string, number>()
 
 		// Configure thinking budget/level if supported
 		const _thinkingBudget = this.options.thinkingBudgetTokens ?? 0
@@ -152,6 +168,7 @@ export class GeminiHandler implements ApiHandler {
 		}
 
 		// Set up base generation config
+		const maxOutputTokens = getGeminiMaxOutputTokens(modelId, info.maxTokens)
 		const requestConfig: GenerateContentConfig = {
 			// Add base URL if configured
 			httpOptions: this.options.geminiBaseUrl ? { baseUrl: this.options.geminiBaseUrl } : undefined,
@@ -159,6 +176,7 @@ export class GeminiHandler implements ApiHandler {
 			// Set temperature (default to 0)
 			// Gemini 3 recommends 1.0
 			temperature: info.temperature ?? 1,
+			...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
 		}
 
 		// Add thinking config only if the model supports it
@@ -210,6 +228,7 @@ export class GeminiHandler implements ApiHandler {
 
 			let isFirstSdkChunk = true
 			for await (const chunk of result) {
+				const responseKey = chunk.responseId || "gemini-response"
 				if (isFirstSdkChunk) {
 					sdkFirstChunkTime = Date.now()
 					ttftSdkMs = sdkFirstChunkTime - sdkCallStartTime
@@ -238,12 +257,21 @@ export class GeminiHandler implements ApiHandler {
 						const functionCall = part.functionCall
 						const args = Object.entries(functionCall.args || {}).filter(([_key, val]) => !!val)
 						if (functionCall.args && args.length > 0) {
+							const existingId = functionCall.id?.trim()
+							const toolCallId =
+								existingId ??
+								(() => {
+									const sequenceNumber = responseToolCallCount.get(responseKey) ?? 0
+									responseToolCallCount.set(responseKey, sequenceNumber + 1)
+									return `${responseKey}-tool-${sequenceNumber}`
+								})()
 							yield {
 								type: "tool_calls",
 								id: chunk.responseId,
 								tool_call: {
+									call_id: toolCallId,
 									function: {
-										id: chunk.responseId,
+										id: toolCallId,
 										name: functionCall.name,
 										arguments: JSON.stringify(functionCall.args),
 									},

src/core/api/providers/litellm.ts

@@ -72,26 +72,24 @@ export async function fetchLiteLlmModelsInfo(baseUrl: string, apiKey: string): P
 		if (response.ok) {
 			const data: LiteLlmModelInfoResponse = await response.json()
 			return data
-		} else {
-			Logger.error("Failed to fetch LiteLLM model info:", response.statusText)
-			// Try with Authorization header instead
-			const retryResponse = await fetch(url, {
-				method: "GET",
-				headers: {
-					accept: "application/json",
-					Authorization: `Bearer ${apiKey}`,
-					...buildExternalBasicHeaders(),
-				},
-			})
-
-			if (retryResponse.ok) {
-				const data: LiteLlmModelInfoResponse = await retryResponse.json()
-				return data
-			} else {
-				Logger.error("Failed to fetch LiteLLM model info with Authorization header:", retryResponse.statusText)
-				throw new Error(`Failed to fetch LiteLLM model info: ${retryResponse.statusText}`)
-			}
 		}
+		Logger.error("Failed to fetch LiteLLM model info:", response.statusText)
+		// Try with Authorization header instead
+		const retryResponse = await fetch(url, {
+			method: "GET",
+			headers: {
+				accept: "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				...buildExternalBasicHeaders(),
+			},
+		})
+
+		if (retryResponse.ok) {
+			const data: LiteLlmModelInfoResponse = await retryResponse.json()
+			return data
+		}
+		Logger.error("Failed to fetch LiteLLM model info with Authorization header:", retryResponse.statusText)
+		throw new Error(`Failed to fetch LiteLLM model info: ${retryResponse.statusText}`)
 	} catch (error) {
 		Logger.error("Error fetching LiteLLM model info:", error)
 		throw error
@@ -102,7 +100,7 @@ export class LiteLlmHandler implements ApiHandler {
 	private options: LiteLlmHandlerOptions
 	private client: OpenAI | undefined
 	private modelInfoCache: LiteLlmModelInfoResponse | undefined
-	private modelInfoCacheTimestamp: number = 0
+	private modelInfoCacheTimestamp = 0
 	private readonly modelInfoCacheTTL = 5 * 60 * 1000 // 5 minutes
 
 	constructor(options: LiteLlmHandlerOptions) {
@@ -274,7 +272,8 @@ export class LiteLlmHandler implements ApiHandler {
 								},
 							] as any,
 						}
-					} else if (Array.isArray(message.content)) {
+					}
+					if (Array.isArray(message.content)) {
 						// Apply cache control to the last content item in the array
 						return {
 							...message,
@@ -377,7 +376,7 @@ export class LiteLlmHandler implements ApiHandler {
 		const cachedModelInfo = StateManager.get().getModelInfo("liteLlm", modelId)
 
 		// Fall back to provided model info or defaults if not in cache
-		const modelInfo = cachedModelInfo || liteLlmModelInfoSaneDefaults
+		const modelInfo = cachedModelInfo || this.options.liteLlmModelInfo || liteLlmModelInfoSaneDefaults
 
 		return {
 			id: modelId,

src/core/api/providers/openrouter.ts

@@ -22,6 +22,7 @@ interface OpenRouterHandlerOptions extends CommonApiHandlerOptions {
 	openRouterProviderSorting?: string
 	reasoningEffort?: string
 	thinkingBudgetTokens?: number
+	enableParallelToolCalling?: boolean
 }
 
 export class OpenRouterHandler implements ApiHandler {
@@ -68,6 +69,7 @@ export class OpenRouterHandler implements ApiHandler {
 			this.options.thinkingBudgetTokens,
 			this.options.openRouterProviderSorting,
 			tools,
+			this.options.enableParallelToolCalling,
 		)
 
 		let didOutputUsage = false