Migrates the vscode extension off its hand-curated static model catalogs
in apps/vscode/src/shared/api.ts and on to the @cline/llms SDK as the
single source of truth for provider/model metadata, end-to-end across
the extension host and the webview.
Net impact on the static catalog file:
apps/vscode/src/shared/api.ts: 5092 -> 468 lines (~90% gone).
What changed at each layer
--------------------------
SDK / catalog plumbing (apps/vscode/src/sdk/model-catalog/):
- New `ProviderCatalog.peekModels(providerId)` synchronous cache read.
- `resolveModelInfo` rewritten: committed selection -> catalog peek
-> await catalog.resolveModels on cache miss. No race with a
background warmer; if the catalog truly has nothing, returns
source: "unknown" and the webview renders a neutral loading state.
- `applyHostModelInfoOverrides` is the canonical seam for the few
fields the SDK does not yet carry. Today it carries only the Vertex
`supportsGlobalEndpoint` allowlist (vertex-global-endpoint.ts, with
a TODO to upstream into the SDK).
- `ProviderListing` extended with SDK metadata (`is_popular`,
`popular_rank`, `usage_cost_display`, `capabilities[]`) and plumbed
through proto + conversion.
Extension-host handlers (apps/vscode/src/core/api/providers/):
- New shared helper `apps/vscode/src/shared/sdk-handler-models.ts`:
`getProviderModelFromSdk(providerId, requestedModelId, committedInfo?)`
returns `{ id, info }` from `getProviderCollectionSync` with
Vertex global-endpoint overrides applied.
- 27 handlers converted to a one-liner `getModel()` through that
helper. Per-handler nuances preserved:
* Anthropic: strips `:fast` and `:1m` host-side suffixes before
SDK lookup; carries them back on the returned id so the
per-request betas still flip.
* Bedrock: keeps the custom Application Inference Profile ARN
branch; base-model info from the SDK.
* Cerebras: keeps the `qwen-3-coder-480b-free` -> `qwen-3-coder-480b`
paid alias.
* Qwen / ZAi: SDK has a single catalog each; handlers keep the
regional base-URL switch but no longer fork the catalog.
* Wandb: keeps the "unknown id falls through to safe defaults"
escape hatch via `MODEL_COLLECTIONS_BY_PROVIDER_ID`.
Refresh-models background tasks:
- `refreshBasetenModels`, `refreshGroqModels`, `refreshHuggingFaceModels`
source their offline-fallback catalog from the SDK via
`getProviderCollectionSync` + `adaptSdkModelInfo`. Live fetch path
unchanged; only the seeding/fallback data changed.
Webview (apps/vscode/webview-ui/):
- `useNormalizedApiConfiguration` always routes through gRPC
`resolveModelInfo`. Removed the `isMigratedSdkProvider` /
`MIGRATED_SDK_PROVIDER_IDS` feature flag and the legacy
`normalizeApiConfiguration` switch entirely.
- New `useStaticProviderSelection` hook for the 22 settings
components whose catalog is now SDK-driven, and
`useDynamicProviderSelection` for the 12 dynamic-list pickers
(openrouter, cline, openai-compatible, ollama, lmstudio, requesty,
litellm, hicap, groq, baseten, huggingface, vercel-ai-gateway,
aihubmix, oca, huawei-cloud-maas, dify, fireworks, together,
vscode-lm) so all of them stop calling the legacy switch.
- `ModelInfoView` reads its `isGemini` check via
`useProviderModels("gemini")` instead of importing `geminiModels`.
- `App.stories.tsx` ships a small inline fixture instead of
importing `bedrockModels`.
- `ExtensionStateContext` no longer seeds `groqModelsState` /
`basetenModelsState` from the deleted catalog; the slices start
empty and the SDK-curated catalog is layered in by the pickers at
render time.
Misc:
- `src/utils/model-utils.ts`: `isAnthropicModelId` consults
`MODEL_COLLECTIONS_BY_PROVIDER_ID["anthropic"]` instead of the
deleted `anthropicModels` map.
- `src/shared/storage/provider-keys.ts`: `getProviderDefaultModelId`
no longer hard-codes 24 per-provider defaults. The function now
consults the SDK catalog and only keeps an override map for
providers whose default is intentionally not the SDK default
(openrouter-shared dynamic providers and local-only providers).
- `src/shared/openai-codex-models.ts`: relative path for
`shape-adapter` import so both the extension and webview build
contexts resolve it identically.
Tests retargeted to assert SDK behavior, not static-map shapes
--------------------------------------------------------------
- claude-code, anthropic, bedrock, vertex, wandb, provider-keys
test suites had assertions tied to deleted shapes. Rewrote them
to either assert through the SDK catalog
(anthropic compares against `adaptSdkModelInfo(sdkCollection.models[id])`,
wandb uses the SDK-declared default, etc.) or focus on the
host-side semantics (bedrock's "global endpoint" block now tests
`vertexModelSupportsGlobalEndpoint` directly).
- claude-code test trimmed its 8 `[1m]`/version-pin variants down
to three SDK-shaped cases. The 8 deleted assertions exercised
extension-only model-id derivations that the SDK does not carry;
matching the CLI's behavior was the explicit goal.
- resolveModelInfo test rewritten around the new peek -> await
-> unknown contract.
- proto-lint: added missing `go_package` option to
`proto/cline/remote_config.proto`.
Verification (npm scripts under apps/vscode/):
- npm run protos OK
- npm run check-types OK (apps/vscode + apps/vscode/webview-ui)
- npm run lint OK (biome + proto-lint)
- npm run build:webview OK (tsc -b && vite build)
- node esbuild.mjs OK (dist/extension.js produced)
- Runtime smoke test: 27/27 provider collections resolve from the
SDK with correct model counts, defaults, and usage-cost-display
flags. openai-codex returns cost=hide as expected; every other
provider returns cost=show.
Cline
The open source coding agent in your IDE and terminal.
CLIRun Cline in your terminal. Interactive chat or fully headless for CI/CD and scripting. |
KanbanRun many agents in parallel from a web-based task board. Each card gets its own worktree, auto-commit, and dependency chains. |
VS Code ExtensionAI coding assistant in your editor. Create files, run commands, browse the web, and use tools with human-in-the-loop approval. |
JetBrains PluginThe same Cline experience in IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the rest of the JetBrains family. |
SDKBuild your own AI agents and integrations powered by the same engine that runs the CLI, Kanban, VS Code extension, and JetBrains plugin. Custom tools, multi-agent teams, connectors, scheduled automations, and more. |
Index
| Product | Description | Location | CHANGELOG |
|---|---|---|---|
| SDK | Node.js programmatic agent API and extension exports. | sdk/ |
CHANGELOG.md |
| CLI | Terminal UI, headless mode, shell commands, and CLI-specific flows. | sdk/apps/cli/ |
CHANGELOG.md |
| VS Code Extension | The Marketplace extension and extension host integration. | / (WIP migrating) |
CHANGELOG.md |
| JetBrains Plugin | JetBrains-hosted client that talks to the shared agent core. | Currently we are not open-sourcing JetBrains plugins | - |
| Kanban | Web-based multi-agent task board. | cline/kanban |
CHANGELOG.md |
| Docs site | Public documentation pages. | docs/ |
- |
Edits Code Across Your Project
Cline reads your project structure, understands the relationships between files, and makes coordinated changes across your codebase. It monitors linter and compiler errors as it works, fixing issues like missing imports, type mismatches, and syntax errors before you even see them. In VS Code and JetBrains, every edit shows up as a diff you can review, modify, or revert. All changes are tracked with checkpoints, so you can easily undo the agent's work.
Runs Bash Commands
Cline executes commands directly in your terminal and watches the output in real time. Install packages, run build scripts, execute tests, deploy applications, manage databases. For long-running processes like dev servers, Cline continues working in the background and reacts to new output as it appears, catching compile errors, test failures, and server crashes as they happen.
Plan and Act
Toggle between Plan mode and Act mode. In Plan mode, Cline explores your codebase, asks clarifying questions, and lays out a strategy. Once you're aligned, switch to Act mode and Cline executes the plan. Every file edit and terminal command requires your approval, so you stay in control of what actually changes. Or toggle auto-approve and let Cline run autonomously.
Rules and Skills
Define project-specific rules in .clinerules files that guide how Cline works in your codebase: coding standards, architecture conventions, deployment procedures, testing requirements. Rules are picked up automatically by the CLI, VS Code extension, and JetBrains plugin. Use skills to let the model load specific rules when needed.
Works With Every Model
Cline is not locked to a single AI provider. Use whichever model fits your workflow:
| Provider | Models |
|---|---|
| Anthropic | Claude Opus, Sonnet, Haiku |
| OpenAI | GPT series model |
| Gemini series model | |
| OpenRouter | 200+ models from any provider |
| Vercel AI Gateway | Models through Vercel AI Gateway |
| AWS Bedrock | Claude, Llama, and more |
| Azure / GCP Vertex | All hosted models |
| Cerebras / Groq | Fast inference models |
| Ollama / LM Studio | Run local models on your machine |
| Any OpenAI-compatible API | Self-hosted or third-party endpoints |
Extend With Plugins or MCP Servers
Extend Cline's capabilities with plugins. Using the SDK, register tools and lifecycle hooks programmatically through the plugin system for logging, auditing, policy enforcement, or adding domain-specific capabilities. Simple plugin example below.
import { Agent, createTool } from "@cline/sdk"
const deployTool = createTool({
name: "deploy",
description: "Deploy the current branch to staging.",
inputSchema: { type: "object", properties: { env: { type: "string" } }, required: ["env"] },
execute: async (input) => {
// your deployment logic
},
})
const agent = new Agent({ tools: [deployTool], /* ... */ })
...or use MCP servers to connect to databases, query APIs, manage cloud infrastructure, and interact with external systems. Use community-built servers or ask Cline to create custom tools on the fly. In the CLI, manage servers with cline mcp.
Multi-Agent Teams
Coordinate multiple agents working together on complex tasks. A coordinator agent breaks the work into subtasks and delegates to specialist agents, each with their own tools and context. Team state persists across sessions so you can pick up where you left off.
cline --team-name auth-sprint "Plan and implement user authentication with tests"
Scheduled Agents
Run agents on cron schedules for recurring automations. Daily PR summaries, weekly dependency checks, codebase health reports. Schedules persist across restarts and run independently of any terminal session.
cline schedule create "PR summary" \
--cron "0 9 * * MON-FRI" \
--prompt "List all open PRs and their review status" \
--workspace /path/to/repo
Connect to Slack, Telegram, Discord, and More
Chat with your agent from any messaging platform: Telegram, Slack, Discord, Google Chat, WhatsApp, and Linear. Each conversation thread maps to an agent session with full context. Set up access control to restrict who can interact with your agent.
cline connect telegram -k $BOT_TOKEN
cline connect slack --token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
Headless CLI for CI/CD
Run Cline with zero interaction for scripting and automation. Pipe input, get JSON output, chain commands, integrate into CI/CD pipelines.
cline "Run tests and fix any failures"
git diff origin/main | cline "Review these changes for issues"
cline --json "List all TODO comments" | jq -r 'select(.type == "agent_event" and .event.text) | .event.text'
Contributing
Start with the Contributing Guide. Join our Discord and head to the #contributors channel to connect with other contributors. Check our careers page for full-time roles.