fix: bake resolved config path into hook scripts at install time

Uses getDocumentsPath() to resolve the actual Documents folder,
writes webhook_config.json there, and embeds the full resolved
path in the generated hook scripts. This way hooks work correctly
even if Documents is in a non-standard location (OneDrive, etc.).

.agents/skills/create-pull-request/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: create-pull-request
-description: Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, and PR creation using the gh CLI tool.
+description: Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, PR template usage, and PR creation using the gh CLI tool.
 ---
 
 # Create Pull Request

.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

.changeset/clear-rockets-happen.md

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

.changeset/config.json

@@ -1,11 +0,0 @@
-{
-	"$schema": "https://unpkg.com/@changesets/config@3.0.5/schema.json",
-	"changelog": "@changesets/cli/changelog",
-	"commit": false,
-	"fixed": [],
-	"linked": [],
-	"access": "restricted",
-	"baseBranch": "main",
-	"updateInternalDependencies": "patch",
-	"ignore": []
-}

.changeset/cuddly-phones-count.md

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

.changeset/early-beers-glow.md

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

.changeset/neat-seals-guess.md

@@ -0,0 +1,5 @@
+---
+"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/smoke-test-retries.md

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

.changeset/strong-dolls-beam.md

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

.changeset/tender-berries-search.md

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

.changeset/wacky-ends-relax.md

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

.changie.yaml

@@ -1,26 +0,0 @@
-changesDir: .changes
-unreleasedDir: unreleased
-headerPath: header.tpl.md
-changelogPath: CHANGELOG.md
-versionExt: md
-versionFormat: '## {{.Version}} - {{.Time.Format "2006-01-02"}}'
-kindFormat: "### {{.Kind}}"
-changeFormat: "* {{.Body}}"
-kinds:
-    - label: Added
-      auto: minor
-    - label: Changed
-      auto: major
-    - label: Deprecated
-      auto: minor
-    - label: Removed
-      auto: major
-    - label: Fixed
-      auto: patch
-    - label: Security
-      auto: patch
-newlines:
-    afterChangelogHeader: 1
-    beforeChangelogVersion: 1
-    endOfVersion: 1
-envPrefix: CHANGIE_

.clinerules/general.md

@@ -14,7 +14,7 @@ This file is the secret sauce for working effectively in this codebase. It captu
 
 ## Miscellaneous
 - This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `npm run compile`, not `npm run build`).
-- When creating PRs, if the change is user-facing and significant enough to warrant a changelog entry, run `npm run changeset` and create a patch changeset. Never create minor or major version bumps. Skip changesets for trivial fixes, internal refactors, or minor UI tweaks that users wouldn't notice.
+- When creating PRs, contributors should not create changelog-entry files. Maintainers handle release versioning and changelog curation during the release process.
 - When adding new feature flags, see this PR as a reference https://github.com/cline/cline/pull/7566
 - Additional instructions about making requests: @.clinerules/network.md
 

.clinerules/workflows/address-pr-comments.md

@@ -19,7 +19,7 @@ Review and address all comments on the current branch's PR.
    - Inline comments: `gh api repos/{owner}/{repo}/pulls/{pr_number}/comments`
    - General comments: `gh pr view {pr_number} --json comments,reviews`
 
-4. Present a summary of all comments with your recommendation for each (apply, skip, or respond). Ignore bot noise (changeset-bot, CI status, etc.).
+4. Present a summary of all comments with your recommendation for each (apply, skip, or respond). Ignore bot noise (release automation, CI status, etc.).
 
 5. **Wait for my approval** before proceeding.
 

.clinerules/workflows/extension-release.md

@@ -1,549 +0,0 @@
-The goal of this workflow is to take a changeset for a release of Cline, an autonomous coding agent extension that plugs right into your IDE, and write the updated announcement component, and the updated changelog. 
-
-
-For reference, here are some examples of how we converted previous changesets to announcement components / changelogs. 
-
-
-- 3.14
-<changeset>
-This PR was opened by the Changesets release GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or setup this action to publish automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-Releases
-claude-dev@3.14.0
-Minor Changes
-77c9863: create clinerules folder if its currently a file and creating new rule
-0ffb7dd: disabling shift hint for now & improving tooltip behavior
-79b76fd: Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile.
-eb6e481: Full support for LaTeX rendering
-df37f29: Add support for custom API request timeout. Previously, timeouts were hardcoded to 30 seconds for providers like Ollama or 15 seconds for OpenRouter and Cline. Now users can set a custom timeout value in milliseconds through the settings interface.
-e4d26be: allow cursorrules and windsurfrules
-c5de50f: Fix Handle @withRetry() SyntaxError when running extension locally issue
-61d2f42: enabled pricing calculation for gemini and vertex + more robust caching & cache tracking for gemini & vertex
-aed152b: add truncation notice when truncating manually
-2fe2405: Migrate Cline Tools Section to new docs
-19cc8bc: Add a timeout setting for the terminal connection, allowing users to adjust this if they are having timeout issues
-03d4410: Added copy button to code blocks.
-c78fe23: addressed race condition in terminal command usage
-91e222f: add checkpoints after more messages
-14230e7: add newrule slash command
-1c7d33a: Add remote config with posthog allowing for disabling new features until they're reading, making for a better developer experience.
-4196c14: add cache ui for open router and cline provider
-d97424f: showing expanded task by default
-5294e78: Refactor to not pass a message for showing the MCP View from the servers modal
-70cc437: Fix Windows path issue: Correct handling of import.meta.url to avoid leading slash in pathname
-4b697d8: Migrate the addRemoteServer to protobus
-Patch Changes
-c63d9a1: updated drag and drop text to say "drop" instead of "drag"
-459adf0: Add markdown copy to chat
-74ec823: Minor UX improvement to drag and drop ux
-b0961f4: Remove linear pull request action
-e9ce384: searchCommits protobus migration
-5802b68: createRuleFile protobus migration
-df7f9fc: Add dependsOn to more blocks in the tasks.json
-41ae732: Fix for git commit mentions in repos with no git commits
-7e78445: Adding args to allow Cursor to open workspaces (for checkpoint testing/development)
-bdfda6f: feat(bedrock): Introduce Amazon Nova Premier
-65243ad: Introduce UI library for future UI development
-4565e06: checkIsImageURL migrated to protobus
-5a8e9d8: protobus migration for openImage
-deeda6e: Lowering Gemini cache TTL time
-db0b022: Adding UI to show openrouter balance next to provider
-4650ffa: deleteRuleFile protobus migration
-d4bd755: fix cost calculation
-</changeset>
-
-<changelog>
-## [3.14.0]
-
--   Add UI to show openrouter balance next to provider
--   Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile (Thanks @clicube!)
--   Add more robust caching & cache tracking for gemini & vertex providers
--   Add support for LaTeX rendering
--   Add support for custom API request timeout. Timeouts were 15-30s, but can now be configured via settings for OpenRouter/Cline & Ollama (Thanks @WingsDrafterwork!)
--   Add truncation notice when truncating manually
--   Add a timeout setting for the terminal connection, allowing users to set a time to wait for terminal startup
--   Add copy button to code blocks
--   Add copy button to markdown blocks (Thanks @weshoke!)
--   Add checkpoints to more messages
--   Add slash command to create a new rules file (/newrule)
--   Add cache ui for open router and cline provider
--   Add Amazon Nova Premier model to Bedrock (Thanks @watany!)
--   Add support for cursorrules and windsurfrules
--   Add support for batch history deletion (Thanks @danix800!)
--   Improve Drag & Drop experience
--   Create clinerules folder creating new rule if it's needed
--   Enable pricing calculation for gemini and vertex providers
--   Refactor message handling to not show the MCP View of the server modal
--   Migrate the addRemoteServer to protobus (Thanks @DaveFres!)
--   Update task header to be expanded by default
--   Update Gemini cache TTL time to 15 minutes
--   Fix race condition in terminal command usage
--   Fix to correctly handle `import.meta.url`, avoiding leading slash in pathname for Windows (Thanks @DaveFres!)
--   Fix @withRetry() decoration syntax error when running extension locally (Thanks @DaveFres!)
--   Fix for git commit mentions in repos with no git commits
--   Fix cost calculation (Thanks @BarreiroT!)
-</changelog>
-
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Gemini prompt caching:</b> Gemini and Vertex providers now support prompt caching and price tracking for
-					Gemini models.
-				</li>
-				<li>
-					<b>Copy Buttons:</b> Buttons were added to Markdown and Code blocks that allow you to copy their contents
-					easily.
-				</li>
-				<li>
-					<b>/newrule command:</b> New slash command to have cline write your .clinerules for you based on your
-					workflow.
-				</li>
-				<li>
-					<b>Drag and drop improvements:</b> Don't forget to hold shift while dragging files!
-				</li>
-				<li>Added more checkpoints across the task, allowing you to restore from more than just file changes.</li>
-				<li>Added support for rendering LaTeX in message responses. (Try asking Cline to show the quadratic formula)</li>
-			</ul>
-			<Accordion isCompact className="pl-0">
-				<AccordionItem
-					key="1"
-					aria-label="Previous Updates"
-					title="Previous Updates:"
-					classNames={{
-						trigger: "bg-transparent border-0 pl-0 pb-0 w-fit",
-						title: "font-bold text-(--vscode-foreground)",
-						indicator:
-							"text-(--vscode-foreground) mb-0.5 -rotate-180 data-[open=true]:-rotate-90 rtl:rotate-0 rtl:data-[open=true]:-rotate-90",
-					}}>
-					<ul style={ulStyle}>
-						<li>
-							<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between
-							projects.
-						</li>
-						<li>
-							<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files
-							to plug and play specific rules for the task
-						</li>
-						<li>
-							<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a
-							new task (more coming soon!)
-						</li>
-						<li>
-							<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally
-							restore your project when the message was sent!
-						</li>
-					</ul>
-				</AccordionItem>
-			</Accordion>
-
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-- 3.13
-
-<changeset>
-Minor Changes
-2964388: Added copy button to MermaidBlock component
-75143a7: Add the ability to fetch from global cline rules files
-Patch Changes
-a0252e7: convert inline style to tailwind css of file SettingsView.tsx
-ab59bd9: Add stream options back to xai provider
-7276f50: Icons to indicate an action is occuring outside of the users workspace
-0b19ba6: update to NEW model
-</changeset>
-
-<changelog>
-## [3.13.0]
-
--   Add Cline rules popover under the chat field, allowing you to easily add, enable & disable workspace level or global rule files
--   Add new slash command menu letting you type “/“ to do quick actions like creating new tasks
--   Add ability to edit past messages, with options to restore your workspace back to that point
--   Allow sending a message when selecting an option provided by the question or plan tool
--   Add command to jump to Cline's chat input
--   Add support for OpenAI o3 & 4o-mini (Thanks @PeterDaveHello and @arafatkatze!)
--   Add baseURL option for Google Gemini provider (Thanks @owengo and @olivierhub!)
--   Add support for Azure's DeepSeek model. (Thanks @yt3trees!)
--   Add ability for models that support it to receive image responses from MCP servers (Thanks @rikaaa0928!)
--   Improve search and replace diff editing by making it more flexible with models that fail to follow structured output instructions. (Thanks @chi-cat!)
--   Add detection of Ctrl+C termination in terminal, improving output reading issues
--   Fix issue where some commands with large output would cause UI to freeze
--   Fix token usage tracking issues with vertex provider (Thanks @mzsima!)
--   Fix issue with xAI reasoning content not being parsed (Thanks @mrubens!)
-</changelog>
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between projects.
-				</li>
-				<li>
-					<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files to plug
-					and play specific rules for the task
-				</li>
-				<li>
-					<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a new task
-					(more coming soon!)
-				</li>
-				<li>
-					<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally restore
-					your project when the message was sent!
-				</li>
-			</ul>
-			<h4 style={{ margin: "5px 0 5px" }}>Previous Updates:</h4>
-			<ul style={ulStyle}>
-				<li>
-					<b>Model Favorites:</b> You can now mark your favorite models when using Cline & OpenRouter providers for
-					quick access!
-				</li>
-				<li>
-					<b>Faster Diff Editing:</b> Improved animation performance for large files, plus a new indicator in chat
-					showing the number of edits Cline makes.
-				</li>
-				<li>
-					<b>New Auto-Approve Options:</b> Turn off Cline's ability to read and edit files outside your workspace.
-				</li>
-			</ul>
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-
-We have a changeset PR that automatically generated as new unreleased PRs are merged into main, the PR is always called "Changeset version bump" and the author is github-actions. 
-
-The Changeset PR description looks something like this:
-
-<changeset-pr-description>
-This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or [setup this action to publish automatically](https://github.com/changesets/action#with-publishing). If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-
-# Releases
-## claude-dev@3.16.0
-
-### Minor Changes
-
--   c6e8b04: Recent task list is now collapsible, allowing users to hide their recent tasks (e.g. when sharing their screen).
--   aabe4ae: Add detection for new users to display special components
--   6c18d51: adds global endpoint for vertex ai users
--   080ed7c: Add Tailwind CSS IntelliSense to the the recommended extensions list
--   5147e28: new workflow feature
-
-### Patch Changes
-
--   c0b3c69: fix eternal loading states when the last message is a checkpoint
--   570ece3: selectImages protos migration
--   8d8452e: askResponse protobus migration
--   cd1ff2a: Finishing the migration of Vscode Advanced settings to Settings Webview
-</changeset-pr-description>
-
-The changeset pr is ALWAYS on the following branch: `changeset-release/main`.
-
-I have the `gh` command line tool set up and authenticated, so you have everything you need.
-
-The first step is to get the full diff from the changeset PR to look at the changes that were automatically made to the `CHANGELOG.md` file. By default it will automatically add a new section to the changelog.md file with the new version. The problem with the automatically generated section is that it just takes the text that the developers threw into their changeset files for each corresponding PR, and they can be pretty vague and bad. Additionally there's some stuff that is totally irrelevant for the end user, like minor refactoring changes. So I manually typically go in and update this section to be a proper changelog that will show up in our patchnotes. You can look at how the rest of the file is done because those are all good examples of us updating this to use good language for the end user. We usually put new features up top (and the most exciting flagship features at the very top), and then bug fixes/improvements at the bottom. Having some basic organization to the ordering of the bullet points by content is nice. But use common sense. 
-
-To handle this process effectively, do the following:
-
-For each of the automatically generated bullet points in the Changelog.md, you should
-1. Take the commit hash at the start of the bullet point, and use the `gh` command line tool find the PR that it was associated with. 
-2. Use the `gh` command to get the PR title/description/discussion to understand the context surrounding the PR.
-3. Use the `gh` command line tool to get the full PR diff to fully understand the changes made in the code.
-4. Synthesize that knowledge to determine (a) whether or not this change is relevant to end users and (b) what the text & ordering of the line should be.  
-5. Update the `CHANGELOG.md` accordingly 
-
-Do this for every single item in the list from the autogenerated bullet points. We want to be diligent and have a full understanding of every feature so we can make the best changelog ever!
-
-Here are some principles for good changelogs from keepchangelog.com, a handy guide:
-
-<keepachangelog-pinciples-for-good-changelogs>
-### Guiding Principles
-- Changelogs are for humans, not machines.
-- There should be an entry for every single version.
-- The same types of changes should be grouped.
-- The latest version comes first.
-
-### Bullet points in the changelog should follow these principles:
-- Types of changes
-- Added for new features.
-- Changed for changes in existing functionality.
-- Deprecated for soon-to-be removed features.
-- Removed for now removed features.
-- Fixed for any bug fixes.
-- Security in case of vulnerabilities.
-</keepachangelog-pinciples-for-good-changelogs>
-
-Lastly, when developers make a PR, they typically make a changeset. And they have 3 options when making the changeset:
-
-1. Patch
-2. Minor
-3. Major
-
-Sometimes they label something as minor when really it should just be a patch. Or vice versa. Because of this, the automatic version bump may be incorrect. So when starting out this workflow, you should use the <ask_followup_question> tool to confirm with me whether or not this should be a patch bump (show the old version number and what the proposed new version number would be) or a minor bump. Part of the release process is making sure the version in package.json that is automatically changed actually corresponds with what we decided the bump should actually be based on the features. ALL these modifications happen in the `changeset-release/main` branch btw. 
-
-<important_note>
-Before doing any of this, make sure you check out the `changeset-release/main` and pull the most recent up to date changes. Then perform all this work in that branch. 
-
-New announcement banners should ONLY be made for minor version bumps or higher. That's another reason why double checking if the changelog warrants the bump is important.
-
-Also, SUPER important: For any external contributors that aren't part of the cline github organization, we always want to add a (Thanks @username!) at the end of the changelog to attribute them properly. We're an open source project and it's ethical to do this.
-</important_note>
-
-Once the changelog looks good, and the version number looks good, we gotta double check that the version number in the changelog has the brackets around it. And as a final step, double check the package.json version number matches the latest number in the changelog. And as the ultimate final step we run `npm run install:all` to make sure the package version number permiates through the lock file. 
-
-
-<detailed_sequence_of_steps>
-# Cline Release Process - Detailed Sequence of Steps
-
-## Before Starting
-1. First, examine the changeset PR without checking it out:
-   ```bash
-   gh pr view changeset-release/main
-   ```
-
-2. View the PR diff to see the auto-generated CHANGELOG.md changes:
-   ```bash
-   gh pr diff changeset-release/main > changeset-diff.txt
-   cat changeset-diff.txt | grep -A 50 "CHANGELOG.md"
-   ```
-
-## Initial Setup
-3. Once you're ready to start, checkout and update the changeset release branch:
-   ```bash
-   git checkout changeset-release/main
-   git pull origin changeset-release/main
-   ```
-
-## Analyzing Each Change
-4. For each commit hash in the auto-generated changelog entries:
-
-   a. Find the PR number associated with a commit hash:
-      ```bash
-      gh pr list --search "<commit-hash>" --state merged
-      ```
-   
-   b. Get PR details for better context:
-      ```bash
-      gh pr view <PR-number>
-      ```
-   
-   c. Check if the contributor is external to determine if attribution is needed:
-      ```bash
-      # Extract username from PR
-      USERNAME=$(gh pr view <PR-number> --json author --jq .author.login)
-      
-      # Check if user is a member of the Cline organization
-	  # this command is a bit finnicky, but it 100% works. 
-	  # if you see a `Error executing command: The command ran successfully, but we couldn't capture its output. Please proceed accordingly.` error, just retry it until you actually get the output
-	  # don't make any assumptions, just retry the command to actually get the output and determine if they're external or not.
-	  # no output means they are an external contributor, otherwise if there is output they are an internal contributor (part of our github org)
-      gh api "orgs/cline/members" --jq "map(.login)" | grep -i "pashpashpash"
-      ```
-   
-   d. View the full PR diff to understand code changes:
-      ```bash
-      gh pr diff <PR-number> > pr-diff-<PR-number>.txt
-      cat pr-diff-<PR-number>.txt
-      ```
-
-## Updating the Changelog
-5. Based on PR analysis, update the CHANGELOG.md with user-friendly descriptions:
-   - Use the `<replace_in_file>` tool to edit the CHANGELOG.md file
-   - Group by feature type (Added, Changed, Fixed)
-   - Put most exciting features at the top
-   - Move bug fixes and small improvements to the bottom
-   - Use clear, end-user focused language
-   - For external contributors, add attribution at the end of the relevant entry: `(Thanks @username!)`
-
-## Version Number Verification
-6. Confirm the version bump is appropriate:
-   - Check package.json to verify the auto-generated version number:
-     ```bash
-     cat package.json | grep "\"version\""
-     ```
-   - If the feature set doesn't warrant a minor bump, use the `<replace_in_file>` tool to modify package.json
-
-7. Ensure the version in CHANGELOG.md has brackets around it:
-   ```
-   ## [3.16.0]
-   ```
-
-## Creating the Announcement (for minor/major versions only)
-8. If this is a minor version bump, create/update the announcement component:
-   - Use the `<replace_in_file>` tool to edit the src/views/components/announcement.tsx file
-   - Update the highlights based on key features
-   - Move previous version highlights to the "Previous Updates" section
-   - Use the previous announcement components as reference for structure
-
-## Finalizing the Release
-9. Update dependencies with the new version number:
-   ```bash
-   npm run install:all
-   ```
-
-10. Commit your changes:
-    ```bash
-    git add CHANGELOG.md package.json package-lock.json src/views/components/announcement.tsx
-    git commit -m "Update CHANGELOG.md and announcement for version 3.16.0"
-    ```
-
-11. Push your changes to the changeset branch:
-    ```bash
-    git push origin changeset-release/main
-    ```
-
-12. Check that your changes pushed successfully:
-    ```bash
-    git status
-    ```
-</detailed_sequence_of_steps>

.clinerules/workflows/hotfix-release.md

@@ -89,16 +89,9 @@ On the main branch, create a commit that updates:
 
 2. **package.json** - Update the version field to the new version
 
-3. **Delete changesets** for the commits being included in the hotfix. This prevents the changeset bot from including duplicate entries in the next regular release.
+3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
 
-   Find and delete the changeset files associated with the selected commits:
-   ```bash
-   ls .changeset/
-   ```
-
-   Each changeset file in `.changeset/` corresponds to a PR. Read them to identify which ones belong to the commits you're hotfixing, then delete those files.
-
-**Skip running `npm run install:all`** - the automation handles outdated lockfiles.
+**Skip running `npm run install:all`** - release automation handles lockfile consistency as needed.
 
 Commit with message format: `v{VERSION} Release Notes (hotfix)`
 
@@ -107,7 +100,7 @@ In the commit body, mention:
 - List the cherry-picked commits that will be included
 
 ```bash
-git add CHANGELOG.md package.json .changeset/
+git add CHANGELOG.md package.json
 git commit -m "v3.40.1 Release Notes (hotfix)
 
 Hotfix release including:

.clinerules/workflows/pr-review.md

@@ -347,8 +347,6 @@ A few notes:
 So until the settings page is update, and this is added to settings in a way that's clean and doesn't confuse new users, I don't think we can merge this. Please bear with us.
 </request_changes_comment>
 <request_changes_comment>
-Also, don't forget to add a changeset since this fixes a user-facing bug.
-
 The architectural change is solid - moving the focus logic to the command handlers makes sense. Just don't want to introduce subtle timing issues by removing those timeouts.
 </request_changes_comment>
 </example_comments_that_i_have_written_before>

.clinerules/workflows/release.md

@@ -1,232 +1,64 @@
 # Release
 
-Prepare and publish a release from the open changeset PR.
+Prepare and publish a release directly from `main`.
 
 ## Overview
 
 This workflow helps you:
-1. Find and checkout the open changeset PR
-2. Clean up the changelog (fix version format, wordsmith entries)
-3. Push changes back to the PR branch
-4. Merge with proper commit message format
-5. Tag and push the release (after verifying the commit)
-6. Trigger the publish workflow
-7. Update GitHub release notes
-8. Provide final summary with Slack announcement
+1. Select/confirm the target version
+2. Curate `CHANGELOG.md` entries manually for end users
+3. Ensure `package.json` version matches the changelog
+4. Create and push a release commit + tag
+5. Trigger publish workflow
+6. Update GitHub release notes and share a summary
 
-## Step 1: Find the Changeset PR
+## Process
 
-Look for the open changeset PR:
-
-```bash
-gh pr list --search "Changeset version bump" --state open --json number,title,headRefName,url
-```
-
-If no PR is found, inform the user there's no changeset PR ready. They may need to:
-- Merge PRs with changesets to main first
-- Manually trigger the Changeset Converter workflow at: https://github.com/cline/cline/actions/workflows/changeset-converter.yml
-
-## Step 2: Gather PR Information
-
-Get the PR details:
-
-```bash
-PR_NUMBER=<number from step 1>
-gh pr view $PR_NUMBER --json body,files,headRefName
-```
-
-Checkout the PR branch:
-
-```bash
-git fetch origin changeset-release/main
-git checkout changeset-release/main
-```
-
-If the branch has diverged from remote, reset to the remote version:
-
-```bash
-git reset --hard origin/changeset-release/main
-```
-
-## Step 3: Analyze the Changes
-
-Read the current CHANGELOG.md to see what the automation generated:
-
-```bash
-head -50 CHANGELOG.md
-```
-
-Get the version from package.json:
-
-```bash
-cat package.json | grep '"version"'
-```
-
-**Present to the user:**
-- The version number that will be released
-- The raw changelog entries from the changeset PR
-- Whether this is a patch, minor, or major release
-
-## Step 4: Clean Up the Changelog
-
-The changelog needs these fixes:
-
-1. **Add brackets to version number**: Change `## 3.44.1` to `## [3.44.1]`
-
-2. **No category headers**: Don't use `### Added`, `### Fixed`, etc. Just a flat list of bullet points.
-
-3. **Order entries from most important to least important**:
-   - Lead with major new features or significant fixes users care about
-   - End with minor fixes or internal changes
-
-4. **Write user-friendly descriptions**:
-   - This is for end users, not developers—explain what changed in plain language
-   - Remove commit hashes from the beginning of lines (the automation adds these)
-   - Look at the actual commit diffs (`git show <hash>`) and PRs to understand what changed
-   - Write colorful descriptions that explain the value and impact, not just technical details
-   - Consolidate related changes into single entries when appropriate
-
-**Ask the user** to review the proposed changelog changes before applying them. Show them:
-- Current (raw) changelog section
-- Proposed (cleaned) changelog section
-
-Once approved, apply the changes to CHANGELOG.md.
-
-## Step 5: Commit and Push Changes
-
-After making changelog edits:
-
-```bash
-git add CHANGELOG.md
-git commit -m "Clean up changelog formatting"
-git push origin changeset-release/main
-```
-
-## Step 6: Merge the PR
-
-**Ask the user to confirm** they're ready to merge.
-
-Merge the PR with the proper commit message format:
-
-```bash
-VERSION=<version from package.json>
-gh pr merge $PR_NUMBER --squash --subject "v${VERSION} Release Notes" --body ""
-```
-
-**If merge is blocked by branch protection:**
-- Users with admin privileges can add the `--admin` flag to bypass
-- Users without admin privileges need to get the PR approved through normal review first before merging
-
-## Step 7: Tag the Release
-
-After the merge completes, checkout main and pull:
+### 1) Sync and determine version
 
 ```bash
 git checkout main
 git pull origin main
+cat package.json | grep '"version"'
 ```
 
-**IMPORTANT: Verify the latest commit is the release commit before tagging:**
+Confirm the release version with the maintainer (patch/minor/major).
+
+### 2) Curate changelog and version
+
+- Edit `CHANGELOG.md` for the target version using human-friendly release notes.
+- Ensure version headers use bracket format, e.g. `## [3.66.1]`.
+- Update `package.json` version to the same value.
+
+### 3) Commit and tag
 
 ```bash
-git log -1 --oneline
+git add CHANGELOG.md package.json package-lock.json
+git commit -m "v<version> Release Notes"
+git push origin main
+git tag v<version>
+git push origin v<version>
 ```
 
-Confirm the commit message matches `v{VERSION} Release Notes` (e.g., `v3.44.1 Release Notes`). Do NOT blindly tag HEAD without verification.
+### 4) Trigger publish workflow
 
-Once verified, tag and push:
+Tell the maintainer to run:
+https://github.com/cline/cline/actions/workflows/publish.yml
+
+Use `v<version>` as the release tag.
+
+### 5) Update GitHub release notes
+
+After publish completes:
 
 ```bash
-VERSION=<version>
-git tag v${VERSION}
-git push origin v${VERSION}
+gh release view v<version> --json body --jq '.body'
+gh release edit v<version> --notes "<final curated release notes>"
 ```
 
-## Step 8: Trigger Publish Workflow
+### 6) Final summary
 
-**Copy the tag to clipboard** so the user can easily paste it into the GitHub Actions workflow:
-
-```bash
-echo -n "v{VERSION}" | pbcopy
-```
-
-**Tell the user to trigger the publish workflow:**
-1. Go to: https://github.com/cline/cline/actions/workflows/publish.yml
-2. Select **"release"** for release-type
-3. Paste **`v{VERSION}`** as the tag (already in clipboard)
-
-**Wait for the user** to confirm the publish workflow has completed before proceeding.
-
-## Step 9: Update GitHub Release Notes
-
-Once the user confirms the publish workflow is done, fetch the auto-generated release content:
-
-```bash
-VERSION=<version>
-gh release view v${VERSION} --json body --jq '.body'
-```
-
-The auto-generated release has:
-- `## What's Changed` - PR list (we'll replace this with our changelog)
-- `## New Contributors` - First-time contributors (keep this if present)
-- `**Full Changelog**` - Comparison link (keep this)
-
-Build the new release body:
-1. Start with `## What's Changed` header
-2. Add our changelog content (from CHANGELOG.md for this version)
-3. Keep the `## New Contributors` section if it exists
-4. Keep the `**Full Changelog**` link
-
-Update the release:
-
-```bash
-gh release edit v${VERSION} --notes "<new body content>"
-```
-
-Verify the release was updated:
-
-```bash
-gh release view v${VERSION}
-```
-
-## Step 10: Final Summary
-
-**Copy a Slack announcement message to clipboard** (include the full changelog, not just highlights):
-
-```bash
-echo "VS Code v{VERSION} Released
-
-- Changelog entry 1
-- Changelog entry 2
-- Changelog entry 3" | pbcopy
-```
-
-**Present a final summary:**
-- Version released: v{VERSION}
-- PR merged: #{PR_NUMBER}
-- Tag pushed: v{VERSION}
-- Release: https://github.com/cline/cline/releases/tag/v{VERSION}
-- Slack message copied to clipboard
-
-**Final reminder:**
-Post the Slack message to announce the release
-
-## Handling Edge Cases
-
-### No changesets found
-If the changeset PR body shows no changes, inform the user they need to merge PRs with changesets first.
-
-### Merge conflicts
-If there are conflicts on the changeset branch, help the user resolve them:
-```bash
-git fetch origin main
-git rebase origin/main
-# resolve conflicts
-git push origin changeset-release/main --force-with-lease
-```
-
-### User wants to add more changes
-If the user wants to include additional PRs before releasing:
-1. Ask them to merge those PRs to main first
-2. The changeset automation will update the PR automatically
-3. Re-run this workflow after the PR is updated
+Provide:
+- Released version/tag
+- Link to release page
+- Summary of top end-user changes

.github/pull_request_template.md

@@ -60,7 +60,6 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
 -   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
--   [ ] I have created a changeset using `npm run changeset` (required for user-facing changes)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/scripts/overwrite_changeset_changelog.py

@@ -1,79 +0,0 @@
-"""
-This script updates a specific version's release notes section in CHANGELOG.md with new content
-or reformats existing content.
-
-The script:
-1. Takes a version number, changelog path, and optionally new content as input from environment variables
-2. Finds the section in the changelog for the specified version
-3. Either:
-   a) Replaces the content with new content if provided, or
-   b) Reformats existing content by:
-      - Removing the first two lines of the changeset format
-      - Ensuring version numbers are wrapped in square brackets
-4. Writes the updated changelog back to the file
-
-Environment Variables:
-    CHANGELOG_PATH: Path to the changelog file (defaults to 'CHANGELOG.md')
-    VERSION: The version number to update/format
-    PREV_VERSION: The previous version number (used to locate section boundaries)
-    NEW_CONTENT: Optional new content to insert for this version
-"""
-
-#!/usr/bin/env python3
-
-import os
-
-CHANGELOG_PATH = os.environ.get("CHANGELOG_PATH", "CHANGELOG.md")
-VERSION = os.environ['VERSION']
-PREV_VERSION = os.environ.get("PREV_VERSION", "")
-NEW_CONTENT = os.environ.get("NEW_CONTENT", "")
-
-def overwrite_changelog_section(changelog_text: str, new_content: str):
-    # Find the section for the specified version
-    version_pattern = f"## {VERSION}\n"
-    unformmatted_prev_version_pattern = f"## {PREV_VERSION}\n"
-    prev_version_pattern = f"## [{PREV_VERSION}]\n"
-    print(f"latest version: {VERSION}")
-    print(f"prev_version: {PREV_VERSION}")
-
-    notes_start_index = changelog_text.find(version_pattern) + len(version_pattern)
-    notes_end_index = changelog_text.find(prev_version_pattern, notes_start_index) if PREV_VERSION and (prev_version_pattern in changelog_text or unformmatted_prev_version_pattern in changelog_text) else len(changelog_text)
-
-    if new_content:
-        return changelog_text[:notes_start_index] + f"{new_content}\n" + changelog_text[notes_end_index:]
-    else:
-        changeset_lines = changelog_text[notes_start_index:notes_end_index].split("\n")
-        filtered_lines = []
-        for line in changeset_lines:
-            # If the previous line is a changeset format
-            if len(filtered_lines) > 1 and filtered_lines[-1].startswith("### "):
-                # Remove the last two lines from the filted_lines
-                filtered_lines.pop()
-                filtered_lines.pop()
-            else:
-                filtered_lines.append(line.strip())
-
-        # Prepend a new line to the first line of filtered_lines
-        if filtered_lines:
-            filtered_lines[0] = "\n" + filtered_lines[0]
-
-        # Print filted_lines wiht a "\n" at the end of each line
-        for line in filtered_lines:
-            print(line.strip())
-
-        parsed_lines = "\n".join(line for line in filtered_lines)
-        updated_changelog = changelog_text[:notes_start_index] + parsed_lines + changelog_text[notes_end_index:]
-        return updated_changelog
-
-with open(CHANGELOG_PATH, 'r') as f:
-    changelog_content = f.read()
-
-new_changelog = overwrite_changelog_section(changelog_content, NEW_CONTENT)
-# print("----------------------------------------------------------------------------------")
-# print(new_changelog)
-# print("----------------------------------------------------------------------------------")
-# Write back to CHANGELOG.md
-with open(CHANGELOG_PATH, 'w') as f:
-    f.write(new_changelog)
-
-print(f"{CHANGELOG_PATH} updated successfully!")

.github/workflows/changeset-converter.yml

@@ -1,113 +0,0 @@
-name: Changeset Converter
-run-name: Changeset Conversion
-
-on:
-    workflow_dispatch:
-    pull_request:
-        types: [closed]
-
-env:
-    REPO_PATH: ${{ github.repository }}
-    GIT_REF: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || 'main' }}
-    NODE_VERSION: 20.18.1
-
-jobs:
-    # Job 1: Create version bump PR when changesets are merged to main
-    changeset-pr-version-bump:
-        if: |
-            github.event_name == 'workflow_dispatch' ||
-            (
-                github.event_name == 'pull_request' &&
-                github.event.pull_request.merged == true &&
-                github.event.pull_request.base.ref == 'main' &&
-                github.actor != 'github-actions'
-            )
-        runs-on: ubuntu-latest
-        permissions:
-            contents: write
-            pull-requests: write
-        steps:
-            - name: Check user for team affiliation
-              id: team_check
-              if: github.event_name == 'workflow_dispatch'
-              uses: morfien101/actions-authorized-user@4a3cfbf0bcb3cafe4a71710a278920c5d94bb38b
-              with:
-                  username: ${{ github.actor }}
-                  org: ${{ github.repository_owner }}
-                  team: "deployer"
-                  github_token: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: Check if user is authorized
-              if: github.event_name == 'workflow_dispatch'
-              run: |
-                  if [ "${{ steps.team_check.outputs.authorized }}" != "true" ]; then
-                      echo "User is not authorized to run this workflow."
-                      exit 1
-                  fi
-
-            - name: Git Checkout
-              uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0
-                  ref: ${{ env.GIT_REF }}
-
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: ${{ env.NODE_VERSION }}
-                  cache: "npm"
-
-            - name: Install Dependencies
-              run: npm ci
-
-            # Check if there are any new changesets to process
-            - name: Check for changesets
-              id: check-changesets
-              run: |
-                  NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ')
-                  echo "Changesets diff with previous version: $NEW_CHANGESETS"
-                  echo "new_changesets=$NEW_CHANGESETS" >> $GITHUB_OUTPUT
-
-            # Create version bump PR using changesets/action if there are new changesets
-            - name: Create Changeset Pull Request
-              if: steps.check-changesets.outputs.new_changesets != '0'
-              uses: changesets/action@v1
-              with:
-                  commit: "changeset version bump"
-                  title: "Changeset version bump"
-                  version: npm run version-packages # This performs the changeset version bump
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-            # Get current and previous versions to edit changelog entry
-            - name: Get version
-              id: get_version
-              run: |
-                  VERSION=$(git show HEAD:package.json | jq -r '.version')
-                  echo "version=$VERSION" >> $GITHUB_OUTPUT
-                  PREV_VERSION=$(git show origin/main:package.json | jq -r '.version')
-                  echo "prev_version=$PREV_VERSION" >> $GITHUB_OUTPUT
-                  echo "version=$VERSION"
-                  echo "prev_version=$PREV_VERSION"
-
-            # Update CHANGELOG.md with proper format
-            - name: Update Changelog Format
-              env:
-                  VERSION: ${{ steps.get_version.outputs.version }}
-                  PREV_VERSION: ${{ steps.get_version.outputs.prev_version }}
-              run: python .github/scripts/overwrite_changeset_changelog.py
-
-            # Commit and push changelog updates
-            - name: Push Changelog updates to Pull Request
-              run: |
-                  git config user.name "github-actions"
-                  git config user.email github-actions@github.com
-                  echo "Running git add and commit..."
-                  git add CHANGELOG.md
-                  git commit -m "Updating CHANGELOG.md format"
-                  git status
-                  echo "--------------------------------------------------------------------------------"
-                  echo "Pushing to remote..."
-                  echo "--------------------------------------------------------------------------------"
-                  CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-                  git push origin $CURRENT_BRANCH

.github/workflows/cline-evals-regression.yml

@@ -55,7 +55,22 @@ jobs:
           CLINE_API_KEY: ${{ secrets.CLINE_API_KEY }}
         run: |
           cline auth -p cline -k "$CLINE_API_KEY" -m "anthropic/claude-sonnet-4.5"
-          npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1 --parallel
+          max_attempts=3
+          for attempt in $(seq 1 $max_attempts); do
+            echo "::group::Attempt $attempt of $max_attempts"
+            if npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1 --parallel; then
+              echo "::endgroup::"
+              echo "Smoke tests passed on attempt $attempt"
+              exit 0
+            fi
+            echo "::endgroup::"
+            if [ $attempt -lt $max_attempts ]; then
+              echo "::warning::Smoke tests failed on attempt $attempt, retrying..."
+              sleep 10
+            fi
+          done
+          echo "::error::Smoke tests failed after $max_attempts attempts"
+          exit 1
 
       - name: Generate summary
         if: always()

.vscode/launch.json

@@ -16,7 +16,8 @@
 				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
 				"--disable-extension",
 				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
-				"${workspaceFolder}"
+				"${workspaceFolder}",
+				"--disable-extensions"
 			],
 			"outFiles": [
 				"${workspaceFolder}/dist/**/*.js"

.vscodeignore

@@ -35,11 +35,9 @@ cli/**
 eslint-rules/
 old_docs/
 evals/
-.changie.yaml
 .codespellrc
 .mocharc.json
 buf.yaml
-.changeset/
 .clinerules/
 
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)

CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [3.67.1]
+
+### Added
+
+- Added Cline SDK API interface for programmatic access to Cline features and tools, enabling integration into custom applications.
+- Added Codex 5.3 model support
+
+### Fixed
+
+- Fix OpenAI Codex by setting `store` to `false`
+- Use `isLocatedInPath()` instead of string matching for path containment checks
+
+## [3.67.0]
+
+### Added
+
+- Add support for skills and optional modelId in subagent configuration
+- Add AgentConfigLoader for file-based agent configs
+- Add Responses API support for OpenAI native provider
+- Preconnect websocket to reduce response latency
+- Fetch featured models from backend with local fallback
+- Add /q command to quit CLI
+- Add MCP enterprise configuration details
+- Pull Cline's recommended models from internal endpoint
+- Add dynamic flag to adjust banner cache duration
+
+### Fixed
+
+- Fix reasoning delta crash on usage-only stream chunks
+- Fix OpenAI tool ID transformation restricted to native provider only
+- Fix auth check for ACP mode
+- Fix CLI yolo mode to not persist yolo setting to disk
+- Fix inline focus-chain slider within its feature row
+- Fix Gemini 3.1 Pro compatibility
+- Fix Cline auth with ACP flag
+
+### Changed
+
+- Move PR skill to .agents/skills
+- SambaNova provider: update models list
+- Remove changeset-converter GitHub Action and npm run changeset
+
 ## [3.66.0]
 
 ### Added

CONTRIBUTING.md

@@ -57,25 +57,11 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 ### Creating a Pull Request
 
-1. Before creating a PR, generate a changeset entry:
-    ```bash
-    npm run changeset
-    ```
-   This will prompt you for:
-   - Type of change (major, minor, patch)
-     - `major` → breaking changes (1.0.0 → 2.0.0)
-     - `minor` → new features (1.0.0 → 1.1.0)
-     - `patch` → bug fixes (1.0.0 → 1.0.1)
-   - Description of your changes
+1. Commit your changes.
 
-2. Commit your changes and the generated `.changeset` file
-
-3. Push your branch and create a PR on GitHub. Our CI will:
+2. Push your branch and create a PR on GitHub. Our CI will:
    - Run tests and checks
-   - Changesetbot will create a comment showing the version impact
-   - When merged to main, changesetbot will create a Version Packages PR
-   - When the Version Packages PR is merged, a new release will be published
-4. Testing
+3. Testing
     - Run `npm run test` to run tests locally. 
     - Before submitting PR, run `npm run format:fix` to format your code
 
@@ -192,15 +178,10 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
       - Temporary workspaces with test fixtures
       - Video recording for failed tests
 
-4. **Version Management with Changesets**
+4. **Versioning & Changelog Notes**
 
-    - Create a changeset for any user-facing changes using `npm run changeset`
-    - Choose the appropriate version bump:
-        - `major` for breaking changes (1.0.0 → 2.0.0)
-        - `minor` for new features (1.0.0 → 1.1.0)
-        - `patch` for bug fixes (1.0.0 → 1.0.1)
-    - Write clear, descriptive changeset messages that explain the impact
-    - Documentation-only changes don't require changesets
+    - Contributors do not need to create changelog-entry files as part of PRs.
+    - Maintainers handle release versioning and changelog curation during the release process.
 
 5. **Commit Guidelines**
 

cli/CHANGELOG.md

@@ -1,6 +1,31 @@
 # cline
 
-## 2.4.2
+## [2.5.0]
+
+### Added
+
+- Added Cline SDK API interface for programmatic access to Cline features and tools, enabling integration into custom applications.
+- Added Codex 5.3 model support
+
+### Fixed
+
+- Fix OpenAI Codex by setting `store` to `false`
+- Use `isLocatedInPath()` instead of string matching for path containment checks
+
+## [2.4.3]
+
+### Added
+
+- Add /q command to quit CLI
+- Fetch featured models from backend with local fallback
+
+### Fixed
+
+- Fix auth check for ACP mode
+- Fix Cline auth with ACP flag
+- Fix yolo mode to not persist yolo setting to disk
+
+## [2.4.2]
 
 ### Added
 

cli/esbuild.mts

@@ -208,8 +208,8 @@ if (production) {
 	buildEnvVars["process.env.IS_DEV"] = "false"
 }
 
-const config: esbuild.BuildOptions = {
-	entryPoints: [path.join(__dirname, "src", "index.ts")],
+// Shared build options
+const sharedOptions: Partial<esbuild.BuildOptions> = {
 	bundle: true,
 	minify: production,
 	sourcemap: !production,
@@ -221,7 +221,6 @@ const config: esbuild.BuildOptions = {
 	sourcesContent: false,
 	platform: "node",
 	target: "node20",
-	outfile: path.join(__dirname, "dist", "cli.mjs"),
 	// These modules need to load files from the module directory at runtime
 	external: [
 		"@grpc/reflection",
@@ -237,6 +236,13 @@ const config: esbuild.BuildOptions = {
 		"@vscode/ripgrep", // Uses __dirname to locate the binary
 	],
 	supported: { "top-level-await": true },
+}
+
+// CLI executable configuration
+const cliConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "index.ts")],
+	outfile: path.join(__dirname, "dist", "cli.mjs"),
 	banner: {
 		js: `#!/usr/bin/env node
 // Suppress all Node.js warnings (deprecation, experimental, etc.)
@@ -250,19 +256,44 @@ const __dirname = _dirname(__filename);`,
 	},
 }
 
+// Library configuration for programmatic use
+const libConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "exports.ts")],
+	outfile: path.join(__dirname, "dist", "lib.mjs"),
+	banner: {
+		js: `// Cline Library - Programmatic API
+import { createRequire as _createRequire } from 'module';
+import { fileURLToPath as _fileURLToPath } from 'url';
+import { dirname as _dirname } from 'path';
+const require = _createRequire(import.meta.url);
+const __filename = _fileURLToPath(import.meta.url);
+const __dirname = _dirname(__filename);`,
+	},
+}
+
 async function main() {
-	const ctx = await esbuild.context(config)
 	if (watch) {
+		// In watch mode, only watch the CLI (primary use case for development)
+		const ctx = await esbuild.context(cliConfig)
 		await ctx.watch()
 		console.log("[cli] Watching for changes...")
 	} else {
-		await ctx.rebuild()
-		await ctx.dispose()
+		// Build both CLI and library
+		console.log("[cli esbuild] Building CLI executable...")
+		const cliCtx = await esbuild.context(cliConfig)
+		await cliCtx.rebuild()
+		await cliCtx.dispose()
 
-		// Make the output executable
-		const outfile = path.join(__dirname, "dist", "cli.mjs")
-		if (fs.existsSync(outfile)) {
-			fs.chmodSync(outfile, "755")
+		console.log("[cli esbuild] Building library bundle...")
+		const libCtx = await esbuild.context(libConfig)
+		await libCtx.rebuild()
+		await libCtx.dispose()
+
+		// Make the CLI output executable
+		const cliOutfile = path.join(__dirname, "dist", "cli.mjs")
+		if (fs.existsSync(cliOutfile)) {
+			fs.chmodSync(cliOutfile, "755")
 		}
 	}
 }

cli/package.json

@@ -1,11 +1,18 @@
 {
 	"name": "cline",
-	"version": "2.4.2",
+	"version": "2.5.0",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
-	"main": "dist/cli.mjs",
+	"main": "dist/lib.mjs",
+	"types": "dist/lib.d.ts",
 	"bin": {
 		"cline": "./dist/cli.mjs"
 	},
+	"exports": {
+		".": {
+			"import": "./dist/lib.mjs",
+			"types": "./dist/lib.d.ts"
+		}
+	},
 	"os": [
 		"darwin",
 		"linux",
@@ -23,8 +30,9 @@
 	"scripts": {
 		"package:brew": "npx tsx ./scripts/update-brew-formula.mts",
 		"package": "npm pack --pack-destination ./dist",
-		"build": "npm run typecheck && npx tsx esbuild.mts",
-		"build:production": "npm run typecheck && npx tsx esbuild.mts --production",
+		"build": "npm run typecheck && npx tsx esbuild.mts && npm run build:types",
+		"build:production": "npm run typecheck && npx tsx esbuild.mts --production && npm run build:types",
+		"build:types": "(npx tsc -p tsconfig.lib.json || true) && cp dist/types/cli/src/exports.d.ts dist/lib.d.ts && mkdir -p dist/agent && cp dist/types/cli/src/agent/ClineAgent.d.ts dist/types/cli/src/agent/ClineSessionEmitter.d.ts dist/types/cli/src/agent/public-types.d.ts dist/agent/ && rm -rf dist/types",
 		"watch": "npx tsx esbuild.mts --watch",
 		"dev": "IS_DEV=true && npm run link && npm run watch ; npm run unlink",
 		"clean": "rimraf dist",
@@ -62,6 +70,7 @@
 		"url": "https://github.com/cline/cline/issues"
 	},
 	"devDependencies": {
+		"@types/marked": "^5.0.2",
 		"@types/node": "20.x",
 		"@types/prompts": "^2.4.9",
 		"@types/react": "^19.2.9",
@@ -81,8 +90,9 @@
 		"ink": "npm:@jrichman/ink@6.4.7",
 		"ink-picture": "^1.3.3",
 		"ink-spinner": "^5.0.0",
-		"ora": "^8.0.1",
+		"marked": "^17.0.3",
 		"nanoid": "^5.1.6",
+		"ora": "^8.0.1",
 		"pino": "^10.0.0",
 		"pino-roll": "^4.0.0",
 		"prompts": "^2.4.2",

cli/src/acp/ACPHostBridgeClientProvider.ts

@@ -108,11 +108,7 @@ class ACPDiffServiceClient implements DiffServiceClientInterface {
 class ACPEnvServiceClient implements EnvServiceClientInterface {
 	private readonly version: string
 
-	constructor(
-		_clientCapabilities: acp.ClientCapabilities | undefined,
-		_sessionIdResolver: SessionIdResolver,
-		version: string = "1.0.0",
-	) {
+	constructor(_clientCapabilities: acp.ClientCapabilities | undefined, _sessionIdResolver: SessionIdResolver, version: string) {
 		this.version = version
 	}
 
@@ -402,7 +398,7 @@ export class ACPHostBridgeClientProvider implements HostBridgeClientProvider {
 		clientCapabilities: acp.ClientCapabilities | undefined,
 		sessionIdResolver: SessionIdResolver,
 		cwdResolver: CwdResolver,
-		version: string = "1.0.0",
+		version: string,
 	) {
 		this.workspaceClient = new ACPWorkspaceServiceClient(clientCapabilities, sessionIdResolver, cwdResolver)
 		this.envClient = new ACPEnvServiceClient(clientCapabilities, sessionIdResolver, version)

cli/src/acp/AcpAgent.ts

@@ -15,7 +15,7 @@
 import type * as acp from "@agentclientprotocol/sdk"
 import { Logger } from "@/shared/services/Logger.js"
 import { ClineAgent } from "../agent/ClineAgent.js"
-import type { AcpAgentOptions, SessionUpdateType } from "../agent/types.js"
+import { type AcpAgentOptions, type SessionUpdateType } from "../agent/types.js"
 
 /**
  * ACP Agent wrapper that bridges stdio connection to ClineAgent.
@@ -39,37 +39,21 @@ export class AcpAgent implements acp.Agent {
 		this.clineAgent = new ClineAgent(options)
 
 		// Wire up the permission handler to use the connection
-		this.clineAgent.setPermissionHandler(async (request, resolve) => {
+		this.clineAgent.setPermissionHandler(async (request) => {
 			try {
 				Logger.debug("[AcpAgent] Forwarding permission request to connection")
-				const response = await this.connection.requestPermission({
-					sessionId: this.getCurrentSessionId() ?? "",
+				return await this.connection.requestPermission({
+					sessionId: request.sessionId,
 					toolCall: request.toolCall,
 					options: request.options,
 				})
-				resolve(response)
 			} catch (error) {
 				Logger.debug("[AcpAgent] Error requesting permission:", error)
-				resolve({ outcome: "rejected" as unknown as acp.RequestPermissionOutcome })
+				return { outcome: { outcome: "cancelled" } }
 			}
 		})
 	}
 
-	/**
-	 * Get the current active session ID from the ClineAgent.
-	 */
-	private getCurrentSessionId(): string | undefined {
-		// Find the session that's currently processing
-		for (const [sessionId, session] of this.clineAgent.sessions) {
-			if (session.controller?.task) {
-				return sessionId
-			}
-		}
-		// Fall back to the first session if none is actively processing
-		const firstSession = this.clineAgent.sessions.keys().next()
-		return firstSession.done ? undefined : firstSession.value
-	}
-
 	/**
 	 * Subscribe to session events and forward them to the connection.
 	 */

cli/src/acp/index.ts

@@ -15,22 +15,18 @@
 
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
 import { Logger } from "@/shared/services/Logger"
-import { version as CLI_VERSION } from "../../../package.json"
 import { AcpAgent } from "./AcpAgent.js"
 import { nodeToWebReadable, nodeToWebWritable } from "./streamUtils.js"
 
 // Re-export classes for programmatic use
 export { ClineAgent } from "../agent/ClineAgent.js"
 export { ClineSessionEmitter } from "../agent/ClineSessionEmitter.js"
-// Re-export types
 export type {
 	AcpAgentOptions,
 	AcpSessionState,
-	ClineAcpSession,
 	ClineAgentOptions,
 	ClineSessionEvents,
 	PermissionHandler,
-	PermissionResolver,
 } from "../agent/types.js"
 export { AcpAgent } from "./AcpAgent.js"
 
@@ -99,7 +95,6 @@ export async function runAcpMode(options: AcpModeOptions = {}): Promise<void> {
 
 	new AgentSideConnection((conn) => {
 		agent = new AcpAgent(conn, {
-			version: CLI_VERSION,
 			debug: Boolean(options.verbose),
 		})
 		return agent

cli/src/agent/ClineAgent.ts

@@ -38,7 +38,6 @@ import {
 } from "@shared/api"
 import type { ClineAsk, ClineMessage as ClineMessageType } from "@shared/ExtensionMessage"
 import { CLI_ONLY_COMMANDS, VSCODE_ONLY_COMMANDS } from "@shared/slashCommands"
-import { ProviderToApiKeyMap } from "@shared/storage"
 import { getProviderModelIdKey } from "@shared/storage/provider-keys"
 import { ClineEndpoint } from "@/config.js"
 import { Controller } from "@/core/controller"
@@ -55,15 +54,19 @@ import { AuthService } from "@/services/auth/AuthService.js"
 import { Logger } from "@/shared/services/Logger.js"
 import type { Mode } from "@/shared/storage/types"
 import { openExternal } from "@/utils/env"
+import { version as AGENT_VERSION } from "../../package.json"
 import { ACPDiffViewProvider } from "../acp/ACPDiffViewProvider.js"
 import { ACPHostBridgeClientProvider } from "../acp/ACPHostBridgeClientProvider.js"
 import { AcpTerminalManager } from "../acp/AcpTerminalManager.js"
+import { isAuthConfigured } from "../utils/auth"
 import { fetchOpenRouterModels, usesOpenRouterModels } from "../utils/openrouter-models"
 import { CliContextResult, initializeCliContext } from "../vscode-context.js"
 import { ClineSessionEmitter } from "./ClineSessionEmitter.js"
 import { translateMessage } from "./messageTranslator.js"
 import { handlePermissionResponse } from "./permissionHandler.js"
-import type { AcpSessionState, ClineAcpSession, ClineAgentOptions, PermissionHandler } from "./types.js"
+import type { ClineAcpSession, ClineAgentOptions, PermissionHandler } from "./public-types.js"
+import { AcpSessionStatus } from "./public-types.js"
+import { type AcpSessionState } from "./types.js"
 
 // Map providers to their static model lists and defaults (copied from ModelPicker.tsx)
 const providerModels: Record<string, { models: Record<string, unknown>; defaultId: string }> = {
@@ -104,7 +107,12 @@ function getModelList(provider: string): string[] {
 export class ClineAgent implements acp.Agent {
 	private readonly options: ClineAgentOptions
 	private readonly ctx: CliContextResult
-	readonly sessions: Map<string, ClineAcpSession> = new Map()
+
+	/** Map of active sessions by session ID */
+	public readonly sessions: Map<string, ClineAcpSession> = new Map()
+
+	/** WeakMap to associate ClineAcpSession with its Controller without exposing it to consumers */
+	readonly #sessionControllers = new WeakMap<ClineAcpSession, Controller>()
 
 	/** Runtime state for active sessions */
 	private readonly sessionStates: Map<string, AcpSessionState> = new Map()
@@ -132,7 +140,7 @@ export class ClineAgent implements acp.Agent {
 
 	constructor(options: ClineAgentOptions) {
 		this.options = options
-		this.ctx = initializeCliContext()
+		this.ctx = initializeCliContext({ clineDir: options.clineDir })
 	}
 
 	/**
@@ -194,7 +202,7 @@ export class ClineAgent implements acp.Agent {
 			},
 			agentInfo: {
 				name: "cline",
-				version: this.options.version,
+				version: AGENT_VERSION,
 			},
 			authMethods: [
 				{
@@ -226,7 +234,7 @@ export class ClineAgent implements acp.Agent {
 			clientCapabilities,
 			() => this.currentActiveSessionId,
 			() => this.sessions.get(this.currentActiveSessionId ?? "")?.cwd ?? process.cwd(),
-			this.options.version,
+			AGENT_VERSION,
 		)
 
 		HostProvider.initialize(
@@ -265,7 +273,7 @@ export class ClineAgent implements acp.Agent {
 	 */
 	async newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {
 		// Check if authentication is required
-		const isAuthenticated = await this.isAuthConfigured()
+		const isAuthenticated = await isAuthConfigured()
 		if (!isAuthenticated) {
 			throw RequestError.authRequired()
 		}
@@ -289,16 +297,16 @@ export class ClineAgent implements acp.Agent {
 			mcpServers: params.mcpServers ?? [],
 			createdAt: Date.now(),
 			lastActivityAt: Date.now(),
-			controller,
 		}
 
+		this.#sessionControllers.set(session, controller)
+
 		this.sessions.set(sessionId, session)
 
 		// Initialize session state
 		const sessionState: AcpSessionState = {
 			sessionId,
-			isProcessing: false,
-			cancelled: false,
+			status: AcpSessionStatus.Idle,
 			pendingToolCalls: new Map(),
 		}
 
@@ -435,11 +443,11 @@ export class ClineAgent implements acp.Agent {
 	 *
 	 * The prompt flow:
 	 * 1. Extract content from the ACP prompt (text, images, files)
-	 * 2. Set up state broadcasting (subscribe to controller updates)
-	 * 3. Initialize or continue task with Controller
+	 * 2. Set up internal cline state subsription
+	 * 3. Initialize or continue cline task
 	 * 4. Translate ClineMessages to ACP SessionUpdates
 	 * 5. Handle permission requests for tools/commands
-	 * 6. Return when task completes, is cancelled, or needs user input
+	 * 6. Return when cline task completes, is cancelled, or needs user input
 	 */
 	async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
 		const session = this.sessions.get(params.sessionId)
@@ -449,11 +457,11 @@ export class ClineAgent implements acp.Agent {
 			throw new Error(`Session not found: ${params.sessionId}`)
 		}
 
-		if (sessionState.isProcessing) {
+		if (sessionState.status === AcpSessionStatus.Processing) {
 			throw new Error(`Session ${params.sessionId} is already processing a prompt`)
 		}
 
-		const controller = session.controller
+		const controller = this.#sessionControllers.get(session)
 		if (!controller) {
 			throw new Error("Controller not initialized for session. This is a bug in the ACP agent setup.")
 		}
@@ -464,8 +472,7 @@ export class ClineAgent implements acp.Agent {
 		})
 
 		// Mark session as processing and set as current active session
-		sessionState.isProcessing = true
-		sessionState.cancelled = false
+		sessionState.status = AcpSessionStatus.Processing
 		session.lastActivityAt = Date.now()
 		this.currentActiveSessionId = params.sessionId
 
@@ -586,7 +593,7 @@ export class ClineAgent implements acp.Agent {
 					Logger.debug("[ClineAgent] Error during cleanup:", error)
 				}
 			}
-			sessionState.isProcessing = false
+			sessionState.status = AcpSessionStatus.Idle
 		}
 	}
 
@@ -648,7 +655,13 @@ export class ClineAgent implements acp.Agent {
 		permissionRequest: Omit<acp.RequestPermissionRequest, "sessionId">,
 	): Promise<void> {
 		const session = this.sessions.get(sessionId)
-		const controller = session?.controller
+
+		if (!session) {
+			Logger.debug("[ClineAgent] No session found for permission request")
+			return
+		}
+
+		const controller = this.#sessionControllers.get(session)
 
 		if (!controller?.task) {
 			Logger.debug("[ClineAgent] No active task for permission request")
@@ -829,7 +842,7 @@ export class ClineAgent implements acp.Agent {
 
 				await this.emitSessionUpdate(sessionId, {
 					sessionUpdate,
-					content: { type: "text", text: needsNewline ? "\n" + textDelta : textDelta },
+					content: { type: "text", text: needsNewline ? `\n${textDelta}` : textDelta },
 				})
 			}
 
@@ -882,18 +895,22 @@ export class ClineAgent implements acp.Agent {
 	 */
 	async cancel(params: acp.CancelNotification): Promise<void> {
 		const session = this.sessions.get(params.sessionId)
+		if (!session) {
+			Logger.debug("[ClineAgent] cancel called for non-existent session:", params.sessionId)
+			return
+		}
 		const sessionState = this.sessionStates.get(params.sessionId)
 
 		Logger.debug("[ClineAgent] cancel called:", {
 			sessionId: params.sessionId,
-			isProcessing: sessionState?.isProcessing,
+			status: sessionState?.status,
 		})
 
 		if (sessionState) {
-			sessionState.cancelled = true
+			sessionState.status = AcpSessionStatus.Cancelled
 
 			// If we have an active controller task, cancel it
-			const controller = session?.controller
+			const controller = this.#sessionControllers.get(session)
 			if (controller?.task) {
 				try {
 					await controller.cancelTask()
@@ -934,7 +951,7 @@ export class ClineAgent implements acp.Agent {
 		session.lastActivityAt = Date.now()
 
 		// Update Controller mode if active
-		const controller = session.controller
+		const controller = this.#sessionControllers.get(session)
 		if (controller) {
 			controller.stateManager.setGlobalState("mode", session.mode)
 
@@ -1065,7 +1082,7 @@ export class ClineAgent implements acp.Agent {
 	 * @returns The permission response from the client
 	 */
 	protected async requestPermission(
-		_sessionId: string,
+		sessionId: string,
 		toolCall: acp.ToolCallUpdate,
 		options: acp.PermissionOption[],
 	): Promise<acp.RequestPermissionResponse> {
@@ -1080,17 +1097,15 @@ export class ClineAgent implements acp.Agent {
 			return { outcome: "rejected" as unknown as acp.RequestPermissionOutcome }
 		}
 
-		// Use the permission handler callback pattern
-		return new Promise<acp.RequestPermissionResponse>((resolve) => {
-			this.permissionHandler!({ toolCall, options }, resolve)
-		})
+		return await this.permissionHandler({ sessionId, toolCall, options })
 	}
 
 	async shutdown(): Promise<void> {
 		for (const [sessionId, session] of this.sessions) {
-			await session.controller?.task?.abortTask()
-			await session.controller?.stateManager.flushPendingState()
-			await session.controller?.dispose()
+			const controller = this.#sessionControllers.get(session)
+			await controller?.task?.abortTask()
+			await controller?.stateManager.flushPendingState()
+			await controller?.dispose()
 			this.sessions.delete(sessionId)
 			this.sessionStates.delete(sessionId)
 		}
@@ -1146,43 +1161,6 @@ export class ClineAgent implements acp.Agent {
 		}
 	}
 
-	/**
-	 * Check if the user has authentication configured.
-	 * Returns true if they have either:
-	 * - Cline provider with stored auth data
-	 * - OpenAI Codex provider with OAuth credentials
-	 * - BYO provider with an API key configured
-	 */
-	private async isAuthConfigured(): Promise<boolean> {
-		const stateManager = StateManager.get()
-		const mode = stateManager.getGlobalSettingsKey("mode") as string
-		const providerKey = mode === "act" ? "actModeApiProvider" : "planModeApiProvider"
-		const currentProvider = (stateManager.getGlobalSettingsKey(providerKey) as string) || "cline"
-
-		if (currentProvider === "cline") {
-			// For Cline provider, check if we have stored auth data
-			return Boolean(
-				stateManager.getSecretKey("clineApiKey") ||
-					stateManager.getSecretKey("clineAccountId") ||
-					stateManager.getSecretKey("cline:clineAccountId"),
-			)
-		}
-
-		// For OpenAI Codex provider, check OAuth credentials
-		if (currentProvider === "openai-codex") {
-			return await openAiCodexOAuthManager.isAuthenticated()
-		}
-
-		// For BYO providers, check if the API key is configured
-		const keyField = ProviderToApiKeyMap[currentProvider as keyof typeof ProviderToApiKeyMap]
-		if (!keyField) {
-			return false
-		}
-
-		const fields = Array.isArray(keyField) ? keyField : [keyField]
-		return fields.some((key) => stateManager.getSecretKey(key))
-	}
-
 	/**
 	 * Handle OpenAI Codex OAuth authentication flow.
 	 *

cli/src/agent/ClineSessionEmitter.ts

@@ -8,7 +8,7 @@
  */
 
 import { EventEmitter } from "events"
-import type { ClineSessionEvents } from "./types.js"
+import type { ClineSessionEvents } from "./public-types.js"
 
 /**
  * Type-safe EventEmitter for ClineAgent session events.

cli/src/agent/messageTranslator.test.ts

@@ -12,6 +12,7 @@ import type { ClineMessage } from "@shared/ExtensionMessage"
 import { beforeEach, describe, expect, it } from "vitest"
 import { createSessionState, translateMessage, translateMessages } from "./messageTranslator"
 import type { AcpSessionState } from "./types"
+import { AcpSessionStatus } from "./types"
 
 // =============================================================================
 // Test Helpers
@@ -175,8 +176,7 @@ describe("createSessionState", () => {
 		const state = createSessionState("my-session-123")
 
 		expect(state.sessionId).toBe("my-session-123")
-		expect(state.isProcessing).toBe(false)
-		expect(state.cancelled).toBe(false)
+		expect(state.status).toBe(AcpSessionStatus.Idle)
 		expect(state.pendingToolCalls).toBeInstanceOf(Map)
 		expect(state.pendingToolCalls.size).toBe(0)
 		expect(state.currentToolCallId).toBeUndefined()
@@ -187,11 +187,11 @@ describe("createSessionState", () => {
 		const state2 = createSessionState("session-2")
 
 		// Modify state1
-		state1.isProcessing = true
+		state1.status = AcpSessionStatus.Processing
 		state1.pendingToolCalls.set("tool-1", {} as acp.ToolCall)
 
 		// state2 should be unaffected
-		expect(state2.isProcessing).toBe(false)
+		expect(state2.status).toBe(AcpSessionStatus.Idle)
 		expect(state2.pendingToolCalls.size).toBe(0)
 	})
 })

cli/src/agent/messageTranslator.ts

@@ -11,6 +11,7 @@
 import type * as acp from "@agentclientprotocol/sdk"
 import type { ClineMessage, ClineSayBrowserAction, ClineSayTool } from "@shared/ExtensionMessage"
 import type { AcpSessionState, TranslatedMessage } from "./types.js"
+import { AcpSessionStatus } from "./types.js"
 
 /**
  * Maps Cline tool types to ACP ToolKind values.
@@ -1019,8 +1020,7 @@ export function translateMessages(messages: ClineMessage[], sessionState: AcpSes
 export function createSessionState(sessionId: string): AcpSessionState {
 	return {
 		sessionId,
-		isProcessing: false,
-		cancelled: false,
+		status: AcpSessionStatus.Idle,
 		pendingToolCalls: new Map(),
 	}
 }

cli/src/agent/public-types.ts

@@ -0,0 +1,254 @@
+/**
+ * Public types for the Cline library API.
+ *
+ * This file contains types that are safe to export to library consumers.
+ * It must NOT import any internal types (Controller, StateManager, etc.)
+ * to keep the generated declaration files clean.
+ *
+ * Internal-only extensions of these types live in ./types.ts.
+ */
+
+import type * as acp from "@agentclientprotocol/sdk"
+
+// ============================================================
+// Session Update Type Utilities
+// ============================================================
+
+/**
+ * Different types of updates that can be sent during session processing.
+ *
+ * These updates provide real-time feedback about the agent's progress.
+ *
+ * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
+ */
+export type SessionUpdateType = acp.SessionUpdate["sessionUpdate"]
+
+/**
+ * Different types of update payloads that can be sent during session processing.
+ *
+ * Each update type has a corresponding payload structure defined in the ACP SessionUpdate union.
+ */
+export type SessionUpdatePayload<T extends SessionUpdateType> = Omit<
+	Extract<acp.SessionUpdate, { sessionUpdate: T }>,
+	"sessionUpdate"
+>
+
+// ============================================================
+// Permission Handler Callback Types
+// ============================================================
+
+/**
+ * Handler function for permission requests.
+ * Called when the agent needs permission for a tool call.
+ * The handler should present the request to the user and call resolve() with their response.
+ */
+export type PermissionHandler = (request: acp.RequestPermissionRequest) => Promise<acp.RequestPermissionResponse>
+
+// ============================================================
+// Session Event Emitter Types
+// ============================================================
+
+/**
+ * Maps ACP SessionUpdate types to their event listener signatures.
+ * Uses the sessionUpdate discriminator to derive event names and payload types.
+ */
+export type ClineSessionEvents = {
+	[K in SessionUpdateType]: (payload: SessionUpdatePayload<K>) => void
+} & {
+	/** Error event for session-level errors (not part of ACP SessionUpdate) */
+	error: (error: Error) => void
+}
+
+// ============================================================
+// ClineAgent Options
+// ============================================================
+
+/**
+ * Options for creating a ClineAgent instance.
+ */
+export interface ClineAgentOptions {
+	/** Whether debug logging is enabled */
+	debug?: boolean
+	/** Cline Config Directory (defaults to ~/.cline) */
+	clineDir?: string
+}
+
+/**
+ * Options for creating an ACP agent instance.
+ */
+export interface AcpAgentOptions {
+	/** Whether debug logging is enabled */
+	debug?: boolean
+}
+
+// ============================================================
+// Session Types
+// ============================================================
+export type SessionID = string
+
+/**
+ * Extended session data stored by Cline for ACP sessions.
+ */
+export interface ClineAcpSession {
+	/** Unique session ID */
+	sessionId: SessionID
+	/** Working directory for the session */
+	cwd: string
+	/** Current mode (plan/act) */
+	mode: "plan" | "act"
+	/** MCP servers passed from the client */
+	mcpServers: acp.McpServer[]
+	/** Timestamp when session was created */
+	createdAt: number
+	/** Timestamp of last activity */
+	lastActivityAt: number
+	/** Whether this session was loaded from history (needs resume on first prompt) */
+	isLoadedFromHistory?: boolean
+	/** Model ID override for plan mode (format: "provider/modelId") */
+	planModeModelId?: string
+	/** Model ID override for act mode (format: "provider/modelId") */
+	actModeModelId?: string
+}
+
+/**
+ * Lifecycle status of an ACP session.
+ *
+ * Represents the state machine:
+ *   Idle → Processing → Idle       (normal completion)
+ *   Idle → Processing → Cancelled  (cancellation, then back to Idle on next prompt)
+ */
+export enum AcpSessionStatus {
+	/** Session is idle, waiting for a prompt */
+	Idle = "idle",
+	/** Session is actively processing a prompt */
+	Processing = "processing",
+	/** Session processing was cancelled */
+	Cancelled = "cancelled",
+}
+
+/**
+ * State tracking for an active ACP session within Cline.
+ */
+export interface AcpSessionState {
+	/** Session ID */
+	sessionId: SessionID
+	/** Current lifecycle status of the session */
+	status: AcpSessionStatus
+	/** Current tool call ID being executed (if any) */
+	currentToolCallId?: string
+	/** Accumulated tool calls for permission batching */
+	pendingToolCalls: Map<string, acp.ToolCall>
+}
+
+// ============================================================
+// Agent Capabilities
+// ============================================================
+
+/**
+ * Cline-specific agent capabilities extending the ACP base capabilities.
+ */
+export interface ClineAgentCapabilities {
+	/** Support for loading sessions from disk */
+	loadSession: boolean
+	/** Prompt capabilities for the agent */
+	promptCapabilities: {
+		/** Support for image inputs */
+		image: boolean
+		/** Support for audio inputs */
+		audio: boolean
+		/** Support for embedded context (file resources) */
+		embeddedContext: boolean
+	}
+	/** MCP server passthrough capabilities */
+	mcpCapabilities: {
+		/** Support for HTTP MCP servers */
+		http: boolean
+		/** Support for SSE MCP servers */
+		sse: boolean
+	}
+}
+
+/**
+ * Cline agent info for ACP initialization response.
+ */
+export interface ClineAgentInfo {
+	name: "cline"
+	title: "Cline"
+	version: string
+}
+
+// ============================================================
+// Permission Options
+// ============================================================
+
+/**
+ * Permission option as presented to the ACP client.
+ */
+export interface ClinePermissionOption {
+	kind: acp.PermissionOptionKind
+	name: string
+	optionId: string
+}
+
+// ============================================================
+// Message Translation
+// ============================================================
+
+/**
+ * Result of translating a Cline message to ACP session update(s).
+ * A single Cline message may produce multiple ACP updates.
+ */
+export interface TranslatedMessage {
+	/** The session updates to send */
+	updates: acp.SessionUpdate[]
+	/** Whether this message requires a permission request */
+	requiresPermission?: boolean
+	/** Permission request details if required */
+	permissionRequest?: Omit<acp.RequestPermissionRequest, "sessionId">
+	/** The toolCallId that was created/used (for tracking across streaming updates) */
+	toolCallId?: string
+}
+
+// ============================================================
+// Re-exported ACP Types
+// ============================================================
+
+export type {
+	Agent,
+	AgentSideConnection,
+	AudioContent,
+	CancelNotification,
+	ClientCapabilities,
+	ContentBlock,
+	ImageContent,
+	InitializeRequest,
+	InitializeResponse,
+	LoadSessionRequest,
+	LoadSessionResponse,
+	McpServer,
+	ModelInfo,
+	NewSessionRequest,
+	NewSessionResponse,
+	PermissionOption,
+	PermissionOptionKind,
+	PromptRequest,
+	PromptResponse,
+	RequestPermissionRequest,
+	RequestPermissionResponse,
+	SessionConfigOption,
+	SessionModelState,
+	SessionNotification,
+	SessionUpdate,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModelRequest,
+	SetSessionModelResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	StopReason,
+	TextContent,
+	ToolCall,
+	ToolCallStatus,
+	ToolCallUpdate,
+	ToolKind,
+} from "@agentclientprotocol/sdk"

cli/src/agent/types.ts

@@ -1,76 +1,13 @@
 /**
- * Custom types and extensions for ACP integration with Cline CLI.
+ * Internal types for ACP integration with Cline CLI.
  *
- * This file extends the base ACP types with Cline-specific functionality.
+ * This file re-exports all public types from ./public-types.ts and adds
+ * internal-only Types that reference core modules (Controller, etc.).
+ *
+ * Library consumers should never import from this file directly — they
+ * get the public types via the library entrypoint (exports.ts).
  */
 
-import type * as acp from "@agentclientprotocol/sdk"
-import type { Controller } from "@/core/controller"
-
-// ============================================================
-// Session Update Type Utilities
-// ============================================================
-
-/**
- * Extract the sessionUpdate discriminator value from a SessionUpdate variant.
- */
-export type SessionUpdateType = acp.SessionUpdate["sessionUpdate"]
-
-/**
- * Extract the payload type for a given sessionUpdate discriminator value.
- * This removes the `sessionUpdate` discriminator field from the type.
- */
-export type SessionUpdatePayload<T extends SessionUpdateType> = Omit<
-	Extract<acp.SessionUpdate, { sessionUpdate: T }>,
-	"sessionUpdate"
->
-
-// ============================================================
-// Permission Handler Callback Types
-// ============================================================
-
-/**
- * Callback to resolve a permission request with the user's response.
- */
-export type PermissionResolver = (response: acp.RequestPermissionResponse) => void
-
-/**
- * Handler function for permission requests.
- * Called when the agent needs permission for a tool call.
- * The handler should present the request to the user and call resolve() with their response.
- */
-export type PermissionHandler = (request: Omit<acp.RequestPermissionRequest, "sessionId">, resolve: PermissionResolver) => void
-
-// ============================================================
-// Session Event Emitter Types
-// ============================================================
-
-/**
- * Maps ACP SessionUpdate types to their event listener signatures.
- * Uses the sessionUpdate discriminator to derive event names and payload types.
- */
-export type ClineSessionEvents = {
-	[K in SessionUpdateType]: (payload: SessionUpdatePayload<K>) => void
-} & {
-	/** Error event for session-level errors (not part of ACP SessionUpdate) */
-	error: (error: Error) => void
-}
-
-// ============================================================
-// ClineAgent Options (decoupled from connection)
-// ============================================================
-
-/**
- * Options for creating a ClineAgent instance (decoupled from connection).
- */
-export interface ClineAgentOptions {
-	/** CLI version string */
-	version: string
-	/** Whether debug logging is enabled */
-	debug?: boolean
-}
-
-// Re-export common ACP types for convenience
 export type {
 	Agent,
 	AgentSideConnection,
@@ -114,134 +51,18 @@ export type {
 	WriteTextFileResponse,
 } from "@agentclientprotocol/sdk"
 
-/**
- * Cline-specific agent capabilities extending the ACP base capabilities.
- */
-export interface ClineAgentCapabilities {
-	/** Support for loading sessions from disk */
-	loadSession: boolean
-	/** Prompt capabilities for the agent */
-	promptCapabilities: {
-		/** Support for image inputs */
-		image: boolean
-		/** Support for audio inputs */
-		audio: boolean
-		/** Support for embedded context (file resources) */
-		embeddedContext: boolean
-	}
-	/** MCP server passthrough capabilities */
-	mcpCapabilities: {
-		/** Support for HTTP MCP servers */
-		http: boolean
-		/** Support for SSE MCP servers */
-		sse: boolean
-	}
-}
+export type {
+	AcpAgentOptions,
+	AcpSessionState,
+	ClineAgentCapabilities,
+	ClineAgentInfo,
+	ClineAgentOptions,
+	ClinePermissionOption,
+	ClineSessionEvents,
+	PermissionHandler,
+	SessionUpdatePayload,
+	SessionUpdateType,
+	TranslatedMessage,
+} from "./public-types.js"
 
-/**
- * Cline agent info for ACP initialization response.
- */
-export interface ClineAgentInfo {
-	name: "cline"
-	title: "Cline"
-	version: string
-}
-
-/**
- * Extended session data stored by Cline for ACP sessions.
- * Maps to Cline's task history structure.
- */
-export interface ClineAcpSession {
-	/** Unique session/task ID */
-	sessionId: string
-	/** Working directory for the session */
-	cwd: string
-	/** Current mode (plan/act) */
-	mode: "plan" | "act"
-	/** MCP servers passed from the client */
-	mcpServers: acp.McpServer[]
-	/** Timestamp when session was created */
-	createdAt: number
-	/** Timestamp of last activity */
-	lastActivityAt: number
-	/** Whether this session was loaded from history (needs resume on first prompt) */
-	isLoadedFromHistory?: boolean
-	/** Controller instance for this session (manages task execution) */
-	controller?: Controller
-	/** Model ID override for plan mode (format: "provider/modelId") */
-	planModeModelId?: string
-	/** Model ID override for act mode (format: "provider/modelId") */
-	actModeModelId?: string
-}
-
-/**
- * Permission option as presented to the ACP client.
- */
-export interface ClinePermissionOption {
-	kind: acp.PermissionOptionKind
-	name: string
-	optionId: string
-}
-
-/**
- * Mapping of Cline message types to their ACP session update equivalents.
- */
-export type ClineToAcpUpdateMapping = {
-	/** Text messages from the agent */
-	text: "agent_message_chunk"
-	/** Reasoning/thinking from the agent */
-	reasoning: "agent_thought_chunk"
-	/** Markdown content from the agent */
-	markdown: "agent_message_chunk"
-	/** Tool execution */
-	tool: "tool_call"
-	/** Command execution */
-	command: "tool_call"
-	/** Command output */
-	command_output: "tool_call_update"
-	/** Task completion */
-	completion_result: "end_turn"
-	/** Error messages */
-	error: "tool_call_update" | "error"
-}
-
-/**
- * Options for creating an ACP agent instance.
- */
-export interface AcpAgentOptions {
-	/** CLI version string */
-	version: string
-	/** Whether debug logging is enabled */
-	debug?: boolean
-}
-
-/**
- * Result of translating a Cline message to ACP session update(s).
- * A single Cline message may produce multiple ACP updates.
- */
-export interface TranslatedMessage {
-	/** The session updates to send */
-	updates: acp.SessionUpdate[]
-	/** Whether this message requires a permission request */
-	requiresPermission?: boolean
-	/** Permission request details if required */
-	permissionRequest?: Omit<acp.RequestPermissionRequest, "sessionId">
-	/** The toolCallId that was created/used (for tracking across streaming updates) */
-	toolCallId?: string
-}
-
-/**
- * State tracking for an active ACP session within Cline.
- */
-export interface AcpSessionState {
-	/** Session ID */
-	sessionId: string
-	/** Whether the session is currently processing a prompt */
-	isProcessing: boolean
-	/** Current tool call ID being executed (if any) */
-	currentToolCallId?: string
-	/** Whether the session has been cancelled */
-	cancelled: boolean
-	/** Accumulated tool calls for permission batching */
-	pendingToolCalls: Map<string, acp.ToolCall>
-}
+export { AcpSessionStatus } from "./public-types.js"

cli/src/components/AuthView.tsx

@@ -15,6 +15,7 @@ import { StringRequest } from "@/shared/proto/cline/common"
 import { openExternal } from "@/utils/env"
 import { COLORS } from "../constants/colors"
 import { useStdinContext } from "../context/StdinContext"
+import { useClineFeaturedModels } from "../hooks/useClineFeaturedModels"
 import { useOcaAuth } from "../hooks/useOcaAuth"
 import { useScrollableList } from "../hooks/useScrollableList"
 import { type DetectedSources, detectImportSources, type ImportSource } from "../utils/import-configs"
@@ -172,6 +173,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const [providerSearch, setProviderSearch] = useState("")
 	const [providerIndex, setProviderIndex] = useState(0)
 	const [clineModelIndex, setClineModelIndex] = useState(0)
+	const featuredModels = useClineFeaturedModels()
 	const [importSources, setImportSources] = useState<DetectedSources>({ codex: false, opencode: false })
 	const [importSource, setImportSource] = useState<ImportSource | null>(null)
 	const [bedrockConfig, setBedrockConfig] = useState<BedrockConfig | null>(null)
@@ -767,7 +769,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					<Box flexDirection="column">
 						<Text color="white">Choose a model</Text>
 						<Text> </Text>
-						<FeaturedModelPicker selectedIndex={clineModelIndex} />
+						<FeaturedModelPicker featuredModels={featuredModels} selectedIndex={clineModelIndex} />
 					</Box>
 				)
 			}
@@ -869,17 +871,17 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					setProviderSearch((prev) => prev + input)
 				}
 			} else if (step === "cline_model") {
-				const maxIndex = getFeaturedModelMaxIndex()
+				const maxIndex = getFeaturedModelMaxIndex(featuredModels)
 
 				if (key.upArrow) {
 					setClineModelIndex((prev) => (prev > 0 ? prev - 1 : maxIndex))
 				} else if (key.downArrow) {
 					setClineModelIndex((prev) => (prev < maxIndex ? prev + 1 : 0))
 				} else if (key.return) {
-					if (isBrowseAllSelected(clineModelIndex)) {
+					if (isBrowseAllSelected(clineModelIndex, featuredModels)) {
 						setStep("modelid")
 					} else {
-						const selectedModel = getFeaturedModelAtIndex(clineModelIndex)
+						const selectedModel = getFeaturedModelAtIndex(clineModelIndex, featuredModels)
 						if (selectedModel) {
 							handleClineModelSelect(selectedModel.id)
 						}

cli/src/components/ChatMessage.markdown.test.tsx

@@ -0,0 +1,53 @@
+import type { ClineMessage } from "@shared/ExtensionMessage"
+import { render } from "ink-testing-library"
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import { ChatMessage } from "./ChatMessage"
+
+vi.mock("../hooks/useTerminalSize", () => ({
+	useTerminalSize: () => ({
+		columns: 120,
+		rows: 40,
+		resizeKey: 0,
+	}),
+}))
+
+describe("ChatMessage markdown rendering", () => {
+	it("renders basic markdown elements correctly with appropriate styling", () => {
+		const message: ClineMessage = {
+			ts: Date.now(),
+			type: "say",
+			say: "text",
+			text: "# Heading 1\n\nThis is a **bold** and *italic* text with `inline code`.\n\n- List item 1\n- List item 2\n\n> Blockquote\n\n```javascript\nconst x = 1;\n```",
+		}
+
+		const { lastFrame } = render(React.createElement(ChatMessage, { message, mode: "act" }))
+		const frame = lastFrame() || ""
+
+		// Check for heading (bold)
+		// \x1B[1m is the ANSI escape code for bold
+		expect(frame).toMatch(/\x1B\[1mHeading 1\x1B\[22m/)
+
+		// Check for bold text
+		expect(frame).toMatch(/\x1B\[1mbold\x1B\[22m/)
+
+		// Check for italic text
+		// \x1B[3m is the ANSI escape code for italic
+		expect(frame).toMatch(/\x1B\[3mitalic\x1B\[23m/)
+
+		// Check for inline code (no special styling in the current implementation, just text)
+		expect(frame).toContain("inline code")
+
+		// Check for list items (gray bullet)
+		// \x1B[90m is the ANSI escape code for gray
+		expect(frame).toMatch(/\x1B\[90m• \x1B\[39mList item 1/)
+		expect(frame).toMatch(/\x1B\[90m• \x1B\[39mList item 2/)
+
+		// Check for blockquote (gray pipe)
+		expect(frame).toMatch(/\x1B\[90m│ \x1B\[39mBlockquote/)
+
+		// Check for code block (cyan text)
+		// \x1B[36m is the ANSI escape code for cyan
+		expect(frame).toMatch(/\x1B\[36mconst x = 1;\x1B\[39m/)
+	})
+})

cli/src/components/ChatMessage.tsx

@@ -11,6 +11,7 @@ import { COMMAND_OUTPUT_STRING } from "@shared/combineCommandSequences"
 import type { ClineAskUseMcpServer, ClineMessage } from "@shared/ExtensionMessage"
 import { Box, Text } from "ink"
 import Spinner from "ink-spinner"
+import { lexer, type Token, type Tokens } from "marked"
 import React from "react"
 import { COLORS } from "../constants/colors"
 import { useTerminalSize } from "../hooks/useTerminalSize"
@@ -20,13 +21,10 @@ import { DiffView } from "./DiffView"
 import { SubagentMessage } from "./SubagentMessage"
 
 /**
- * Add "(Tab)" hint after "Act mode" mentions.
+ * Add "(Tab)" hint after "Act mode" mentions in plain text.
  * Case-insensitive, avoids double-adding if already present.
- * Matches just "Act mode" without requiring "to " prefix because markdown
- * processing may split "toggle to **Act mode**" into separate text chunks.
  */
 function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
-	// Match "Act mode" in various capitalizations, but not if already followed by (Tab)
 	const actModeRegex = /\bact\s+mode\b(?!\s*\(tab\))/gi
 	const parts = text.split(actModeRegex)
 	const matches = text.match(actModeRegex)
@@ -37,9 +35,7 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
 
 	const nodes: React.ReactNode[] = []
 	parts.forEach((part, i) => {
-		if (part) {
-			nodes.push(part)
-		}
+		if (part) nodes.push(part)
 		if (matches[i]) {
 			nodes.push(
 				<React.Fragment key={`${keyPrefix}-act-mode-${i}`}>
@@ -49,72 +45,146 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
 			)
 		}
 	})
-
 	return nodes
 }
 
 /**
- * Render inline markdown: **bold**, *italic*, `code`
- * Also adds "(Tab)" hints after "Act mode" mentions.
- * Returns array of React nodes with appropriate styling
+ * Render an array of marked tokens as Ink React nodes.
+ * This is the entry point for recursive rendering — each token may
+ * contain child tokens (e.g. a paragraph contains inline tokens,
+ * a list contains items, etc.).
  */
-function renderInlineMarkdown(text: string): React.ReactNode[] {
-	const nodes: React.ReactNode[] = []
-	let hintCallIndex = 0
-	const addHintedText = (value: string) => addActModeHint(value, `hint-${hintCallIndex++}`)
-	// Match **bold**, *italic*, or `code` - order matters (** before *)
-	const regex = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g
-	let lastIndex = 0
-	let match
-
-	while ((match = regex.exec(text)) !== null) {
-		// Add text before match (with Act Mode hint processing)
-		if (match.index > lastIndex) {
-			const beforeText = text.slice(lastIndex, match.index)
-			nodes.push(...addHintedText(beforeText))
-		}
-
-		const fullMatch = match[0]
-		const key = `md-${match.index}`
-
-		if (fullMatch.startsWith("**") && fullMatch.endsWith("**")) {
-			// Bold - also process for Act Mode hints inside bold text
-			const boldContent = fullMatch.slice(2, -2)
-			const hintedContent = addHintedText(boldContent)
-			nodes.push(
-				<Text bold key={key}>
-					{hintedContent}
-				</Text>,
-			)
-		} else if (fullMatch.startsWith("*") && fullMatch.endsWith("*")) {
-			// Italic
-			nodes.push(
-				<Text italic key={key}>
-					{fullMatch.slice(1, -1)}
-				</Text>,
-			)
-		} else if (fullMatch.startsWith("`") && fullMatch.endsWith("`")) {
-			// Inline code
-			nodes.push(<Text key={key}>{fullMatch.slice(1, -1)}</Text>)
-		}
-
-		lastIndex = regex.lastIndex
-	}
-
-	// Add remaining text (with Act Mode hint processing)
-	if (lastIndex < text.length) {
-		nodes.push(...addHintedText(text.slice(lastIndex)))
-	}
-
-	return nodes.length > 0 ? nodes : addHintedText(text)
+function renderTokens(tokens: Token[], color?: string): React.ReactNode[] {
+	return tokens.map((token, i) => renderToken(token, i, color))
 }
 
 /**
- * Render text with inline markdown support
+ * Render a single marked token (block or inline) as an Ink React node.
+ * Handles both block-level tokens (heading, paragraph, list, code, etc.)
+ * and inline tokens (strong, em, codespan, link, text).
+ */
+function renderToken(token: Token, key: number, color?: string): React.ReactNode {
+	switch (token.type) {
+		// --- Block tokens ---
+
+		case "heading": {
+			const { depth, tokens } = token as Tokens.Heading
+			return (
+				<Box key={key} marginY={depth === 1 ? 1 : 0}>
+					<Text bold color={color}>
+						{renderTokens(tokens, color)}
+					</Text>
+				</Box>
+			)
+		}
+
+		case "paragraph":
+			return (
+				<Text color={color} key={key}>
+					{renderTokens((token as Tokens.Paragraph).tokens, color)}
+				</Text>
+			)
+
+		case "code":
+			return (
+				<Box flexDirection="column" key={key} marginY={1}>
+					{(token as Tokens.Code).text.split("\n").map((line, i) => (
+						<Text color="cyan" key={i}>
+							{line || " "}
+						</Text>
+					))}
+				</Box>
+			)
+
+		case "list": {
+			const { ordered, start, items } = token as Tokens.List
+			return (
+				<Box flexDirection="column" key={key}>
+					{items.map((item, i) => (
+						<Box flexDirection="row" key={i}>
+							<Text color="gray">{ordered ? `${Number(start ?? 1) + i}. ` : "• "}</Text>
+							<Box flexDirection="column" flexGrow={1}>
+								{renderTokens(item.tokens, color)}
+							</Box>
+						</Box>
+					))}
+				</Box>
+			)
+		}
+
+		case "blockquote":
+			return (
+				<Box flexDirection="row" key={key}>
+					<Text color="gray">│ </Text>
+					<Box flexDirection="column">{renderTokens((token as Tokens.Blockquote).tokens, color)}</Box>
+				</Box>
+			)
+
+		case "space":
+			return <Text key={key}> </Text>
+
+		// --- Inline tokens ---
+
+		case "strong":
+			return (
+				<Text bold color={color} key={key}>
+					{renderTokens((token as Tokens.Strong).tokens, color)}
+				</Text>
+			)
+
+		case "em":
+			return (
+				<Text color={color} italic key={key}>
+					{renderTokens((token as Tokens.Em).tokens, color)}
+				</Text>
+			)
+
+		case "codespan":
+			return <Text key={key}>{(token as Tokens.Codespan).text}</Text>
+
+		case "link": {
+			const { text, href } = token as Tokens.Link
+			return (
+				<Text color={color} key={key}>
+					{text && text !== href ? `${text} (${href})` : href}
+				</Text>
+			)
+		}
+
+		case "text": {
+			const { text, tokens } = token as Tokens.Text
+			if (tokens?.length) {
+				return (
+					<Text color={color} key={key}>
+						{renderTokens(tokens, color)}
+					</Text>
+				)
+			}
+			return (
+				<Text color={color} key={key}>
+					{addActModeHint(text, `${key}`)}
+				</Text>
+			)
+		}
+
+		// Fallback for any unhandled token type
+		default:
+			return "raw" in token ? (
+				<Text color={color} key={key}>
+					{(token as { raw: string }).raw}
+				</Text>
+			) : null
+	}
+}
+
+/**
+ * Render a markdown string as Ink components.
+ * Uses marked's lexer to parse markdown into tokens, then renders
+ * each token to the appropriate Ink component.
  */
 const MarkdownText: React.FC<{ children: string; color?: string }> = ({ children, color }) => {
-	const nodes = renderInlineMarkdown(children)
-	return <Text color={color}>{nodes}</Text>
+	const tokens = lexer(children)
+	return <Box flexDirection="column">{renderTokens(tokens, color)}</Box>
 }
 
 interface ChatMessageProps {

cli/src/components/ChatView.tsx

@@ -1172,7 +1172,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 						setSlashMenuDismissed(true)
 						return
 					}
-					if (cmd.name === "exit") {
+					if (cmd.name === "exit" || cmd.name === "q") {
 						handleExit()
 						return
 					}

cli/src/components/FeaturedModelPicker.tsx

@@ -7,13 +7,14 @@
 import { Box, Text } from "ink"
 import React from "react"
 import { COLORS } from "../constants/colors"
-import { type FeaturedModel, getAllFeaturedModels } from "../constants/featured-models"
+import type { FeaturedModel } from "../constants/featured-models"
 
 interface FeaturedModelPickerProps {
 	selectedIndex: number
 	title?: string
 	showBrowseAll?: boolean
 	helpText?: string
+	featuredModels: FeaturedModel[]
 }
 
 export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
@@ -21,8 +22,9 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 	title,
 	showBrowseAll = true,
 	helpText = "Arrows to navigate, Enter to select",
+	featuredModels,
 }) => {
-	const featuredModels = getAllFeaturedModels()
+	const models = featuredModels
 
 	return (
 		<Box flexDirection="column">
@@ -35,7 +37,7 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 				</Text>
 			)}
 
-			{featuredModels.map((model, i) => {
+			{models.map((model, i) => {
 				const isSelected = i === selectedIndex
 
 				return (
@@ -64,8 +66,8 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 
 			{showBrowseAll && (
 				<Box>
-					<Text color={selectedIndex === featuredModels.length ? COLORS.primaryBlue : "white"}>
-						{selectedIndex === featuredModels.length ? "❯ " : "  "}
+					<Text color={selectedIndex === models.length ? COLORS.primaryBlue : "white"}>
+						{selectedIndex === models.length ? "❯ " : "  "}
 						Browse all models...
 					</Text>
 				</Box>
@@ -81,24 +83,21 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
  * Get the maximum valid index for the featured model picker
  * (includes "Browse all" option if showBrowseAll is true)
  */
-export function getFeaturedModelMaxIndex(showBrowseAll = true): number {
-	const featuredModels = getAllFeaturedModels()
+export function getFeaturedModelMaxIndex(featuredModels: FeaturedModel[], showBrowseAll = true): number {
 	return showBrowseAll ? featuredModels.length : featuredModels.length - 1
 }
 
 /**
  * Check if the selected index is the "Browse all" option
  */
-export function isBrowseAllSelected(selectedIndex: number): boolean {
-	const featuredModels = getAllFeaturedModels()
+export function isBrowseAllSelected(selectedIndex: number, featuredModels: FeaturedModel[]): boolean {
 	return selectedIndex === featuredModels.length
 }
 
 /**
  * Get the featured model at the given index, or null if "Browse all" is selected
  */
-export function getFeaturedModelAtIndex(index: number): FeaturedModel | null {
-	const featuredModels = getAllFeaturedModels()
+export function getFeaturedModelAtIndex(index: number, featuredModels: FeaturedModel[]): FeaturedModel | null {
 	if (index >= 0 && index < featuredModels.length) {
 		return featuredModels[index]
 	}

cli/src/components/HelpPanelContent.tsx

@@ -88,6 +88,10 @@ export const HelpPanelContent: React.FC<HelpPanelContentProps> = ({ onClose }) =
 						{"  "}
 						<Text color="white">/clear</Text> - Start a fresh task
 					</Text>
+					<Text>
+						{"  "}
+						<Text color="white">/q</Text> - Quit Cline
+					</Text>
 				</Box>
 
 				<Text>

cli/src/components/QuitCommand.test.tsx

@@ -0,0 +1,112 @@
+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"
+
+// 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(),
+}))
+
+// 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()
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	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("should exit the application when /exit is selected from slash menu", async () => {
+		const { stdin } = render(<ChatView onExit={mockOnExit} />)
+		await delay()
+
+		// 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()
+	})
+})

cli/src/components/SettingsPanelContent.tsx

@@ -25,6 +25,7 @@ import { supportsReasoningEffortForModel } from "@/utils/model-utils"
 import { version as CLI_VERSION } from "../../package.json"
 import { COLORS } from "../constants/colors"
 import { useStdinContext } from "../context/StdinContext"
+import { useClineFeaturedModels } from "../hooks/useClineFeaturedModels"
 import { useOcaAuth } from "../hooks/useOcaAuth"
 import { isMouseEscapeSequence } from "../utils/input"
 import { applyBedrockConfig, applyProviderConfig } from "../utils/provider-config"
@@ -161,6 +162,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	)
 	const [isPickingFeaturedModel, setIsPickingFeaturedModel] = useState(initialMode === "featured-models")
 	const [featuredModelIndex, setFeaturedModelIndex] = useState(0)
+	const featuredModels = useClineFeaturedModels()
 	const [isPickingProvider, setIsPickingProvider] = useState(false)
 	const [isPickingLanguage, setIsPickingLanguage] = useState(false)
 	const [isEnteringApiKey, setIsEnteringApiKey] = useState(false)
@@ -1292,7 +1294,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 
 			// Featured model picker mode (Cline provider)
 			if (isPickingFeaturedModel) {
-				const maxIndex = getFeaturedModelMaxIndex()
+				const maxIndex = getFeaturedModelMaxIndex(featuredModels)
 
 				if (key.escape) {
 					setIsPickingFeaturedModel(false)
@@ -1306,12 +1308,12 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 				} else if (key.downArrow) {
 					setFeaturedModelIndex((prev) => (prev < maxIndex ? prev + 1 : 0))
 				} else if (key.return) {
-					if (isBrowseAllSelected(featuredModelIndex)) {
+					if (isBrowseAllSelected(featuredModelIndex, featuredModels)) {
 						// Switch to full ModelPicker
 						setIsPickingFeaturedModel(false)
 						setIsPickingModel(true)
 					} else {
-						const selectedModel = getFeaturedModelAtIndex(featuredModelIndex)
+						const selectedModel = getFeaturedModelAtIndex(featuredModelIndex, featuredModels)
 						if (selectedModel && pickingModelKey) {
 							handleModelSelect(selectedModel.id)
 							setIsPickingFeaturedModel(false)
@@ -1522,6 +1524,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 			const label = pickingModelKey === "actModelId" ? "Model ID (Act)" : "Model ID (Plan)"
 			return (
 				<FeaturedModelPicker
+					featuredModels={featuredModels}
 					helpText="Arrows to navigate, Enter to select, Esc to cancel"
 					selectedIndex={featuredModelIndex}
 					title={`Select: ${label}`}

cli/src/constants/featured-models.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { getAllFeaturedModels } from "./featured-models"
+import { getAllFeaturedModels, mapRecommendedModelsToFeaturedModels } from "./featured-models"
 
 describe("featured models", () => {
 	it("includes display names for all featured models", () => {
@@ -9,4 +9,15 @@ describe("featured models", () => {
 			expect(model.name).toBeTruthy()
 		}
 	})
+
+	it("fills free model metadata from fallback when upstream payload is sparse", () => {
+		const models = mapRecommendedModelsToFeaturedModels({
+			recommended: [],
+			free: [{ id: "trinity-large-preview:free", name: "trinity-large-preview:free", description: "", tags: [] }],
+		})
+
+		expect(models.free[0]?.name).toBe("Arcee AI Trinity Large Preview")
+		expect(models.free[0]?.description).toBe("Arcee AI's advanced large preview model in the Trinity series")
+		expect(models.free[0]?.labels).toContain("FREE")
+	})
 })

cli/src/constants/featured-models.ts

@@ -2,6 +2,7 @@
  * Featured models shown in the Cline model picker during onboarding
  * These are curated models that work well with Cline
  */
+import { CLINE_RECOMMENDED_MODELS_FALLBACK } from "@shared/cline/recommended-models"
 
 export interface FeaturedModel {
 	id: string
@@ -10,61 +11,81 @@ export interface FeaturedModel {
 	labels: string[]
 }
 
-export const FEATURED_MODELS: { recommended: FeaturedModel[]; free: FeaturedModel[] } = {
-	recommended: [
-		{
-			id: "google/gemini-3.1-pro-preview",
-			name: "Gemini 3.1 Pro Preview",
-			description: "Latest Gemini release with 1m ctx window and strong coding performance",
-			labels: ["NEW"],
-		},
-		{
-			id: "anthropic/claude-sonnet-4.6",
-			name: "Claude Sonnet 4.6",
-			description: "Latest Sonnet release with strong coding and agent performance",
-			labels: ["NEW"],
-		},
-		{
-			id: "anthropic/claude-opus-4.6",
-			name: "Claude Opus 4.6",
-			description: "Most intelligent model for agents and coding",
-			labels: ["BEST"],
-		},
-		{
-			id: "openai/gpt-5.2-codex",
-			name: "GPT 5.2 Codex",
-			description: "OpenAI's latest with strong coding abilities",
-			labels: ["HOT"],
-		},
-	],
-	free: [
-		{
-			id: "minimax/minimax-m2.5",
-			name: "MiniMax M2.5",
-			description: "MiniMax-M2.5 is a lightweight, state-of-the-art LLM optimized for coding and agentic workflows",
-			labels: ["FREE"],
-		},
-		{
-			id: "z-ai/glm-5",
-			name: "Z-AI GLM5",
-			description: "Z.AI's latest GLM 5 model with strong coding and agent performance",
-			labels: ["FREE"],
-		},
-		{
-			id: "kwaipilot/kat-coder-pro",
-			name: "KAT Coder Pro",
-			description: "KwaiKAT's most advanced agentic coding model in the KAT-Coder series",
-			labels: ["FREE"],
-		},
-		{
-			id: "arcee-ai/trinity-large-preview:free",
-			name: "Trinity Large Preview",
-			description: "Arcee AI's advanced large preview model in the Trinity series",
-			labels: ["FREE"],
-		},
-	],
+type RecommendedModelLike = {
+	id: string
+	name: string
+	description: string
+	tags: string[]
 }
 
-export function getAllFeaturedModels(): FeaturedModel[] {
-	return [...FEATURED_MODELS.recommended, ...FEATURED_MODELS.free]
+export interface FeaturedModelsByTier {
+	recommended: FeaturedModel[]
+	free: FeaturedModel[]
+}
+
+interface RecommendedModelsByTier {
+	recommended: RecommendedModelLike[]
+	free: RecommendedModelLike[]
+}
+
+function toFeaturedModel(model: RecommendedModelLike): FeaturedModel {
+	return {
+		id: model.id,
+		name: model.name,
+		description: model.description,
+		labels: model.tags,
+	}
+}
+
+function getModelIdSuffix(id: string): string {
+	const lastSlashIndex = id.lastIndexOf("/")
+	return lastSlashIndex >= 0 ? id.slice(lastSlashIndex + 1) : id
+}
+
+function findFallbackFeaturedModelById(models: FeaturedModel[], id: string): FeaturedModel | undefined {
+	const idSuffix = getModelIdSuffix(id)
+	return models.find((model) => model.id === id || getModelIdSuffix(model.id) === idSuffix)
+}
+
+function mapRecommendedModelToFeaturedModelWithFallback(
+	model: RecommendedModelLike,
+	fallbackModels: FeaturedModel[],
+	defaultLabels: string[] = [],
+): FeaturedModel {
+	const fallbackModel = findFallbackFeaturedModelById(fallbackModels, model.id)
+	const upstreamNameLooksLikeFallback = model.name === model.id || model.name.trim().length === 0
+	const name = upstreamNameLooksLikeFallback ? (fallbackModel?.name ?? model.name) : model.name
+	const description = model.description.trim().length > 0 ? model.description : (fallbackModel?.description ?? "")
+	const labels = model.tags.length > 0 ? model.tags : (fallbackModel?.labels ?? defaultLabels)
+
+	return {
+		id: model.id,
+		name,
+		description,
+		labels,
+	}
+}
+
+export const FEATURED_MODELS: FeaturedModelsByTier = {
+	recommended: CLINE_RECOMMENDED_MODELS_FALLBACK.recommended.map(toFeaturedModel),
+	free: CLINE_RECOMMENDED_MODELS_FALLBACK.free.map(toFeaturedModel),
+}
+
+export function getAllFeaturedModels(modelsByTier: FeaturedModelsByTier = FEATURED_MODELS): FeaturedModel[] {
+	return [...modelsByTier.recommended, ...modelsByTier.free]
+}
+
+export function mapRecommendedModelsToFeaturedModels(data: RecommendedModelsByTier): FeaturedModelsByTier {
+	return {
+		recommended: data.recommended.map((model) =>
+			mapRecommendedModelToFeaturedModelWithFallback(model, FEATURED_MODELS.recommended),
+		),
+		free: data.free.map((model) => mapRecommendedModelToFeaturedModelWithFallback(model, FEATURED_MODELS.free, ["FREE"])),
+	}
+}
+
+export function withFeaturedModelFallback(modelsByTier: FeaturedModelsByTier): FeaturedModelsByTier {
+	const recommended = modelsByTier.recommended.length > 0 ? modelsByTier.recommended : FEATURED_MODELS.recommended
+	const free = modelsByTier.free.length > 0 ? modelsByTier.free : FEATURED_MODELS.free
+	return { recommended, free }
 }

cli/src/exports.ts

@@ -0,0 +1,71 @@
+/**
+ * Cline Library Exports
+ *
+ * This file exports the public API for programmatic use of Cline.
+ * Use these classes and types to embed Cline into your applications.
+ *
+ * @example
+ * ```typescript
+ * import { ClineAgent } from "cline"
+ *
+ * const agent = new ClineAgent()
+ * await agent.initialize({ clientCapabilities: {} })
+ * const session = await agent.newSession({ cwd: process.cwd() })
+ * ```
+ * @module cline
+ */
+
+export { ClineAgent } from "./agent/ClineAgent.js"
+export { ClineSessionEmitter } from "./agent/ClineSessionEmitter.js"
+export type {
+	AcpAgentOptions,
+	AcpSessionState,
+	AcpSessionStatus,
+	Agent,
+	AgentSideConnection,
+	AudioContent,
+	CancelNotification,
+	ClientCapabilities,
+	ClineAcpSession,
+	ClineAgentCapabilities,
+	ClineAgentInfo,
+	ClineAgentOptions,
+	ClinePermissionOption,
+	ClineSessionEvents,
+	ContentBlock,
+	ImageContent,
+	InitializeRequest,
+	InitializeResponse,
+	LoadSessionRequest,
+	LoadSessionResponse,
+	McpServer,
+	ModelInfo,
+	NewSessionRequest,
+	NewSessionResponse,
+	PermissionHandler,
+	PermissionOption,
+	PermissionOptionKind,
+	PromptRequest,
+	PromptResponse,
+	RequestPermissionRequest,
+	RequestPermissionResponse,
+	SessionConfigOption,
+	SessionModelState,
+	SessionNotification,
+	SessionUpdate,
+	SessionUpdatePayload,
+	SessionUpdateType,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModelRequest,
+	SetSessionModelResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	StopReason,
+	TextContent,
+	ToolCall,
+	ToolCallStatus,
+	ToolCallUpdate,
+	ToolKind,
+	TranslatedMessage,
+} from "./agent/public-types.js"

cli/src/hooks/useClineFeaturedModels.ts

@@ -0,0 +1,34 @@
+import { useEffect, useState } from "react"
+import { refreshClineRecommendedModels } from "@/core/controller/models/refreshClineRecommendedModels"
+import {
+	type FeaturedModel,
+	getAllFeaturedModels,
+	mapRecommendedModelsToFeaturedModels,
+	withFeaturedModelFallback,
+} from "../constants/featured-models"
+
+export function useClineFeaturedModels(): FeaturedModel[] {
+	const [featuredModels, setFeaturedModels] = useState<FeaturedModel[]>(() => getAllFeaturedModels())
+
+	useEffect(() => {
+		let cancelled = false
+		void (async () => {
+			try {
+				const recommendedModels = await refreshClineRecommendedModels()
+				const mappedModels = mapRecommendedModelsToFeaturedModels(recommendedModels)
+				const modelsWithFallback = withFeaturedModelFallback(mappedModels)
+				if (!cancelled) {
+					setFeaturedModels(getAllFeaturedModels(modelsWithFallback))
+				}
+			} catch {
+				// Keep local fallback models on error.
+			}
+		})()
+
+		return () => {
+			cancelled = true
+		}
+	}, [])
+
+	return featuredModels
+}

cli/src/index.ts

@@ -20,7 +20,7 @@ import { PostHogClientProvider } from "@/services/telemetry/providers/posthog/Po
 import { HistoryItem } from "@/shared/HistoryItem"
 import { Logger } from "@/shared/services/Logger"
 import { Session } from "@/shared/services/Session"
-import { getProviderModelIdKey, ProviderToApiKeyMap } from "@/shared/storage"
+import { getProviderModelIdKey } from "@/shared/storage"
 import { isOpenaiReasoningEffort, OPENAI_REASONING_EFFORT_OPTIONS, type OpenaiReasoningEffort } from "@/shared/storage/types"
 import { version as CLI_VERSION } from "../package.json"
 import { runAcpMode } from "./acp/index.js"
@@ -29,7 +29,8 @@ import { checkRawModeSupport } from "./context/StdinContext"
 import { createCliHostBridgeProvider } from "./controllers"
 import { CliCommentReviewController } from "./controllers/CliCommentReviewController"
 import { CliWebviewProvider } from "./controllers/CliWebviewProvider"
-import { restoreConsole } from "./utils/console"
+import { isAuthConfigured } from "./utils/auth"
+import { restoreConsole, suppressConsoleUnlessVerbose } from "./utils/console"
 import { printInfo, printWarning } from "./utils/display"
 import { selectOutputMode } from "./utils/mode-selection"
 import { parseImagesFromInput, processImagePaths } from "./utils/parser"
@@ -42,6 +43,10 @@ import { autoUpdateOnStartup, checkForUpdates } from "./utils/update"
 import { initializeCliContext } from "./vscode-context"
 import { CLI_LOG_FILE, shutdownEvent, window } from "./vscode-shim"
 
+// CLI-only behavior: suppress console output unless verbose mode is enabled.
+// Kept explicit here so importing the library bundle does not mutate global console methods.
+suppressConsoleUnlessVerbose()
+
 /**
  * Common options shared between runTask and resumeTask
  */
@@ -790,68 +795,6 @@ devCommand
 		await openExternal(CLI_LOG_FILE)
 	})
 
-/**
- * Check if the user has completed onboarding (has any provider configured).
- *
- * Uses `welcomeViewCompleted` as the single source of truth, matching the VS Code extension's approach.
- * If `welcomeViewCompleted` is undefined (first run), checks if ANY provider has credentials
- * and sets the flag accordingly.
- */
-async function isAuthConfigured(): Promise<boolean> {
-	const stateManager = StateManager.get()
-
-	// Check welcomeViewCompleted first - this is the single source of truth
-	const welcomeViewCompleted = stateManager.getGlobalStateKey("welcomeViewCompleted")
-	if (welcomeViewCompleted !== undefined) {
-		return welcomeViewCompleted
-	}
-
-	// welcomeViewCompleted is undefined - run migration logic to check if ANY provider has credentials
-	// This mirrors the extension's migrateWelcomeViewCompleted behavior
-	const hasAnyAuth = await checkAnyProviderConfigured()
-
-	// Set welcomeViewCompleted based on what we found
-	stateManager.setGlobalState("welcomeViewCompleted", hasAnyAuth)
-	await stateManager.flushPendingState()
-
-	return hasAnyAuth
-}
-
-/**
- * Check if ANY provider has valid credentials configured.
- * Used for migration when welcomeViewCompleted is undefined.
- */
-async function checkAnyProviderConfigured(): Promise<boolean> {
-	const stateManager = StateManager.get()
-	const config = stateManager.getApiConfiguration() as Record<string, unknown>
-
-	// Check Cline account (stored as "cline:clineAccountId" in secrets, loaded into config)
-	if (config["clineApiKey"] || config["cline:clineAccountId"]) return true
-
-	// Check OpenAI Codex OAuth (stored in SECRETS_KEYS, loaded into config)
-	if (config["openai-codex-oauth-credentials"]) return true
-
-	// Check all BYO provider API keys (loaded into config from secrets)
-	for (const [provider, keyField] of Object.entries(ProviderToApiKeyMap)) {
-		// Skip cline - already checked above with the correct key
-		if (provider === "cline") continue
-
-		const fields = Array.isArray(keyField) ? keyField : [keyField]
-		for (const field of fields) {
-			if (config[field]) return true
-		}
-	}
-
-	// Check provider-specific settings that indicate configuration
-	// (for providers that don't require API keys like Bedrock with IAM, Ollama, LM Studio)
-	if (config.awsRegion) return true
-	if (config.vertexProjectId) return true
-	if (config.ollamaBaseUrl) return true
-	if (config.lmStudioBaseUrl) return true
-
-	return false
-}
-
 /**
  * Validate that a task exists in history
  * @returns The task history item if found, null otherwise

cli/src/lib-import.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest"
+
+describe("library import side effects", () => {
+	it("importing library exports must not mutate console.log", async () => {
+		const originalConsoleLog = console.log
+		await import("./exports")
+		expect(console.log).toBe(originalConsoleLog)
+	}, 10000)
+})

cli/src/utils/auth.ts

@@ -0,0 +1,64 @@
+import { StateManager } from "@/core/storage/StateManager"
+import { ProviderToApiKeyMap } from "@/shared/storage"
+
+/**
+ * Check if the user has completed onboarding (has any provider configured).
+ *
+ * Uses `welcomeViewCompleted` as the single source of truth, matching the VS Code extension's approach.
+ * If `welcomeViewCompleted` is undefined (first run), checks if ANY provider has credentials
+ * and sets the flag accordingly.
+ */
+export async function isAuthConfigured(): Promise<boolean> {
+	const stateManager = StateManager.get()
+
+	// Check welcomeViewCompleted first - this is the single source of truth
+	const welcomeViewCompleted = stateManager.getGlobalStateKey("welcomeViewCompleted")
+	if (welcomeViewCompleted !== undefined) {
+		return welcomeViewCompleted
+	}
+
+	// welcomeViewCompleted is undefined - run migration logic to check if ANY provider has credentials
+	// This mirrors the extension's migrateWelcomeViewCompleted behavior
+	const hasAnyAuth = await checkAnyProviderConfigured()
+
+	// Set welcomeViewCompleted based on what we found
+	stateManager.setGlobalState("welcomeViewCompleted", hasAnyAuth)
+	await stateManager.flushPendingState()
+
+	return hasAnyAuth
+}
+
+/**
+ * Check if ANY provider has valid credentials configured.
+ * Used for migration when welcomeViewCompleted is undefined.
+ */
+export async function checkAnyProviderConfigured(): Promise<boolean> {
+	const stateManager = StateManager.get()
+	const config = stateManager.getApiConfiguration() as Record<string, unknown>
+
+	// Check Cline account (stored as "cline:clineAccountId" in secrets, loaded into config)
+	if (config["clineApiKey"] || config["cline:clineAccountId"]) return true
+
+	// Check OpenAI Codex OAuth (stored in SECRETS_KEYS, loaded into config)
+	if (config["openai-codex-oauth-credentials"]) return true
+
+	// Check all BYO provider API keys (loaded into config from secrets)
+	for (const [provider, keyField] of Object.entries(ProviderToApiKeyMap)) {
+		// Skip cline - already checked above with the correct key
+		if (provider === "cline") continue
+
+		const fields = Array.isArray(keyField) ? keyField : [keyField]
+		for (const field of fields) {
+			if (config[field]) return true
+		}
+	}
+
+	// Check provider-specific settings that indicate configuration
+	// (for providers that don't require API keys like Bedrock with IAM, Ollama, LM Studio)
+	if (config.awsRegion) return true
+	if (config.vertexProjectId) return true
+	if (config.ollamaBaseUrl) return true
+	if (config.lmStudioBaseUrl) return true
+
+	return false
+}

cli/src/utils/console.ts

@@ -12,11 +12,19 @@ export const originalConsoleWarn = console.warn.bind(console)
 export const originalConsoleInfo = console.info.bind(console)
 export const originalConsoleDebug = console.debug.bind(console)
 
-// Check for verbose flag early (before commander parses)
-const isVerbose = process.argv.includes("-v") || process.argv.includes("--verbose")
+/**
+ * Suppress console output unless verbose mode is enabled.
+ *
+ * This is intentionally opt-in and should only be called by the CLI entrypoint.
+ * Library consumers should not have their global console methods mutated as a
+ * side effect of importing the library bundle.
+ */
+export function suppressConsoleUnlessVerbose(argv: string[] = process.argv) {
+	const isVerbose = argv.includes("-v") || argv.includes("--verbose")
+	if (isVerbose) {
+		return
+	}
 
-// Suppress console output unless verbose mode
-if (!isVerbose) {
 	console.log = () => {}
 	console.warn = () => {}
 	console.error = () => {}

cli/tsconfig.lib.json

@@ -0,0 +1,20 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"declarationMap": false,
+		"noCheck": true,
+		"noResolve": true,
+		"outDir": "dist/types"
+	},
+	"include": [
+		"src/exports.ts",
+		"src/agent/public-types.ts",
+		"src/agent/ClineAgent.ts",
+		"src/agent/ClineSessionEmitter.ts",
+		"src/agent/types.ts",
+		"src/agent/messageTranslator.ts",
+		"src/agent/permissionHandler.ts"
+	]
+}

cli/vitest.config.ts

@@ -5,11 +5,28 @@ export default defineConfig({
 	test: {
 		globals: true,
 		environment: "node",
-		include: ["src/**/*.test.{ts,tsx}", "tests/**/*.test.{ts,tsx}"],
 		coverage: {
 			reporter: ["text", "json", "html"],
 			exclude: ["node_modules/", "dist/"],
 		},
+		projects: [
+			{
+				extends: true,
+				test: {
+					name: "unit",
+					include: ["src/**/*.test.{ts,tsx}", "tests/**/*.test.{ts,tsx}"],
+					exclude: ["src/**/*.markdown.test.tsx"],
+				},
+			},
+			{
+				extends: true,
+				test: {
+					name: "markdown",
+					include: ["src/**/*.markdown.test.tsx"],
+					env: { FORCE_COLOR: "3" },
+				},
+			},
+		],
 	},
 	resolve: {
 		alias: {

docs/cline-sdk/overview.md

@@ -0,0 +1,643 @@
+# 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).
+
+## Installation
+
+```bash
+npm install cline
+```
+
+If you want direct ACP type imports as well:
+
+```bash
+npm install @agentclientprotocol/sdk
+```
+
+Requires Node.js 20+.
+
+## Quick Start
+
+```typescript
+import { ClineAgent } from "cline"
+
+const agent = new ClineAgent({ version: "1.0.0" })
+
+// 1. Initialize — negotiates capabilities
+await agent.initialize({
+  protocolVersion: 1,
+  clientCapabilities: {},
+})
+
+// 2. Authenticate (if using Cline-hosted models)
+await agent.authenticate({ methodId: "cline-oauth" })
+
+// 3. Create a session
+const { sessionId } = await agent.newSession({
+  cwd: process.cwd(),
+  mcpServers: [],
+})
+
+// 4. Subscribe to streaming output
+const emitter = agent.emitterForSession(sessionId)
+
+emitter.on("agent_message_chunk", (payload) => {
+  process.stdout.write(payload.content.text)
+})
+
+emitter.on("tool_call", (payload) => {
+  console.log(`[tool] ${payload.title}`)
+})
+
+emitter.on("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" }],
+})
+
+console.log("Done:", stopReason)
+
+// 6. Clean up
+await agent.shutdown()
+```
+
+## Core Concepts
+
+### Agent Lifecycle
+
+The SDK follows the ACP lifecycle:
+
+```
+initialize() → authenticate() → newSession() → prompt() ⇄ events → shutdown()
+```
+
+| Step | Method | Purpose |
+|------|--------|---------|
+| Init | `initialize()` | Exchange protocol version and capabilities |
+| Auth | `authenticate()` | OAuth flow for Cline or OpenAI Codex accounts |
+| 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 |
+| Mode | `setSessionMode()` | Switch between `"plan"` and `"act"` modes |
+| Model | `unstable_setSessionModel()` | Change the backing LLM (experimental) |
+| Shutdown | `shutdown()` | Abort all tasks, flush state, release resources |
+
+### Sessions
+
+A session is an independent conversation with its own task history, working directory, and MCP server connections. 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"] },
+  ],
+})
+```
+
+The response includes:
+- `sessionId` — use this in all subsequent calls
+- `modes` — available modes (`plan`, `act`) and the current mode
+- `models` — available models and the current model ID
+
+Access session metadata via the read-only `sessions` map:
+
+```typescript
+const session = agent.sessions.get(sessionId)
+// { sessionId, cwd, mode, mcpServers, createdAt, lastActivityAt, ... }
+```
+
+### Prompting
+
+`prompt()` sends a user message and blocks until the agent finishes its turn. While the prompt is processing, the agent streams output via session events.
+
+```typescript
+const response = await agent.prompt({
+  sessionId,
+  prompt: [
+    { type: "text", text: "Refactor the auth module to use JWT" },
+  ],
+})
+```
+
+The prompt array accepts multiple content blocks:
+
+```typescript
+// Text + image + file context
+await agent.prompt({
+  sessionId,
+  prompt: [
+    { type: "text", text: "What's in this screenshot?" },
+    { type: "image", data: base64ImageData, mimeType: "image/png" },
+    {
+      type: "resource",
+      resource: {
+        uri: "file:///path/to/relevant-file.ts",
+        mimeType: "text/plain",
+        text: fileContents,
+      },
+    },
+  ],
+})
+```
+
+#### Content Block Types
+
+| Type | Fields | Description |
+|------|--------|-------------|
+| `TextContent` | `{ type: "text", text: string }` | Plain text message |
+| `ImageContent` | `{ type: "image", mimeType: string, data: string }` | Base64-encoded image |
+| `EmbeddedResource` | `{ type: "resource", resource: { uri: string, mimeType?: string, text?: string, blob?: string } }` | File or resource context |
+
+#### Stop Reasons
+
+`prompt()` resolves with a `stopReason`:
+
+| 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 |
+
+### Streaming Events
+
+Subscribe to real-time output via `ClineSessionEmitter`. Each session has its own emitter.
+
+```typescript
+const emitter = agent.emitterForSession(sessionId)
+```
+
+#### Event Types
+
+All events correspond to [ACP `SessionUpdate` types](https://agentclientprotocol.com/protocol/schema#SessionUpdate):
+
+| Event | Payload | Description |
+|-------|---------|-------------|
+| `agent_message_chunk` | `{ content: ContentBlock }` | Streamed text from the agent |
+| `agent_thought_chunk` | `{ content: ContentBlock }` | Internal reasoning / chain-of-thought |
+| `tool_call` | `ToolCall` | New tool invocation (file edit, command, etc.) |
+| `tool_call_update` | `ToolCallUpdate` | Progress/result update for an existing tool call |
+| `plan` | `{ entries: PlanEntry[] }` | Agent's execution plan |
+| `available_commands_update` | `{ availableCommands: AvailableCommand[] }` | Slash commands the agent supports |
+| `current_mode_update` | `{ currentModeId: string }` | Mode changed (plan/act) |
+| `user_message_chunk` | `{ content: ContentBlock }` | User message chunks (for multi-turn) |
+| `config_option_update` | `{ configOptions: SessionConfigOption[] }` | Configuration changed |
+| `session_info_update` | Session metadata | Session metadata changed |
+| `error` | `Error` | Session-level error (not an ACP update) |
+
+```typescript
+emitter.on("agent_message_chunk", (payload) => {
+  // payload.content is a ContentBlock — usually { type: "text", text: "..." }
+  process.stdout.write(payload.content.text)
+})
+
+emitter.on("agent_thought_chunk", (payload) => {
+  console.log("[thinking]", payload.content.text)
+})
+
+emitter.on("tool_call", (payload) => {
+  console.log(`[${payload.kind}] ${payload.title} (${payload.status})`)
+})
+
+emitter.on("tool_call_update", (payload) => {
+  console.log(`  → ${payload.toolCallId}: ${payload.status}`)
+})
+
+emitter.on("error", (err) => {
+  console.error("Session error:", err)
+})
+```
+
+The emitter supports `on`, `once`, `off`, and `removeAllListeners`.
+
+### Permission Handling
+
+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) => {
+  // request.toolCall — details about what the agent wants to do
+  // request.options — available choices (allow_once, reject_once, etc.)
+
+  console.log(`Permission requested: ${request.toolCall.title}`)
+  console.log("Options:", request.options.map(o => `${o.optionId} (${o.kind})`))
+
+  // Auto-approve everything:
+  const allowOption = request.options.find(o => o.kind === "allow_once")
+  if (allowOption) {
+    resolve({ outcome: { outcome: "selected", optionId: allowOption.optionId } })
+  } else {
+    resolve({ outcome: { outcome: "rejected" } })
+  }
+})
+```
+
+#### Permission Options
+
+Each permission request includes an array of `PermissionOption` objects:
+
+| `kind` | Meaning |
+|--------|---------|
+| `allow_once` | Approve this single operation |
+| `allow_always` | Approve and remember for future operations |
+| `reject_once` | Deny this single operation |
+| `reject_always` | Deny and remember for future operations |
+
+**Important:** If no permission handler is set, all tool calls are rejected for safety.
+
+### Modes
+
+Cline supports two modes:
+
+- **`plan`** — The agent gathers information and creates a plan without executing actions
+- **`act`** — The agent executes actions (file edits, commands, etc.)
+
+```typescript
+// Switch to plan mode
+await agent.setSessionMode({ sessionId, modeId: "plan" })
+
+// Switch back to act mode
+await agent.setSessionMode({ sessionId, modeId: "act" })
+```
+
+The current mode is returned in `newSession()` and emitted via `current_mode_update` events.
+
+### Model Selection
+
+Change the backing model with `unstable_setSessionModel()`. The model ID format is `"provider/modelId"`.
+
+```typescript
+await agent.unstable_setSessionModel({
+  sessionId,
+  modelId: "anthropic/claude-sonnet-4-20250514",
+})
+```
+
+This sets the model for both plan and act modes. Available providers include `anthropic`, `openai-native`, `gemini`, `bedrock`, `deepseek`, `mistral`, `groq`, `xai`, and others.
+
+> **Note:** This API is experimental and may change.
+
+### Authentication
+
+The SDK supports two OAuth flows:
+
+```typescript
+// Cline account (uses browser OAuth)
+await agent.authenticate({ methodId: "cline-oauth" })
+
+// OpenAI Codex / ChatGPT subscription
+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.
+
+### Cancellation
+
+Cancel an in-progress prompt turn:
+
+```typescript
+await agent.cancel({ sessionId })
+```
+
+The pending `prompt()` call will resolve with `{ stopReason: "cancelled" }`.
+
+## API Reference
+
+### Constructor
+
+```typescript
+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) */
+  clineDir?: string
+}
+```
+
+The `clineDir` option lets you isolate configuration and task history per-application:
+
+```typescript
+const agent = new ClineAgent({
+  version: "1.0.0",
+  clineDir: "/tmp/my-app-cline",
+})
+```
+
+### Methods
+
+#### `initialize(params): Promise<InitializeResponse>`
+
+Initialize the agent and negotiate protocol capabilities.
+
+```typescript
+const response = await agent.initialize({
+  clientCapabilities: {},
+  protocolVersion: 1,
+})
+
+// Response includes:
+{
+  protocolVersion: "0.9.0",
+  agentCapabilities: {
+    loadSession: true,
+    promptCapabilities: { image: true, audio: false, embeddedContext: true },
+    mcpCapabilities: { http: true, sse: false }
+  },
+  agentInfo: { name: "cline", version: "2.2.3" },
+  authMethods: [
+    { id: "cline-oauth", name: "Sign in with Cline", description: "..." },
+    { id: "openai-codex-oauth", name: "Sign in with ChatGPT", description: "..." }
+  ]
+}
+```
+
+#### `newSession(params): Promise<NewSessionResponse>`
+
+Create a new conversation session.
+
+```typescript
+const session = await agent.newSession({
+  cwd: "/path/to/project",
+  mcpServers: [
+    {
+      type: "stdio",
+      name: "filesystem",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
+      env: {},
+    },
+  ],
+})
+
+// Response includes:
+{
+  sessionId: "uuid-string",
+  modes: {
+    availableModes: [
+      { id: "plan", name: "Plan", description: "Gather information and create a detailed plan" },
+      { id: "act", name: "Act", description: "Execute actions to accomplish the task" }
+    ],
+    currentModeId: "act"
+  },
+  models: {
+    currentModelId: "anthropic/claude-sonnet-4-5-20241022",
+    availableModels: [{ modelId: "anthropic/claude-3-5-sonnet-20241022", name: "..." }]
+  }
+}
+```
+
+> **Note:** `newSession()` may throw an auth-required error if credentials are not configured yet.
+
+#### `prompt(params): Promise<PromptResponse>`
+
+Send a user prompt to the agent. This is the main method for interacting with Cline. Blocks until the agent finishes its turn.
+
+```typescript
+const response = await agent.prompt({
+  sessionId: session.sessionId,
+  prompt: [
+    { type: "text", text: "Create a function that adds two numbers" },
+  ],
+})
+
+// Response: { stopReason: "end_turn" | "max_tokens" | "cancelled" | "error" }
+```
+
+#### `cancel(params): Promise<void>`
+
+Cancel an ongoing prompt operation.
+
+```typescript
+await agent.cancel({ sessionId: session.sessionId })
+```
+
+#### `setSessionMode(params): Promise<SetSessionModeResponse>`
+
+Switch between plan and act modes.
+
+```typescript
+await agent.setSessionMode({ sessionId, modeId: "plan" })
+```
+
+#### `unstable_setSessionModel(params): Promise<SetSessionModelResponse>`
+
+Change the model for the session. Model ID format: `"provider/modelId"`.
+
+```typescript
+await agent.unstable_setSessionModel({
+  sessionId,
+  modelId: "anthropic/claude-sonnet-4-20250514",
+})
+```
+
+#### `authenticate(params): Promise<AuthenticateResponse>`
+
+Authenticate with a provider. Opens a browser window for OAuth flow.
+
+```typescript
+await agent.authenticate({ methodId: "cline-oauth" })
+```
+
+#### `shutdown(): Promise<void>`
+
+Clean up all resources. Call this when done.
+
+```typescript
+await agent.shutdown()
+```
+
+#### `setPermissionHandler(handler)`
+
+Set a callback to handle tool permission requests.
+
+```typescript
+agent.setPermissionHandler((request, resolve) => {
+  resolve({ outcome: { outcome: "selected", optionId: "allow_once" } })
+})
+```
+
+#### `emitterForSession(sessionId): ClineSessionEmitter`
+
+Get the typed event emitter for a session.
+
+```typescript
+const emitter = agent.emitterForSession(session.sessionId)
+```
+
+#### `sessions` (read-only Map)
+
+Access active sessions:
+
+```typescript
+for (const [sessionId, session] of agent.sessions) {
+  console.log(sessionId, session.cwd, session.mode)
+}
+```
+
+## Full Example: Auto-Approve Agent
+
+```typescript
+import { ClineAgent } from "cline"
+
+async function runTask(task: string, cwd: string) {
+  const agent = new ClineAgent({ version: "1.0.0" })
+
+  await agent.initialize({
+    protocolVersion: 1,
+    clientCapabilities: {},
+  })
+
+  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" },
+    })
+  })
+
+  // 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("tool_call", (p) => {
+    console.log(`[tool] ${p.title}`)
+  })
+
+  const { stopReason } = await agent.prompt({
+    sessionId,
+    prompt: [{ type: "text", text: task }],
+  })
+
+  console.log("\n--- Agent Output ---")
+  console.log(output.join(""))
+  console.log(`\nStop reason: ${stopReason}`)
+
+  await agent.shutdown()
+}
+
+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"
+
+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}`)
+
+  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]
+
+  if (selected) {
+    resolve({ outcome: { outcome: "selected", optionId: selected.optionId } })
+  } else {
+    resolve({ outcome: { outcome: "rejected" } })
+  }
+}
+
+async function main() {
+  const agent = new ClineAgent({ version: "1.0.0" })
+  await agent.initialize({ protocolVersion: 1, clientCapabilities: {} })
+
+  const { sessionId } = await agent.newSession({
+    cwd: process.cwd(),
+    mcpServers: [],
+  })
+
+  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)
+  })
+
+  // 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 }],
+    })
+
+    console.log(`\n[${stopReason}]`)
+  }
+
+  await agent.shutdown()
+  rl.close()
+}
+
+main()
+```
+
+## Exported Types
+
+All types are re-exported from the `cline` package. Key types:
+
+| Type | Description |
+|------|-------------|
+| `ClineAgent` | Main agent class |
+| `ClineSessionEmitter` | Typed event emitter for session events |
+| `ClineAgentOptions` | Constructor options |
+| `ClineAcpSession` | Session metadata (read-only) |
+| `ClineSessionEvents` | Event name → handler signature map |
+| `PermissionHandler` | `(request, resolve) => void` callback |
+| `PermissionResolver` | `(response) => void` callback |
+| `SessionUpdate` | Union of all session update types |
+| `SessionUpdateType` | Discriminator values (`"agent_message_chunk"`, `"tool_call"`, etc.) |
+| `ToolCall` | Tool call details (id, title, kind, status, content) |
+| `ToolCallUpdate` | Partial update to an existing tool call |
+| `ToolCallStatus` | `"pending" \| "in_progress" \| "completed" \| "failed"` |
+| `ToolKind` | `"read" \| "edit" \| "delete" \| "execute" \| "search" \| ...` |
+| `StopReason` | `"end_turn" \| "cancelled" \| "error" \| "max_tokens" \| ...` |
+| `ContentBlock` | `TextContent \| ImageContent \| AudioContent \| ...` |
+| `McpServer` | MCP server configuration (stdio, http) |
+| `PromptRequest` / `PromptResponse` | Prompt call types |
+| `NewSessionRequest` / `NewSessionResponse` | Session creation types |
+| `InitializeRequest` / `InitializeResponse` | Initialization types |
+
+See the [ACP Schema](https://agentclientprotocol.com/protocol/schema) for the full type definitions.
+
+## Relationship to ACP
+
+The Cline SDK implements the [Agent Client Protocol](https://agentclientprotocol.com) `Agent` interface. The key difference from a standard ACP stdio agent is that the SDK uses an **event emitter pattern** instead of a transport connection:
+
+| ACP Stdio (via `AcpAgent`) | SDK (via `ClineAgent`) |
+|-----------------------------|------------------------|
+| Session updates sent over JSON-RPC stdio | Session updates emitted via `ClineSessionEmitter` |
+| Permissions requested via `connection.requestPermission()` | Permissions requested via `setPermissionHandler()` callback |
+| Single process, single connection | Embeddable, multiple concurrent sessions |
+
+If you need stdio-based ACP communication (e.g., for IDE integration), use the `cline` CLI binary directly. The SDK is for embedding Cline in your own Node.js processes.

docs/docs.json

@@ -286,7 +286,8 @@
 							{
 								"group": "Control Other Cline Features",
 								"pages": [
-									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode"
+									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode",
+									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-marketplace"
 								]
 							},
 							{

docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/mcp-marketplace.mdx

@@ -0,0 +1,298 @@
+---
+title: "MCP Marketplace"
+sidebarTitle: "MCP Marketplace"
+description: "Enterprise controls for MCP Marketplace access, server allowlisting, and remote MCP server management"
+---
+
+The MCP Marketplace lets developers discover and install MCP servers that extend Cline's capabilities. For Enterprise administrators, this page covers how to control marketplace access, restrict which servers are available, and push pre-configured MCP servers to your organization.
+
+<Note>
+For complete details about the MCP Marketplace and how developers use it, see [MCP Made Easy](/mcp/mcp-marketplace).
+</Note>
+
+## Overview
+
+Enterprise administrators have four configuration options to govern MCP server usage across their organization:
+
+| Setting | Purpose |
+|---------|---------|
+| `mcpMarketplaceEnabled` | Enable or disable the MCP Marketplace entirely |
+| `allowedMCPServers` | Restrict the marketplace to only approved MCP servers |
+| `remoteMCPServers` | Push pre-configured remote MCP servers to all users |
+| `blockPersonalRemoteMCPServers` | Prevent users from adding their own remote MCP servers |
+
+These settings are applied through your organization's [remote configuration](/enterprise-solutions/configuration/remote-configuration/overview) and take effect immediately for all team members.
+
+## Disabling the MCP Marketplace
+
+To completely disable the MCP Marketplace for your organization, set `mcpMarketplaceEnabled` to `false`:
+
+```json
+{
+  "mcpMarketplaceEnabled": false
+}
+```
+
+When `mcpMarketplaceEnabled` is set to `false`:
+- The MCP Marketplace tab is hidden from all users
+- Users cannot browse or install MCP servers from the marketplace
+- Locally configured MCP servers are blocked
+- Enterprise policy takes precedence over individual preferences
+
+When `mcpMarketplaceEnabled` is set to `true` or omitted:
+- Users can freely browse and install MCP servers from the marketplace
+- No organizational restrictions apply to marketplace access
+
+<Warning>
+Disabling the marketplace entirely also blocks locally configured MCP servers. If you want to allow specific servers while restricting others, use the allowlist approach described below instead.
+</Warning>
+
+## Restricting the Marketplace to Approved Servers
+
+Rather than disabling the marketplace entirely, you can restrict it to a curated list of approved MCP servers using the `allowedMCPServers` setting. This is the recommended approach for most enterprises — it lets developers benefit from MCP while ensuring only vetted servers are available.
+
+### Configuration
+
+Add an `allowedMCPServers` array to your remote configuration. Each entry requires an `id` field set to the server's GitHub repository path:
+
+```json
+{
+  "allowedMCPServers": [
+    { "id": "github.com/modelcontextprotocol/server-filesystem" },
+    { "id": "github.com/modelcontextprotocol/server-github" },
+    { "id": "github.com/your-org/internal-mcp-server" }
+  ]
+}
+```
+
+### How It Works
+
+When `allowedMCPServers` is configured:
+- The marketplace catalog is filtered to show **only** the servers in your allowlist
+- Users can browse, view details, and install any server on the list
+- Servers not on the list are completely hidden from the marketplace
+- The allowlist applies to all team members in the organization
+
+When `allowedMCPServers` is omitted or `undefined`:
+- The full marketplace catalog is available with no restrictions
+
+When `allowedMCPServers` is set to an empty array (`[]`):
+- The marketplace shows no servers — effectively disabling installation while keeping the UI visible
+
+### Finding Server IDs
+
+The `id` for each allowed server is its GitHub repository path (without the `https://` prefix). For example:
+
+| Server | ID |
+|--------|----|
+| Filesystem | `github.com/modelcontextprotocol/server-filesystem` |
+| GitHub | `github.com/modelcontextprotocol/server-github` |
+| Custom internal server | `github.com/your-org/your-mcp-server` |
+
+You can find the correct ID by checking the `githubUrl` field of any server in the [MCP Marketplace](/mcp/mcp-marketplace) and removing the `https://` prefix.
+
+## Pushing Pre-Configured Remote MCP Servers
+
+Use `remoteMCPServers` to push MCP servers directly to all users without requiring them to install anything from the marketplace. This is ideal for internal MCP servers or third-party servers that need specific configuration.
+
+### Configuration
+
+```json
+{
+  "remoteMCPServers": [
+    {
+      "name": "Internal Code Search",
+      "url": "https://mcp.internal.yourcompany.com/code-search",
+      "alwaysEnabled": true,
+      "headers": {
+        "Authorization": "Bearer ${AUTH_TOKEN}"
+      }
+    },
+    {
+      "name": "Documentation Server",
+      "url": "https://mcp.internal.yourcompany.com/docs",
+      "alwaysEnabled": false
+    }
+  ]
+}
+```
+
+### Remote Server Options
+
+Each remote MCP server entry supports the following fields:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `name` | string | Yes | Display name for the server |
+| `url` | string | Yes | The URL endpoint of the MCP server |
+| `alwaysEnabled` | boolean | No | When `true`, users cannot disable this server |
+| `headers` | object | No | Custom HTTP headers for authentication |
+
+### Always-Enabled Servers
+
+When `alwaysEnabled` is set to `true`:
+- The server is automatically active for all users
+- Users cannot toggle the server off
+- The server appears in the user's MCP configuration but the disable control is locked
+- This is useful for compliance, security, or internal tooling servers that must always be available
+
+## Blocking Personal Remote MCP Servers
+
+To prevent users from adding their own remote MCP servers, set `blockPersonalRemoteMCPServers` to `true`:
+
+```json
+{
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+When `blockPersonalRemoteMCPServers` is `true`:
+- Users cannot add or configure remote MCP servers on their own
+- Only servers defined in the organization's `remoteMCPServers` configuration are available
+- This ensures all remote MCP connections go through approved, organization-managed endpoints
+
+When `blockPersonalRemoteMCPServers` is `false` or omitted:
+- Users can freely add their own remote MCP server connections
+
+## Combined Configuration Examples
+
+### Locked-Down Environment
+
+For organizations that need strict control over all MCP server access:
+
+```json
+{
+  "mcpMarketplaceEnabled": true,
+  "allowedMCPServers": [
+    { "id": "github.com/modelcontextprotocol/server-filesystem" },
+    { "id": "github.com/modelcontextprotocol/server-github" }
+  ],
+  "remoteMCPServers": [
+    {
+      "name": "Internal API Gateway",
+      "url": "https://mcp.internal.yourcompany.com/gateway",
+      "alwaysEnabled": true,
+      "headers": {
+        "X-Api-Key": "org-managed-key"
+      }
+    }
+  ],
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+This configuration:
+- Allows the marketplace but limits it to two approved servers
+- Pushes an always-enabled internal MCP server to all users
+- Blocks users from adding their own remote MCP servers
+
+### Open Environment with Internal Servers
+
+For organizations that want flexibility with internal server access:
+
+```json
+{
+  "remoteMCPServers": [
+    {
+      "name": "Company Knowledge Base",
+      "url": "https://mcp.yourcompany.com/kb",
+      "alwaysEnabled": true
+    }
+  ]
+}
+```
+
+This configuration:
+- Leaves the full marketplace open (no `allowedMCPServers` restriction)
+- Ensures all developers have access to the company knowledge base
+- Allows users to add their own remote MCP servers
+
+### Marketplace Disabled with Internal Servers Only
+
+For organizations that want to fully manage the MCP experience:
+
+```json
+{
+  "mcpMarketplaceEnabled": false,
+  "remoteMCPServers": [
+    {
+      "name": "Approved Code Assistant",
+      "url": "https://mcp.internal.yourcompany.com/code-assist",
+      "alwaysEnabled": true
+    },
+    {
+      "name": "Internal Docs Search",
+      "url": "https://mcp.internal.yourcompany.com/docs",
+      "alwaysEnabled": true
+    }
+  ],
+  "blockPersonalRemoteMCPServers": true
+}
+```
+
+This configuration:
+- Disables the marketplace completely
+- Provides only organization-managed MCP servers
+- Prevents users from adding any additional remote servers
+
+## Enterprise Policy Recommendations
+
+### Recommended Approach
+
+Most organizations should **use the allowlist** (`allowedMCPServers`) rather than disabling the marketplace entirely. This gives developers access to useful tools while ensuring security review of each server.
+
+<AccordionGroup>
+  <Accordion title="Security Review Process" icon="shield">
+    Before adding an MCP server to your allowlist:
+    - Review the server's source code on GitHub
+    - Evaluate the server's permissions and data access patterns
+    - Check for active maintenance and security practices
+    - Assess whether the server's data handling meets your compliance requirements
+    - Test the server in a sandbox environment before approving
+  </Accordion>
+
+  <Accordion title="Internal MCP Servers" icon="building">
+    For internal tooling, use `remoteMCPServers` with `alwaysEnabled: true`:
+    - Connect Cline to internal APIs, databases, and knowledge bases
+    - Ensure consistent access across all developers
+    - Manage authentication centrally through custom headers
+    - Use `blockPersonalRemoteMCPServers` to prevent shadow IT
+  </Accordion>
+
+  <Accordion title="Compliance Considerations" icon="clipboard-check">
+    MCP servers can access external APIs and process data:
+    - Audit which servers handle sensitive data
+    - Ensure servers comply with your data residency requirements
+    - Document approved servers in your security policies
+    - Regularly review and update your allowlist
+  </Accordion>
+</AccordionGroup>
+
+### Recommendations by Organization Size
+
+#### Small Teams (5–20 developers)
+- **Marketplace:** Open or lightly restricted with an allowlist
+- **Remote Servers:** Push internal servers as needed
+- **Personal Servers:** Allow with guidance
+- **Review Cadence:** Quarterly allowlist review
+
+#### Medium Organizations (20–100 developers)
+- **Marketplace:** Restricted to an approved allowlist
+- **Remote Servers:** Push internal servers with `alwaysEnabled`
+- **Personal Servers:** Consider blocking (`blockPersonalRemoteMCPServers: true`)
+- **Review Cadence:** Monthly allowlist review
+
+#### Large Enterprises (100+ developers)
+- **Marketplace:** Strictly restricted to a vetted allowlist
+- **Remote Servers:** All MCP access through organization-managed servers
+- **Personal Servers:** Blocked (`blockPersonalRemoteMCPServers: true`)
+- **Review Cadence:** Formal approval process for new servers with security review
+
+## Support & Questions
+
+For help configuring MCP Marketplace policies:
+- Review [Remote Configuration Overview](/enterprise-solutions/configuration/remote-configuration/overview)
+- See [MCP Made Easy](/mcp/mcp-marketplace) for marketplace functionality details
+- See [MCP Overview](/mcp/mcp-overview) for general MCP concepts
+- Contact your Enterprise support representative
+- Join our [Discord](https://discord.gg/cline) for community discussion

docs/enterprise-solutions/sso-setup.mdx

@@ -9,7 +9,21 @@ Cline Enterprise integrates with your identity provider (IdP) via **WorkOS AuthK
 
 This page describes, at a high level, how SSO is set up for Cline Enterprise using WorkOS AuthKit.
 
-If you haven’t completed initial onboarding, start with [Onboarding](/enterprise-solutions/onboarding).
+If you haven't completed initial onboarding, start with [Onboarding](/enterprise-solutions/onboarding).
+
+### Video Walkthrough
+
+<Frame>
+  <iframe
+    src="https://www.youtube.com/embed/QC7mzXLjIH8"
+    title="SSO Setup with WorkOS"
+    width="100%"
+    style={{ aspectRatio: "16/9" }}
+    frameBorder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowFullScreen
+  />
+</Frame>
 
 ## Where setup happens
 SSO setup spans two places:

docs/features/dictation.mdx

@@ -1,48 +0,0 @@
----
-title: "Dictation (Deprecated)"
-description: "Voice input feature has been removed from Cline"
----
-
-# Dictation Feature Removed
-
-The dictation (voice-to-text) feature has been removed from Cline as of this release.
-
-## What Happened?
-
-The voice input feature that allowed you to speak to Cline instead of typing has been discontinued and is no longer available in the extension.
-
-## Alternative Workflows
-
-While the built-in dictation feature is no longer available, you can still work efficiently with Cline using these approaches:
-
-### 1. System-Level Voice Input
-
-Both macOS and Windows offer built-in dictation features that work across all applications:
-
-- **macOS**: Press `Fn` twice (or `Fn Fn`) to activate dictation in any text field
-- **Windows**: Press `Windows + H` to open voice typing
-- **Linux**: Various desktop environments offer voice input through accessibility features
-
-These system-level tools will work in Cline's chat input just like any other text field.
-
-### 2. Copy-Paste from Voice Notes
-
-If you prefer to think out loud:
-1. Use your phone's voice recorder or a voice memo app
-2. Transcribe using your preferred tool (many phones have built-in transcription)
-3. Copy and paste the transcribed text into Cline
-
-### 3. Third-Party Transcription Tools
-
-Many standalone transcription tools can be used alongside Cline:
-- Browser-based transcription services
-- Desktop transcription applications
-- AI-powered note-taking apps with transcription features
-
-## Why Was It Removed?
-
-The dictation feature was removed to streamline Cline's core functionality and focus development efforts on the primary AI assistance capabilities.
-
-## Questions?
-
-If you have questions about this change or need help setting up alternative voice input methods, please reach out through Cline's support channels.

docs/provider-config/minimax.mdx

@@ -1,6 +1,6 @@
 ---
 title: "MiniMax"
-description: "Learn how to configure and use MiniMax models with Cline. Access MiniMax-M2 series models with large context windows and prompt caching."
+description: "Learn how to configure and use MiniMax models with Cline. Access MiniMax-M2 series models with large context windows, prompt caching, and reasoning support."
 ---
 
 MiniMax provides AI models with large context windows and competitive pricing, featuring the MiniMax-M2 series.
@@ -18,9 +18,10 @@ MiniMax provides AI models with large context windows and competitive pricing, f
 
 Cline supports the following MiniMax models:
 
--   `MiniMax-M2.1` (Default) - Latest model with 192K context and prompt caching ($0.30/$1.20 per 1M tokens)
+-   `MiniMax-M2.5` (Default) - Latest model with 192K context, prompt caching, and reasoning/thinking support ($0.30/$1.20 per 1M tokens)
+-   `MiniMax-M2.1` - Previous generation with 192K context and prompt caching ($0.30/$1.20 per 1M tokens)
 -   `MiniMax-M2.1-lightning` - Fast variant with higher output pricing ($0.30/$2.40 per 1M tokens)
--   `MiniMax-M2` - Previous generation with 192K context ($0.30/$1.20 per 1M tokens)
+-   `MiniMax-M2` - Earlier generation with 192K context ($0.30/$1.20 per 1M tokens)
 
 ### Configuration in Cline
 
@@ -32,5 +33,6 @@ Cline supports the following MiniMax models:
 ### Tips and Notes
 
 -   **Large Context:** All models support 192K token context windows.
--   **Prompt Caching:** M2.1 models support prompt caching for reduced costs on repeated queries.
+-   **Reasoning Support:** M2.5 supports extended thinking/reasoning for complex tasks.
+-   **Prompt Caching:** M2.5 and M2.1 models support prompt caching for reduced costs on repeated queries.
 -   **Pricing:** Check the [MiniMax pricing page](https://www.minimax.io/platform/document/pricing) for current rates.

docs/provider-config/sambanova.mdx

@@ -14,29 +14,6 @@ SambaNova provides fast AI inference on custom-built hardware, hosting popular o
 3.  **Create a Key:** Generate a new API key.
 4.  **Copy the Key:** Copy the API key immediately and store it securely.
 
-### Supported Models
-
-Cline supports the following SambaNova models:
-
-#### Meta Llama Models
--   `Llama-4-Maverick-17B-128E-Instruct` - Llama 4 Maverick with vision support ($0.63/$1.80 per 1M tokens)
--   `Llama-4-Scout-17B-16E-Instruct` - Llama 4 Scout ($0.40/$0.70 per 1M tokens)
--   `Meta-Llama-3.3-70B-Instruct` (Default) - Versatile 70B model with 128K context ($0.60/$1.20 per 1M tokens)
--   `Meta-Llama-3.1-405B-Instruct` - Largest Llama model ($5.00/$10.00 per 1M tokens)
--   `Meta-Llama-3.1-8B-Instruct` - Compact 8B model ($0.10/$0.20 per 1M tokens)
--   `Meta-Llama-3.2-1B-Instruct` - Ultra-compact 1B model ($0.04/$0.08 per 1M tokens)
--   `Meta-Llama-3.2-3B-Instruct` - Small 3B model ($0.08/$0.16 per 1M tokens)
-
-#### DeepSeek Models
--   `DeepSeek-R1` - Reasoning model ($5.00/$7.00 per 1M tokens)
--   `DeepSeek-R1-Distill-Llama-70B` - Distilled reasoning model ($0.70/$1.40 per 1M tokens)
--   `DeepSeek-V3-0324` - General-purpose model ($3.00/$4.50 per 1M tokens)
--   `DeepSeek-V3.1` - Latest DeepSeek with hybrid reasoning ($3.00/$4.50 per 1M tokens)
-
-#### Qwen Models
--   `Qwen3-32B` - Dense 32B model ($0.40/$0.80 per 1M tokens)
--   `QwQ-32B` - Reasoning-focused Qwen model ($0.50/$1.00 per 1M tokens)
-
 ### Configuration in Cline
 
 1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.

locales/ko/CONTRIBUTING.md

@@ -56,15 +56,10 @@ Cline에 기여하는 것에 관심을 가져주셔서 감사합니다! 버그
     - 변경사항이 기존 테스트에 영향을 미치는 경우 해당 테스트를 업데이트해 주세요
     - 적절한 경우 단위 테스트와 통합 테스트를 모두 포함해 주세요
 
-4. **Changesets를 활용한 버전 관리**
+4. **버전/릴리스 노트 관리**
 
-    - 사용자에게 영향을 미치는 변경 사항이 있는 경우, `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이 필요하지 않습니다
+    - 기여자는 PR에서 changelog-entry 파일을 만들 필요가 없습니다.
+    - 릴리스 버전 관리와 CHANGELOG 정리는 메인테이너가 릴리스 과정에서 수행합니다.
 
 5. **커밋 가이드라인**
 

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.66.0",
+	"version": "3.67.1",
 	"icon": "assets/icons/icon.png",
 	"workspaces": [
 		".",
@@ -437,8 +437,6 @@
 		"publish:marketplace:prerelease": "vsce publish --allow-package-secrets sendgrid --pre-release && ovsx publish --pre-release",
 		"publish:marketplace:nightly": "node ./scripts/publish-nightly.mjs",
 		"prepare": "npx husky",
-		"changeset": "changeset",
-		"version-packages": "changeset version",
 		"docs": "cd docs && npm run dev",
 		"docs:check-links": "cd docs && npm run check",
 		"docs:rename-file": "cd docs && npm run rename",
@@ -462,7 +460,6 @@
 	"devDependencies": {
 		"@biomejs/biome": "^2.3.14",
 		"@bufbuild/buf": "^1.54.0",
-		"@changesets/cli": "^2.27.12",
 		"@types/better-sqlite3": "^7.6.13",
 		"@types/chai": "^5.0.1",
 		"@types/clone-deep": "^4.0.4",

proto/cline/dictation.proto

@@ -1,44 +0,0 @@
-syntax = "proto3";
-
-package cline;
-
-import "cline/common.proto";
-
-option go_package = "github.com/cline/grpc-go/cline";
-option java_multiple_files = true;
-option java_package = "bot.cline.proto";
-
-service DictationService {
-  rpc startRecording(EmptyRequest) returns (RecordingResult);
-  rpc stopRecording(EmptyRequest) returns (RecordedAudio);
-  rpc cancelRecording(EmptyRequest) returns (RecordingResult);
-  rpc getRecordingStatus(EmptyRequest) returns (RecordingStatus);
-  rpc transcribeAudio(TranscribeAudioRequest) returns (Transcription);
-}
-
-message TranscribeAudioRequest {
-  string audio_base64 = 2;
-  string language = 3;
-}
-
-message RecordingResult {
-  bool success = 1;
-  string error = 2;
-}
-
-message RecordedAudio {
-  bool success = 1;
-  string audio_base64 = 2;
-  string error = 3;
-}
-
-message RecordingStatus {
-  bool is_recording = 1;
-  double duration_seconds = 2;
-  string error = 3;
-}
-
-message Transcription {
-  string text = 1;
-  string error = 2;
-}

proto/cline/models.proto

@@ -19,6 +19,8 @@ service ModelsService {
   rpc getVsCodeLmModels(EmptyRequest) returns (VsCodeLmModelsArray);
   // Refreshes and returns OpenRouter models
   rpc refreshOpenRouterModelsRpc(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  // Refreshes and returns recommended and free Cline models
+  rpc refreshClineRecommendedModelsRpc(EmptyRequest) returns (ClineRecommendedModelsResponse);
   // Refreshes and returns Hugging Face models
   rpc refreshHuggingFaceModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns OpenAI models
@@ -113,6 +115,18 @@ message OpenRouterCompatibleModelInfo {
   map<string, OpenRouterModelInfo> models = 1;
 }
 
+message ClineRecommendedModel {
+  string id = 1;
+  string name = 2;
+  string description = 3;
+  repeated string tags = 4;
+}
+
+message ClineRecommendedModelsResponse {
+  repeated ClineRecommendedModel recommended = 1;
+  repeated ClineRecommendedModel free = 2;
+}
+
 // Request for fetching OpenAI models
 message OpenAiModelsRequest {
   Metadata metadata = 1;
@@ -448,6 +462,7 @@ enum ApiFormat {
   OPENAI_CHAT = 2;
   R1_CHAT = 3;
   OPENAI_RESPONSES = 4;
+  OPENAI_RESPONSES_WEBSOCKET_MODE = 5;
 }
 
 // Model info for OpenAI-compatible models

proto/cline/state.proto

@@ -104,7 +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 openai_codex_oauth_credentials = 47;
+  optional string openai_codex_oauth_credentials = 48;
 }
 
 // NOTE: Add new fields under API_HANDLER_SETTINGS_FIELDS or USER_SETTINGS_FIELDS
@@ -255,7 +255,6 @@ message Settings {
   optional bool cline_web_tools_enabled = 144;
   optional string preferred_language = 145;
   optional PlanActMode mode = 147;
-  optional DictationSettings dictation_settings = 148;
   optional FocusChainSettings focus_chain_settings = 149;
   optional string custom_prompt = 150;
   optional bool subagents_enabled = 153;
@@ -282,11 +281,6 @@ message Settings {
   map<string, string> open_ai_headers = 177;
 }
 
-message DictationSettings {
-  bool feature_enabled = 1;
-  bool dictation_enabled = 2;
-  string dictation_language = 3;
-}
 message State {
   string state_json = 1;
 }
@@ -387,6 +381,7 @@ message UpdateTaskSettingsRequest {
 // Message for updating settings
 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)
 
@@ -410,7 +405,6 @@ message UpdateSettingsRequest {
   optional BrowserSettingsUpdate browser_settings = 20;
   optional string default_terminal_profile = 21;
   optional bool yolo_mode_toggled = 22;
-  optional DictationSettings dictation_settings = 23;
   optional bool multi_root_enabled = 25;
   optional string vscode_terminal_execution_mode = 27;
   optional int32 max_consecutive_mistakes = 28;

scripts/generate-state-proto.mjs

@@ -82,7 +82,6 @@ function inferProtoType(typeText, fieldName) {
 		// Other types - order matters for substring matching
 		["AutoApprovalSettings", "AutoApprovalSettings"],
 		["BrowserSettings", "BrowserSettings"],
-		["DictationSettings", "DictationSettings"],
 		["FocusChainSettings", "FocusChainSettings"],
 		["OpenaiReasoningEffort", "OpenaiReasoningEffort"],
 		["PlanActMode", "PlanActMode"],

src/common.ts

@@ -9,8 +9,8 @@ import { clearOnboardingModelsCache } from "./core/controller/models/getClineOnb
 import { HookDiscoveryCache } from "./core/hooks/HookDiscoveryCache"
 import { HookProcessRegistry } from "./core/hooks/HookProcessRegistry"
 import { StateManager } from "./core/storage/StateManager"
+import { AgentConfigLoader } from "./core/task/tools/subagent/AgentConfigLoader"
 import { ExtensionRegistryInfo } from "./registry"
-import { audioRecordingService } from "./services/dictation/AudioRecordingService"
 import { ErrorService } from "./services/error"
 import { featureFlagsService } from "./services/feature-flags"
 import { getDistinctId } from "./services/logging/distinctId"
@@ -151,9 +151,7 @@ async function checkWorktreeAutoOpen(stateManager: StateManager): Promise<void>
  * Performs cleanup when Cline is deactivated that is common to all platforms.
  */
 export async function tearDown(): Promise<void> {
-	// Clean up audio recording service to ensure no orphaned processes
-	audioRecordingService.cleanup()
-
+	AgentConfigLoader.getInstance()?.dispose()
 	PostHogClientProvider.getInstance().dispose()
 	telemetryService.dispose()
 	ErrorService.get().dispose()

src/core/api/index.ts

@@ -428,6 +428,8 @@ function createHandlerForProvider(
 				minimaxApiKey: options.minimaxApiKey,
 				minimaxApiLine: options.minimaxApiLine,
 				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "hicap":
 			return new HicapHandler({

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

@@ -0,0 +1,59 @@
+import "should"
+import { openRouterDefaultModelInfo } from "@shared/api"
+import sinon from "sinon"
+import { ClineHandler } from "../cline"
+
+describe("ClineHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	it("should handle usage-only chunks when delta is missing", async () => {
+		const handler = Object.create(ClineHandler.prototype) as ClineHandler
+		;(handler as any).options = {}
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 17,
+									completion_tokens: 9,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").resolves(fakeClient as any)
+		sinon.stub(handler, "getModel").returns({
+			id: "openai/gpt-4o-mini",
+			info: openRouterDefaultModelInfo,
+		})
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				cacheWriteTokens: 0,
+				cacheReadTokens: 0,
+				inputTokens: 17,
+				outputTokens: 9,
+				totalCost: 0,
+			},
+		])
+	})
+})

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

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

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

@@ -46,6 +46,8 @@ describe("LiteLlmHandler", () => {
 	}
 
 	beforeEach(() => {
+		fakeClient.chat.completions.create.resetHistory()
+
 		mockFetchForTesting(mockFetch, () => {
 			return new Promise((resolve) => {
 				doneMockingFetch = resolve

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

@@ -0,0 +1,60 @@
+import "should"
+import { openRouterDefaultModelInfo } from "@shared/api"
+import sinon from "sinon"
+import { OpenRouterHandler } from "../openrouter"
+
+describe("OpenRouterHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
+	it("should handle usage-only chunks when delta is missing", async () => {
+		const handler = new OpenRouterHandler({
+			openRouterApiKey: "test-api-key",
+		})
+		const fakeClient = {
+			chat: {
+				completions: {
+					create: sinon.stub().resolves(
+						createAsyncIterable([
+							{
+								choices: [{}],
+								usage: {
+									prompt_tokens: 13,
+									completion_tokens: 5,
+								},
+							},
+						]),
+					),
+				},
+			},
+		}
+		sinon.stub(handler as any, "ensureClient").returns(fakeClient as any)
+		sinon.stub(handler, "getModel").returns({
+			id: "openai/gpt-4o-mini",
+			info: openRouterDefaultModelInfo,
+		})
+
+		const chunks: any[] = []
+		for await (const chunk of handler.createMessage("system", [{ role: "user", content: "hi" }])) {
+			chunks.push(chunk)
+		}
+
+		chunks.should.deepEqual([
+			{
+				type: "usage",
+				cacheWriteTokens: 0,
+				cacheReadTokens: 0,
+				inputTokens: 13,
+				outputTokens: 5,
+				totalCost: 0,
+			},
+		])
+	})
+})

src/core/api/providers/__tests__/vercel-ai-gateway.test.ts

@@ -1,8 +1,19 @@
 import "should"
 import { openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
+import sinon from "sinon"
 import { VercelAIGatewayHandler } from "../vercel-ai-gateway"
 
 describe("VercelAIGatewayHandler", () => {
+	afterEach(() => {
+		sinon.restore()
+	})
+
+	const createAsyncIterable = (data: any[] = []) => ({
+		[Symbol.asyncIterator]: async function* () {
+			yield* data
+		},
+	})
+
 	describe("getModel", () => {
 		it("should return configured model and info when both are provided", () => {
 			const customModelInfo = {
@@ -38,4 +49,46 @@ describe("VercelAIGatewayHandler", () => {
 			result.info.should.deepEqual(openRouterDefaultModelInfo)
 		})
 	})
+
+	describe("createMessage", () => {
+		it("should handle usage-only chunks when delta is missing", async () => {
+			const handler = new VercelAIGatewayHandler({
+				vercelAiGatewayApiKey: "test-api-key",
+			})
+			const fakeClient = {
+				chat: {
+					completions: {
+						create: sinon.stub().resolves(
+							createAsyncIterable([
+								{
+									choices: [{}],
+									usage: {
+										prompt_tokens: 11,
+										completion_tokens: 7,
+									},
+								},
+							]),
+						),
+					},
+				},
+			}
+			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",
+					cacheWriteTokens: 0,
+					cacheReadTokens: 0,
+					inputTokens: 11,
+					outputTokens: 7,
+					totalCost: 0,
+				},
+			])
+		})
+	})
 })

src/core/api/providers/cerebras.ts

@@ -84,7 +84,8 @@ export class CerebrasHandler implements ApiHandler {
 							.map((block) => {
 								if (block.type === "text") {
 									return block.text
-								} else if (block.type === "image") {
+								}
+								if (block.type === "image") {
 									return "[Image content not supported in Cerebras]"
 								}
 								return ""
@@ -195,14 +196,18 @@ export class CerebrasHandler implements ApiHandler {
 				// Rate limit error - will be handled by retry decorator with patient backoff
 				const _limits = this.getRateLimits()
 				throw new Error(`Cerebras API rate limit exceeded.`)
-			} else if (error?.status === 401) {
+			}
+			if (error?.status === 401) {
 				throw new Error("Cerebras API authentication failed. Please check your API key.")
-			} else if (error?.status === 403) {
+			}
+			if (error?.status === 403) {
 				throw new Error("Cerebras API access denied. Please check your API key permissions.")
-			} else if (error?.status >= 500) {
+			}
+			if (error?.status >= 500) {
 				// Server errors - retryable
 				throw new Error(`Cerebras API server error (${error.status}): ${error.message || "Unknown server error"}`)
-			} else if (error?.status === 400) {
+			}
+			if (error?.status === 400) {
 				// Client errors - not retryable
 				throw new Error(`Cerebras API bad request: ${error.message || "Invalid request parameters"}`)
 			}

src/core/api/providers/cline.ts

@@ -168,7 +168,12 @@ export class ClineHandler implements ApiHandler {
 
 				// Reasoning tokens are returned separately from the content
 				// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
-				if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
+				if (
+					delta &&
+					"reasoning" in delta &&
+					delta.reasoning &&
+					!shouldSkipReasoningForModel(this.options.openRouterModelId)
+				) {
 					yield {
 						type: "reasoning",
 						reasoning: typeof delta.reasoning === "string" ? delta.reasoning : JSON.stringify(delta.reasoning),
@@ -183,6 +188,7 @@ export class ClineHandler implements ApiHandler {
 				See: https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks
 				*/
 				if (
+					delta &&
 					"reasoning_details" in delta &&
 					delta.reasoning_details &&
 					// @ts-expect-error-next-line

src/core/api/providers/fireworks.ts

@@ -71,7 +71,7 @@ export class FireworksHandler implements ApiHandler {
 				}
 			}
 
-			if (reasoning || ("reasoning_content" in delta && delta.reasoning_content)) {
+			if (reasoning || (delta && "reasoning_content" in delta && delta.reasoning_content)) {
 				yield {
 					type: "reasoning",
 					reasoning: delta.content || ((delta as any).reasoning_content as string | undefined) || "",

src/core/api/providers/minimax.ts

@@ -56,18 +56,22 @@ export class MinimaxHandler implements ApiHandler {
 		// Tools are available only when native tools are enabled
 		const nativeToolsOn = tools?.length && tools?.length > 0
 
+		const budget_tokens = this.options.thinkingBudgetTokens || 0
+		const reasoningOn = (model.info.supportsReasoning ?? false) && budget_tokens !== 0
+
 		// MiniMax M2 uses Anthropic API format
-		// Note: According to MiniMax docs, some Anthropic parameters like 'thinking' are ignored
-		// but we'll include the standard Anthropic streaming pattern for consistency
 		const stream: AnthropicStream<Anthropic.RawMessageStreamEvent> = await client.messages.create({
 			model: model.id,
 			max_tokens: model.info.maxTokens || 8192,
-			temperature: 1.0, // MiniMax recommends 1.0, range is (0.0, 1.0]
 			system: [{ text: systemPrompt, type: "text" }],
 			messages,
 			stream: true,
 			tools: nativeToolsOn ? (tools as AnthropicTool[]) : undefined,
-			tool_choice: nativeToolsOn ? { type: "any" } : undefined,
+			thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
+			// "Thinking isn't compatible with temperature, top_p, or top_k modifications"
+			temperature: reasoningOn ? undefined : 1.0, // MiniMax recommends 1.0, range is (0.0, 1.0]
+			// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
+			tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
 		})
 
 		const lastStartedToolCall = { id: "", name: "", arguments: "" }

src/core/api/providers/oca.ts

@@ -1,5 +1,6 @@
+import { Anthropic, APIError as AnthropicAPIError } from "@anthropic-ai/sdk"
 import { liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults, ModelInfo } from "@shared/api"
-import OpenAI, { APIError, OpenAIError } from "openai"
+import OpenAI, { APIError as OpenAIAPIError, OpenAIError } from "openai"
 import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
 import { OcaAuthService } from "@/services/auth/oca/OcaAuthService"
 import {
@@ -16,10 +17,12 @@ import { ApiFormat } from "@/shared/proto/index.cline"
 import { Logger } from "@/shared/services/Logger"
 import { ApiHandler, type CommonApiHandlerOptions } from ".."
 import { withRetry } from "../retry"
+import { sanitizeAnthropicMessages } from "../transform/anthropic-format"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { convertToOpenAIResponsesInput } from "../transform/openai-response-format"
 import { ApiStream } from "../transform/stream"
 import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-processor"
+import { convertOpenAIToolsToAnthropicTools, handleAnthropicMessagesApiStreamResponse } from "../utils/messages_api_support"
 import { handleResponsesApiStreamResponse } from "../utils/responses_api_support"
 
 export interface OcaHandlerOptions extends CommonApiHandlerOptions {
@@ -35,14 +38,15 @@ export interface OcaHandlerOptions extends CommonApiHandlerOptions {
 
 export class OcaHandler implements ApiHandler {
 	protected options: OcaHandlerOptions
-	protected client: OpenAI | undefined
+	protected openAIClient: OpenAI | undefined
+	protected anthropicClient: Anthropic | undefined
 	protected externalHeaders: Record<string, string> = {}
 
 	constructor(options: OcaHandlerOptions) {
 		this.options = options
 	}
 
-	protected initializeClient(options: OcaHandlerOptions): OpenAI {
+	protected initializeOpenAIClient(options: OcaHandlerOptions): OpenAI {
 		const externalHeaders = buildExternalBasicHeaders()
 		return new (class OCIOpenAI extends OpenAI {
 			protected override async prepareOptions(opts: any): Promise<void> {
@@ -63,7 +67,7 @@ export class OcaHandler implements ApiHandler {
 				error: Object | undefined,
 				message: string | undefined,
 				headers: any | undefined,
-			): APIError {
+			): OpenAIAPIError {
 				interface OciError {
 					code?: string
 					message?: string
@@ -94,23 +98,89 @@ export class OcaHandler implements ApiHandler {
 		})
 	}
 
-	protected ensureClient(): OpenAI {
-		if (!this.client) {
+	protected initializeAnthropicClient(options: OcaHandlerOptions): Anthropic {
+		const externalHeaders = buildExternalBasicHeaders()
+		return new (class OCIAnthropic extends Anthropic {
+			protected override async prepareOptions(opts: any): Promise<void> {
+				const token = await OcaAuthService.getInstance().getAuthToken()
+				if (!token) {
+					throw new OpenAIError("Unable to handle auth, Oracle Code Assist (OCA) access token is not available")
+				}
+				opts.headers ??= {}
+				// OCA Headers
+				const ociHeaders = await createOcaHeaders(token, options.taskId!)
+				opts.headers = { ...opts.headers, ...externalHeaders, ...ociHeaders }
+				Logger.log(`Making request with customer opc-request-id: ${opts.headers?.["opc-request-id"]}`)
+				return super.prepareOptions(opts)
+			}
+
+			protected override makeStatusError(
+				status: number | undefined,
+				error: Object | undefined,
+				message: string | undefined,
+				headers: any | undefined,
+			): AnthropicAPIError {
+				interface OciError {
+					code?: string
+					message?: string
+				}
+				let ociErrorMessage = message
+				if (typeof error === "object" && error !== null) {
+					try {
+						ociErrorMessage = JSON.stringify(error)
+						const ociErr = error as OciError
+						if (ociErr.code !== undefined && ociErr.message !== undefined) {
+							ociErrorMessage = `${ociErr.code}: ${ociErr.message}`
+						}
+					} catch {}
+				}
+				const opcRequestId = headers?.[OCI_HEADER_OPC_REQUEST_ID]
+				if (opcRequestId) {
+					ociErrorMessage += `\n(${OCI_HEADER_OPC_REQUEST_ID}: ${opcRequestId})`
+				}
+				const statusCode = typeof status === "number" ? status : 500
+				return super.makeStatusError(statusCode, error ?? {}, ociErrorMessage, headers)
+			}
+		})({
+			baseURL:
+				options.ocaBaseUrl ||
+				(options.ocaMode === "internal" ? DEFAULT_INTERNAL_OCA_BASE_URL : DEFAULT_EXTERNAL_OCA_BASE_URL),
+			apiKey: "noop",
+			fetch, // Use configured fetch with proxy support
+		})
+	}
+
+	protected ensureOpenAIClient(): OpenAI {
+		if (!this.openAIClient) {
 			if (!this.options.ocaModelId) {
 				throw new Error("Oracle Code Assist (OCA) model is not selected")
 			}
 			try {
-				this.client = this.initializeClient(this.options)
+				this.openAIClient = this.initializeOpenAIClient(this.options)
 			} catch (error) {
 				throw new Error(`Error creating Oracle Code Assist (OCA) client: ${error.message}`)
 			}
 		}
-		return this.client
+		return this.openAIClient
+	}
+
+	protected ensureAnthropicClient(): Anthropic {
+		if (!this.anthropicClient) {
+			if (!this.options.ocaModelId) {
+				throw new Error("Oracle Code Assist (OCA) model is not selected")
+			}
+			try {
+				this.anthropicClient = this.initializeAnthropicClient(this.options)
+			} catch (error) {
+				throw new Error(`Error creating Oracle Code Assist (OCA) client: ${error.message}`)
+			}
+		}
+		return this.anthropicClient
 	}
 
 	async getApiCosts(prompt_tokens: number, completion_tokens: number): Promise<number | undefined> {
 		// Reference: https://github.com/BerriAI/litellm/blob/122ee634f434014267af104814022af1d9a0882f/litellm/proxy/spend_tracking/spend_management_endpoints.py#L1473
-		const client = this.ensureClient()
+		const client = this.ensureOpenAIClient()
 		const modelId = this.options.ocaModelId || liteLlmDefaultModelId
 		const token = await OcaAuthService.getInstance().getAuthToken()
 		if (!token) {
@@ -163,13 +233,15 @@ export class OcaHandler implements ApiHandler {
 	async *createMessage(systemPrompt: string, messages: ClineStorageMessage[], tools?: OpenAITool[]): ApiStream {
 		if (this.options.ocaModelInfo?.apiFormat == ApiFormat.OPENAI_RESPONSES) {
 			yield* this.createMessageResponsesApi(systemPrompt, messages, tools)
+		} else if (this.options.ocaModelInfo?.apiFormat == ApiFormat.ANTHROPIC_CHAT) {
+			yield* this.createMessageMessagesApi(systemPrompt, messages, tools)
 		} else {
 			yield* this.createMessageChatApi(systemPrompt, messages, tools)
 		}
 	}
 
 	async *createMessageChatApi(systemPrompt: string, messages: ClineStorageMessage[], tools?: OpenAITool[]): ApiStream {
-		const client = this.ensureClient()
+		const client = this.ensureOpenAIClient()
 		const formattedMessages = convertToOpenAiMessages(messages)
 		const systemMessage: OpenAI.Chat.ChatCompletionSystemMessageParam = {
 			role: "system",
@@ -306,8 +378,8 @@ export class OcaHandler implements ApiHandler {
 	}
 
 	async *createMessageResponsesApi(systemPrompt: string, messages: ClineStorageMessage[], tools?: OpenAITool[]): ApiStream {
-		const client = this.ensureClient()
-		const inputMessages = convertToOpenAIResponsesInput(messages).input
+		const client = this.ensureOpenAIClient()
+		const inputMessages = convertToOpenAIResponsesInput(messages, { usePreviousResponseId: false }).input
 		// Convert messages to Responses API input format
 		const input: OpenAI.Responses.ResponseInputItem[] = [{ role: "system", content: systemPrompt }, ...inputMessages]
 
@@ -329,14 +401,56 @@ export class OcaHandler implements ApiHandler {
 			tools: responseTools,
 		}
 
-		if (this.options.ocaModelInfo && this.options.ocaModelInfo.supportsReasoning) {
-			responsesParams["reasoning"] = { effort: this.options.ocaReasoningEffort as any, summary: "auto" }
+		const ocaModelInfo = this.options.ocaModelInfo
+		if (!ocaModelInfo) {
+			throw new Error("Oracle Code Assist (OCA) model info is required for Responses API")
+		}
+		if (ocaModelInfo.supportsReasoning) {
+			responsesParams.reasoning = { effort: this.options.ocaReasoningEffort as any, summary: "auto" }
 		}
 
 		// Create the response using Responses API
 		const stream = await client.responses.create(responsesParams)
 
-		yield* handleResponsesApiStreamResponse(stream, this.options.ocaModelInfo!, this.calculateCost.bind(this))
+		yield* handleResponsesApiStreamResponse(stream, ocaModelInfo, this.calculateCost.bind(this))
+	}
+
+	async *createMessageMessagesApi(systemPrompt: string, messages: ClineStorageMessage[], tools?: OpenAITool[]): ApiStream {
+		const client = this.ensureAnthropicClient()
+
+		const modelId = this.options.ocaModelId || liteLlmDefaultModelId
+
+		const budgetTokens = this.options.thinkingBudgetTokens || 0
+		const reasoningOn = this.options.ocaModelInfo?.supportsReasoning && budgetTokens !== 0
+
+		let temperature: number | undefined = this.options.ocaModelInfo?.temperature ?? 0
+		const maxTokens: number | undefined = this.options.ocaModelInfo?.maxTokens || 8192
+
+		if (reasoningOn) {
+			temperature = 0
+		}
+
+		const anthropicTools = convertOpenAIToolsToAnthropicTools(tools)
+		const anthropicMessages = sanitizeAnthropicMessages(messages, this.options.ocaUsePromptCache ?? false)
+
+		const stream = await client.messages.create({
+			model: modelId,
+			max_tokens: maxTokens,
+			temperature: reasoningOn ? undefined : temperature,
+			system: [
+				{
+					text: systemPrompt,
+					type: "text",
+					cache_control: this.options.ocaUsePromptCache ? { type: "ephemeral" } : undefined,
+				},
+			],
+			messages: anthropicMessages,
+			stream: true,
+			tools: anthropicTools,
+			thinking: reasoningOn ? { type: "enabled", budget_tokens: budgetTokens } : undefined,
+		})
+
+		yield* handleAnthropicMessagesApiStreamResponse(stream)
 	}
 
 	getModel() {

src/core/api/providers/openai-codex.ts

@@ -3,11 +3,16 @@ import { normalizeOpenaiReasoningEffort } from "@shared/storage/types"
 import OpenAI from "openai"
 import type { ChatCompletionTool } from "openai/resources/chat/completions"
 import * as os from "os"
+import { MessageEvent as UndiciMessageEvent, WebSocket as UndiciWebSocket } from "undici"
 import { v7 as uuidv7 } from "uuid"
 import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { buildExternalBasicHeaders } from "@/services/EnvUtils"
+import { featureFlagsService } from "@/services/feature-flags"
 import { ClineStorageMessage } from "@/shared/messages/content"
 import { fetch } from "@/shared/net"
+import { ApiFormat } from "@/shared/proto/cline/models"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
+import { Logger } from "@/shared/services/Logger"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { convertToOpenAIResponsesInput } from "../transform/openai-response-format"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
@@ -17,6 +22,7 @@ import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
  * Routes to chatgpt.com/backend-api/codex
  */
 const CODEX_API_BASE_URL = "https://chatgpt.com/backend-api/codex"
+const CODEX_RESPONSES_WEBSOCKET_URL = "wss://chatgpt.com/backend-api/codex/responses"
 
 interface OpenAiCodexHandlerOptions extends CommonApiHandlerOptions {
 	reasoningEffort?: string
@@ -36,6 +42,8 @@ interface OpenAiCodexHandlerOptions extends CommonApiHandlerOptions {
 export class OpenAiCodexHandler implements ApiHandler {
 	private options: OpenAiCodexHandlerOptions
 	private client?: OpenAI
+	private responsesWs: UndiciWebSocket | undefined
+	private websocketRequestInFlight = false
 	// Session ID for the Codex API (persists for the lifetime of the handler)
 	private readonly sessionId: string
 	// Abort controller for cancelling ongoing requests
@@ -49,7 +57,7 @@ export class OpenAiCodexHandler implements ApiHandler {
 		this.sessionId = uuidv7()
 	}
 
-	private normalizeUsage(usage: any, model: { id: string; info: ModelInfo }): ApiStreamUsageChunk | undefined {
+	private normalizeUsage(usage: any, _model: { id: string; info: ModelInfo }): ApiStreamUsageChunk | undefined {
 		if (!usage) {
 			return undefined
 		}
@@ -101,17 +109,18 @@ export class OpenAiCodexHandler implements ApiHandler {
 		if (!accessToken) {
 			throw new Error("Not authenticated with OpenAI Codex. Please sign in using the OpenAI Codex OAuth flow in settings.")
 		}
-
-		// Format conversation for Responses API
-		const formattedInput = convertToOpenAIResponsesInput(messages).input
+		const useWebsocketMode = this.useWebsocketMode(model.info.apiFormat)
+		const { input, previousResponseId } = convertToOpenAIResponsesInput(messages, { usePreviousResponseId: useWebsocketMode })
+		const usePreviousResponseId = useWebsocketMode && !!previousResponseId
 
 		// Build request body
-		const requestBody = this.buildRequestBody(model, formattedInput, systemPrompt, tools)
+		const requestBody = this.buildRequestBody(model, input, systemPrompt, tools, previousResponseId)
+		const fallbackRequestBody = this.buildRequestBody(model, input, systemPrompt, tools)
 
 		// Make the request with retry on auth failure
 		for (let attempt = 0; attempt < 2; attempt++) {
 			try {
-				yield* this.executeRequest(requestBody, model, accessToken)
+				yield* this.executeRequest(requestBody, fallbackRequestBody, model, accessToken, usePreviousResponseId)
 				return
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error)
@@ -133,11 +142,19 @@ export class OpenAiCodexHandler implements ApiHandler {
 		}
 	}
 
+	private useWebsocketMode(apiFormat?: ApiFormat): boolean {
+		if (featureFlagsService.getBooleanFlagEnabled(FeatureFlag.OPENAI_RESPONSES_WEBSOCKET_MODE)) {
+			return apiFormat === ApiFormat.OPENAI_RESPONSES_WEBSOCKET_MODE
+		}
+		return false
+	}
+
 	private buildRequestBody(
 		model: { id: string; info: ModelInfo },
 		formattedInput: any,
 		systemPrompt: string,
 		tools?: ChatCompletionTool[],
+		previousResponseId?: string,
 	): any {
 		// Determine reasoning effort
 		const reasoningEffort = normalizeOpenaiReasoningEffort(this.options.reasoningEffort)
@@ -149,6 +166,7 @@ export class OpenAiCodexHandler implements ApiHandler {
 			stream: true,
 			store: false,
 			instructions: systemPrompt,
+			...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
 			...(includeReasoning ? { include: ["reasoning.encrypted_content"] } : {}),
 			...(includeReasoning
 				? {
@@ -177,7 +195,13 @@ export class OpenAiCodexHandler implements ApiHandler {
 		return body
 	}
 
-	private async *executeRequest(requestBody: any, model: { id: string; info: ModelInfo }, accessToken: string): ApiStream {
+	private async *executeRequest(
+		requestBody: any,
+		fallbackRequestBody: any,
+		model: { id: string; info: ModelInfo },
+		accessToken: string,
+		useWebsocketMode: boolean,
+	): ApiStream {
 		// Create AbortController for cancellation
 		this.abortController = new AbortController()
 
@@ -194,6 +218,16 @@ export class OpenAiCodexHandler implements ApiHandler {
 				...buildExternalBasicHeaders(),
 			}
 
+			if (useWebsocketMode) {
+				try {
+					yield* this.createResponseStreamWebsocket(requestBody, fallbackRequestBody, accessToken, codexHeaders, model)
+					return
+				} catch (error) {
+					Logger.error("OpenAI Codex websocket mode failed, falling back to HTTP Responses API:", error)
+					this.closeResponsesWebsocket()
+				}
+			}
+
 			// Try using OpenAI SDK first
 			try {
 				const client =
@@ -232,6 +266,223 @@ export class OpenAiCodexHandler implements ApiHandler {
 		}
 	}
 
+	private async *createResponseStreamWebsocket(
+		primaryParams: OpenAI.Responses.ResponseCreateParamsStreaming,
+		fallbackParams: OpenAI.Responses.ResponseCreateParamsStreaming,
+		accessToken: string,
+		codexHeaders: Record<string, string>,
+		model: { id: string; info: ModelInfo },
+	): ApiStream {
+		try {
+			for await (const event of this.createResponseEventsViaWebsocket(primaryParams, accessToken, codexHeaders)) {
+				if (this.abortController?.signal.aborted) {
+					return
+				}
+				yield* this.processEvent(event, model)
+			}
+		} catch (error) {
+			if (this.shouldRetryWebsocketWithFullContext(error, !!primaryParams.previous_response_id)) {
+				Logger.log(
+					"Retrying Codex websocket response with full context after previous_response_not_found or socket reset",
+				)
+				this.closeResponsesWebsocket()
+				for await (const event of this.createResponseEventsViaWebsocket(fallbackParams, accessToken, codexHeaders)) {
+					if (this.abortController?.signal.aborted) {
+						return
+					}
+					yield* this.processEvent(event, model)
+				}
+				return
+			}
+			throw error
+		}
+	}
+
+	private shouldRetryWebsocketWithFullContext(error: unknown, hadPreviousResponseId: boolean): boolean {
+		const errorCode =
+			typeof error === "object" && error && "code" in error && typeof (error as { code: unknown }).code === "string"
+				? (error as { code: string }).code
+				: undefined
+
+		if (hadPreviousResponseId && errorCode === "previous_response_not_found") {
+			return true
+		}
+		if (errorCode === "websocket_closed" || errorCode === "websocket_error") {
+			return true
+		}
+		return false
+	}
+
+	private async ensureResponsesWebsocket(accessToken: string, codexHeaders: Record<string, string>): Promise<UndiciWebSocket> {
+		if (this.responsesWs && this.responsesWs.readyState === UndiciWebSocket.OPEN) {
+			return this.responsesWs
+		}
+
+		this.closeResponsesWebsocket()
+
+		const ws = new UndiciWebSocket(CODEX_RESPONSES_WEBSOCKET_URL, {
+			headers: {
+				Authorization: `Bearer ${accessToken}`,
+				"OpenAI-Beta": "responses_websockets=2026-02-06",
+				...codexHeaders,
+			},
+		})
+
+		await new Promise<void>((resolve, reject) => {
+			const cleanup = () => {
+				ws.removeEventListener("open", handleOpen)
+				ws.removeEventListener("error", handleError)
+				ws.removeEventListener("close", handleClose)
+			}
+			const handleOpen = () => {
+				cleanup()
+				resolve()
+			}
+			const handleError = () => {
+				cleanup()
+				reject(new Error("Failed to open Codex Responses websocket"))
+			}
+			const handleClose = () => {
+				cleanup()
+				reject(new Error("Codex Responses websocket closed before opening"))
+			}
+			ws.addEventListener("open", handleOpen)
+			ws.addEventListener("error", handleError)
+			ws.addEventListener("close", handleClose)
+		})
+
+		this.responsesWs = ws
+		return ws
+	}
+
+	private closeResponsesWebsocket() {
+		if (this.responsesWs) {
+			try {
+				this.responsesWs.close()
+			} catch {}
+			this.responsesWs = undefined
+		}
+	}
+
+	private async *createResponseEventsViaWebsocket(
+		params: OpenAI.Responses.ResponseCreateParamsStreaming,
+		accessToken: string,
+		codexHeaders: Record<string, string>,
+	): AsyncGenerator<OpenAI.Responses.ResponseStreamEvent> {
+		if (this.websocketRequestInFlight) {
+			const error: Error & { code?: string } = new Error("Websocket response.create is already in progress")
+			error.code = "websocket_concurrency_limit"
+			throw error
+		}
+
+		const ws = await this.ensureResponsesWebsocket(accessToken, codexHeaders)
+		this.websocketRequestInFlight = true
+
+		const eventQueue: OpenAI.Responses.ResponseStreamEvent[] = []
+		let resolver: (() => void) | undefined
+		let completed = false
+		let failure: (Error & { code?: string }) | undefined
+
+		const wake = () => {
+			const next = resolver
+			resolver = undefined
+			next?.()
+		}
+
+		const handleMessage = (evt: UndiciMessageEvent) => {
+			try {
+				let raw = ""
+				if (typeof evt.data === "string") {
+					raw = evt.data
+				} else if (evt.data instanceof ArrayBuffer) {
+					raw = new TextDecoder().decode(new Uint8Array(evt.data))
+				} else if (ArrayBuffer.isView(evt.data)) {
+					raw = new TextDecoder().decode(new Uint8Array(evt.data.buffer, evt.data.byteOffset, evt.data.byteLength))
+				} else {
+					raw = String(evt.data)
+				}
+
+				const parsed = JSON.parse(raw)
+				if (parsed?.type === "error" && parsed?.error) {
+					const error: Error & { code?: string } = new Error(parsed.error.message || "Codex Responses websocket error")
+					error.code = parsed.error.code
+					failure = error
+					completed = true
+					wake()
+					return
+				}
+
+				eventQueue.push(parsed as OpenAI.Responses.ResponseStreamEvent)
+				if (parsed?.type === "response.completed" || parsed?.type === "response.failed") {
+					completed = true
+				}
+				wake()
+			} catch (error) {
+				const parseError: Error & { code?: string } = new Error(
+					`Failed to parse websocket event: ${error instanceof Error ? error.message : String(error)}`,
+				)
+				parseError.code = "websocket_parse_error"
+				failure = parseError
+				completed = true
+				wake()
+			}
+		}
+
+		const handleError = () => {
+			const error: Error & { code?: string } = new Error("Codex Responses websocket emitted an error event")
+			error.code = "websocket_error"
+			failure = error
+			completed = true
+			wake()
+		}
+
+		const handleClose = () => {
+			if (!completed) {
+				const error: Error & { code?: string } = new Error("Codex Responses websocket closed during response stream")
+				error.code = "websocket_closed"
+				failure = error
+				completed = true
+				wake()
+			}
+		}
+
+		ws.addEventListener("message", handleMessage)
+		ws.addEventListener("error", handleError)
+		ws.addEventListener("close", handleClose)
+
+		try {
+			ws.send(
+				JSON.stringify({
+					type: "response.create",
+					...params,
+				}),
+			)
+
+			while (!completed || eventQueue.length > 0) {
+				if (eventQueue.length === 0) {
+					await new Promise<void>((resolve) => {
+						resolver = resolve
+					})
+					continue
+				}
+
+				const event = eventQueue.shift()
+				if (event) {
+					yield event
+				}
+			}
+
+			if (failure) {
+				throw failure
+			}
+		} finally {
+			ws.removeEventListener("message", handleMessage)
+			ws.removeEventListener("error", handleError)
+			ws.removeEventListener("close", handleClose)
+			this.websocketRequestInFlight = false
+		}
+	}
+
 	private async *makeCodexRequest(requestBody: any, model: { id: string; info: ModelInfo }, accessToken: string): ApiStream {
 		const url = `${CODEX_API_BASE_URL}/responses`
 
@@ -465,6 +716,7 @@ export class OpenAiCodexHandler implements ApiHandler {
 	}
 
 	abort(): void {
+		this.closeResponsesWebsocket()
 		this.abortController?.abort()
 	}
 

src/core/api/providers/openai-native.ts

@@ -8,10 +8,18 @@ import {
 import { normalizeOpenaiReasoningEffort } from "@shared/storage/types"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
-import type { ChatCompletionReasoningEffort, ChatCompletionTool } from "openai/resources/chat/completions"
+import type {
+	ChatCompletionFunctionTool,
+	ChatCompletionReasoningEffort,
+	ChatCompletionTool,
+} from "openai/resources/chat/completions"
+import { MessageEvent as UndiciMessageEvent, WebSocket as UndiciWebSocket } from "undici"
+import { buildExternalBasicHeaders } from "@/services/EnvUtils"
+import { featureFlagsService } from "@/services/feature-flags"
 import { ClineStorageMessage } from "@/shared/messages/content"
 import { createOpenAIClient } from "@/shared/net"
 import { ApiFormat } from "@/shared/proto/cline/models"
+import { FeatureFlag } from "@/shared/services/feature-flags/feature-flags"
 import { Logger } from "@/shared/services/Logger"
 import { isGPT5ModelFamily } from "@/utils/model-utils"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
@@ -26,12 +34,16 @@ interface OpenAiNativeHandlerOptions extends CommonApiHandlerOptions {
 	reasoningEffort?: string
 	thinkingBudgetTokens?: number
 	apiModelId?: string
-	store?: boolean
+	openAiNativeUseResponsesWebsocket?: boolean
 }
 
 export class OpenAiNativeHandler implements ApiHandler {
 	private options: OpenAiNativeHandlerOptions
 	private client: OpenAI | undefined
+	private responsesWs: UndiciWebSocket | undefined
+	private responsesWsReadyPromise: Promise<UndiciWebSocket> | undefined
+	private websocketRequestInFlight = false
+	private abortController?: AbortController
 
 	constructor(options: OpenAiNativeHandlerOptions) {
 		this.options = options
@@ -73,7 +85,8 @@ export class OpenAiNativeHandler implements ApiHandler {
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: ClineStorageMessage[], tools?: ChatCompletionTool[]): ApiStream {
 		// Responses API requires tool format to be set to OPENAI_RESPONSES with native tools calling enabled
-		if (this.getModel()?.info?.apiFormat === ApiFormat.OPENAI_RESPONSES) {
+		const apiFormat = this.getModel()?.info?.apiFormat
+		if (apiFormat === ApiFormat.OPENAI_RESPONSES || apiFormat === ApiFormat.OPENAI_RESPONSES_WEBSOCKET_MODE) {
 			if (!tools?.length) {
 				throw new Error("Native Tool Call must be enabled in your setting for OpenAI Responses API")
 			}
@@ -91,13 +104,17 @@ export class OpenAiNativeHandler implements ApiHandler {
 		const client = this.ensureClient()
 		const model = this.getModel()
 		const toolCallProcessor = new ToolCallProcessor()
+		this.abortController = new AbortController()
 
 		// Handle o1 models separately as they don't support streaming
 		if (model.info.supportsStreaming === false) {
-			const response = await client.chat.completions.create({
-				model: model.id,
-				messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
-			})
+			const response = await client.chat.completions.create(
+				{
+					model: model.id,
+					messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages, "openai-native")],
+				},
+				{ signal: this.abortController?.signal },
+			)
 			yield {
 				type: "text",
 				text: response.choices[0]?.message.content || "",
@@ -115,7 +132,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 
 		const stream = await client.chat.completions.create({
 			model: model.id,
-			messages: [{ role: systemRole, content: systemPrompt }, ...convertToOpenAiMessages(messages)],
+			messages: [{ role: systemRole, content: systemPrompt }, ...convertToOpenAiMessages(messages, "openai-native")],
 			stream: true,
 			stream_options: { include_usage: true },
 			reasoning_effort: reasoningEffort,
@@ -152,26 +169,79 @@ export class OpenAiNativeHandler implements ApiHandler {
 		messages: ClineStorageMessage[],
 		tools: ChatCompletionTool[],
 	): ApiStream {
-		const client = this.ensureClient()
 		const model = this.getModel()
+		const usePreviousResponseId = this.useWebsocketMode(model.info.apiFormat)
 
-		// Convert messages to Responses API input format
-		const { input, previousResponseId } = convertToOpenAIResponsesInput(messages)
+		// Warm websocket connection early in websocket mode so the first response.create avoids handshake latency.
+		if (usePreviousResponseId) {
+			this.preconnectResponsesWebsocket()
+		}
 
-		// Convert ChatCompletion tools to Responses API format if provided
-		const responseTools = tools
-			?.filter((tool) => tool?.type === "function")
-			.map((tool: any) => ({
+		const { input, previousResponseId } = convertToOpenAIResponsesInput(messages, { usePreviousResponseId })
+		const responseTools = this.mapResponseTools(tools)
+		this.abortController = new AbortController()
+
+		const params = this.buildResponseCreateParams({
+			modelId: model.id,
+			systemPrompt,
+			input,
+			previousResponseId,
+			tools: responseTools,
+		})
+
+		const fallbackParams = this.buildResponseCreateParams({
+			modelId: model.id,
+			systemPrompt,
+			input,
+			tools: responseTools,
+		})
+
+		if (usePreviousResponseId && previousResponseId) {
+			try {
+				yield* this.createResponseStreamWebsocket(model.info, params, fallbackParams)
+				return
+			} catch (error) {
+				Logger.error("OpenAI websocket mode failed, falling back to HTTP Responses API:", error)
+				this.closeResponsesWebsocket()
+			}
+		}
+
+		yield* this.createResponseStreamHttp(model.info, params)
+	}
+
+	private preconnectResponsesWebsocket(): void {
+		void this.ensureResponsesWebsocket().catch((error) => {
+			Logger.debug("OpenAI websocket preconnect failed:", error)
+			this.closeResponsesWebsocket()
+		})
+	}
+
+	private useWebsocketMode(apiFormat?: ApiFormat): boolean {
+		if (featureFlagsService.getBooleanFlagEnabled(FeatureFlag.OPENAI_RESPONSES_WEBSOCKET_MODE)) {
+			return apiFormat === ApiFormat.OPENAI_RESPONSES_WEBSOCKET_MODE
+		}
+		return false
+	}
+
+	private mapResponseTools(tools: ChatCompletionTool[]): OpenAI.Responses.Tool[] {
+		return tools
+			?.filter((tool): tool is ChatCompletionFunctionTool => tool?.type === "function")
+			.map((tool) => ({
 				type: "function" as const,
 				name: tool.function.name,
 				description: tool.function.description,
-				parameters: tool.function.parameters,
-				strict: tool.function.strict ?? true, // Responses API defaults to strict mode
+				parameters: tool.function.parameters ?? null,
+				strict: tool.function.strict ?? true,
 			}))
+	}
 
-		Logger.debug(`OpenAI Responses Input: ${JSON.stringify(input)}`)
-
-		// Create the response using Responses API
+	private buildResponseCreateParams(args: {
+		modelId: string
+		systemPrompt: string
+		input: OpenAI.Responses.ResponseInput
+		tools: OpenAI.Responses.Tool[]
+		previousResponseId?: string
+	}): OpenAI.Responses.ResponseCreateParamsStreaming {
 		const requestedEffort = normalizeOpenaiReasoningEffort(this.options.reasoningEffort)
 		const reasoning: { effort: ChatCompletionReasoningEffort; summary: "auto" } | undefined =
 			requestedEffort === "none"
@@ -181,25 +251,261 @@ export class OpenAiNativeHandler implements ApiHandler {
 						summary: "auto",
 					}
 
-		const stream = await client.responses.create({
-			model: model.id,
-			instructions: systemPrompt,
-			input,
+		return {
+			model: args.modelId,
+			instructions: args.systemPrompt,
+			input: args.input,
 			stream: true,
-			tools: responseTools,
-			store: this.options.store ?? false,
-			...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
+			tools: args.tools,
+			store: !args.previousResponseId, // Do not use store when websocket mode is enabled.
+			...(args.previousResponseId ? { previous_response_id: args.previousResponseId } : {}),
 			...(reasoning ? { reasoning } : {}),
-			// include: ["reasoning.encrypted_content"],
+		}
+	}
+
+	private async *createResponseStreamHttp(
+		modelInfo: ModelInfo,
+		params: OpenAI.Responses.ResponseCreateParamsStreaming,
+	): ApiStream {
+		const client = this.ensureClient()
+		Logger.debug(`OpenAI Responses Input (HTTP): ${JSON.stringify(params.input)}`)
+		const stream = await client.responses.create(params, { signal: this.abortController?.signal })
+		yield* this.processResponsesEvents(stream, modelInfo)
+	}
+
+	private async *createResponseStreamWebsocket(
+		modelInfo: ModelInfo,
+		primaryParams: OpenAI.Responses.ResponseCreateParamsStreaming,
+		fallbackParams: OpenAI.Responses.ResponseCreateParamsStreaming,
+	): ApiStream {
+		Logger.debug(`OpenAI Responses Input (WebSocket): ${JSON.stringify(primaryParams.input)}`)
+		try {
+			yield* this.processResponsesEvents(this.createResponseEventsViaWebsocket(primaryParams), modelInfo)
+		} catch (error) {
+			if (this.shouldRetryWebsocketWithFullContext(error, !!primaryParams.previous_response_id)) {
+				Logger.log("Retrying websocket response with full context after previous_response_not_found or socket reset")
+				this.closeResponsesWebsocket()
+				yield* this.processResponsesEvents(this.createResponseEventsViaWebsocket(fallbackParams), modelInfo)
+				return
+			}
+			throw error
+		}
+	}
+
+	private shouldRetryWebsocketWithFullContext(error: unknown, hadPreviousResponseId: boolean): boolean {
+		const errorCode =
+			typeof error === "object" && error && "code" in error && typeof (error as { code: unknown }).code === "string"
+				? (error as { code: string }).code
+				: undefined
+
+		if (hadPreviousResponseId && errorCode === "previous_response_not_found") {
+			return true
+		}
+		if (errorCode === "websocket_closed" || errorCode === "websocket_error") {
+			return true
+		}
+		return false
+	}
+
+	private async ensureResponsesWebsocket(): Promise<UndiciWebSocket> {
+		if (this.responsesWs && this.responsesWs.readyState === UndiciWebSocket.OPEN) {
+			return this.responsesWs
+		}
+
+		if (this.responsesWsReadyPromise) {
+			return this.responsesWsReadyPromise
+		}
+
+		this.closeResponsesWebsocket()
+
+		if (!this.options.openAiNativeApiKey) {
+			throw new Error("OpenAI API key is required")
+		}
+
+		const ws = new UndiciWebSocket("wss://api.openai.com/v1/responses", {
+			headers: {
+				Authorization: `Bearer ${this.options.openAiNativeApiKey}`,
+				"OpenAI-Beta": "responses_websockets=2026-02-06",
+				...buildExternalBasicHeaders(),
+			},
 		})
 
+		this.responsesWs = ws
+		const readyPromise = new Promise<UndiciWebSocket>((resolve, reject) => {
+			const cleanup = () => {
+				ws.removeEventListener("open", handleOpen)
+				ws.removeEventListener("error", handleError)
+				ws.removeEventListener("close", handleClose)
+			}
+			const handleOpen = () => {
+				cleanup()
+				resolve(ws)
+			}
+			const handleError = () => {
+				cleanup()
+				reject(new Error("Failed to open Responses websocket"))
+			}
+			const handleClose = () => {
+				cleanup()
+				reject(new Error("Responses websocket closed before opening"))
+			}
+			ws.addEventListener("open", handleOpen)
+			ws.addEventListener("error", handleError)
+			ws.addEventListener("close", handleClose)
+		})
+
+		this.responsesWsReadyPromise = readyPromise
+
+		try {
+			return await readyPromise
+		} catch (error) {
+			if (this.responsesWs === ws) {
+				this.responsesWs = undefined
+			}
+			throw error
+		} finally {
+			if (this.responsesWsReadyPromise === readyPromise) {
+				this.responsesWsReadyPromise = undefined
+			}
+		}
+	}
+
+	private closeResponsesWebsocket() {
+		this.responsesWsReadyPromise = undefined
+		if (this.responsesWs) {
+			try {
+				this.responsesWs.close()
+			} catch {}
+			this.responsesWs = undefined
+		}
+	}
+
+	private async *createResponseEventsViaWebsocket(
+		params: OpenAI.Responses.ResponseCreateParamsStreaming,
+	): AsyncGenerator<OpenAI.Responses.ResponseStreamEvent> {
+		if (this.websocketRequestInFlight) {
+			const error: Error & { code?: string } = new Error("Websocket response.create is already in progress")
+			error.code = "websocket_concurrency_limit"
+			throw error
+		}
+
+		const ws = await this.ensureResponsesWebsocket()
+		this.websocketRequestInFlight = true
+
+		const eventQueue: OpenAI.Responses.ResponseStreamEvent[] = []
+		let resolver: (() => void) | undefined
+		let completed = false
+		let failure: (Error & { code?: string }) | undefined
+
+		const wake = () => {
+			const next = resolver
+			resolver = undefined
+			next?.()
+		}
+
+		const handleMessage = (evt: UndiciMessageEvent) => {
+			try {
+				let raw = ""
+				if (typeof evt.data === "string") {
+					raw = evt.data
+				} else if (evt.data instanceof ArrayBuffer) {
+					raw = new TextDecoder().decode(new Uint8Array(evt.data))
+				} else if (ArrayBuffer.isView(evt.data)) {
+					raw = new TextDecoder().decode(new Uint8Array(evt.data.buffer, evt.data.byteOffset, evt.data.byteLength))
+				} else {
+					raw = String(evt.data)
+				}
+				const parsed = JSON.parse(raw)
+
+				if (parsed?.type === "error" && parsed?.error) {
+					const error: Error & { code?: string } = new Error(parsed.error.message || "Responses websocket error")
+					error.code = parsed.error.code
+					failure = error
+					completed = true
+					wake()
+					return
+				}
+
+				eventQueue.push(parsed as OpenAI.Responses.ResponseStreamEvent)
+				if (parsed?.type === "response.completed" || parsed?.type === "response.failed") {
+					completed = true
+				}
+				wake()
+			} catch (error) {
+				const parseError: Error & { code?: string } = new Error(
+					`Failed to parse websocket event: ${error instanceof Error ? error.message : String(error)}`,
+				)
+				parseError.code = "websocket_parse_error"
+				failure = parseError
+				completed = true
+				wake()
+			}
+		}
+
+		const handleError = () => {
+			const error: Error & { code?: string } = new Error("Responses websocket emitted an error event")
+			error.code = "websocket_error"
+			failure = error
+			completed = true
+			wake()
+		}
+
+		const handleClose = () => {
+			if (!completed) {
+				const error: Error & { code?: string } = new Error("Responses websocket closed during response stream")
+				error.code = "websocket_closed"
+				failure = error
+				completed = true
+				wake()
+			}
+		}
+
+		ws.addEventListener("message", handleMessage)
+		ws.addEventListener("error", handleError)
+		ws.addEventListener("close", handleClose)
+
+		try {
+			ws.send(
+				JSON.stringify({
+					type: "response.create",
+					...params,
+				}),
+			)
+
+			while (!completed || eventQueue.length > 0) {
+				if (eventQueue.length === 0) {
+					await new Promise<void>((resolve) => {
+						resolver = resolve
+					})
+					continue
+				}
+
+				const event = eventQueue.shift()
+				if (event) {
+					yield event
+				}
+			}
+
+			if (failure) {
+				throw failure
+			}
+		} finally {
+			ws.removeEventListener("message", handleMessage)
+			ws.removeEventListener("error", handleError)
+			ws.removeEventListener("close", handleClose)
+			this.websocketRequestInFlight = false
+		}
+	}
+
+	private async *processResponsesEvents(
+		stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>,
+		modelInfo: ModelInfo,
+	): ApiStream {
 		const functionCallByItemId = new Map<string, { call_id?: string; name?: string; id?: string }>()
 
-		// Process the response stream
 		for await (const chunk of stream) {
 			Logger.debug(`OpenAI Responses Chunk: ${JSON.stringify(chunk)}`)
 
-			// Handle different event types from Responses API
 			if (chunk.type === "response.output_item.added") {
 				const item = chunk.item
 				if (item.type === "function_call" && item.id) {
@@ -277,7 +583,6 @@ export class OpenAiNativeHandler implements ApiHandler {
 				}
 			}
 			if (chunk.type === "response.output_text.delta") {
-				// Handle text content deltas
 				if (chunk.delta) {
 					yield {
 						id: chunk.item_id,
@@ -287,7 +592,6 @@ export class OpenAiNativeHandler implements ApiHandler {
 				}
 			}
 			if (chunk.type === "response.reasoning_text.delta") {
-				// Handle reasoning content deltas
 				if (chunk.delta) {
 					yield {
 						id: chunk.item_id,
@@ -315,7 +619,6 @@ export class OpenAiNativeHandler implements ApiHandler {
 				}
 			}
 			if (chunk.type === "response.function_call_arguments.done") {
-				// Handle completed function call
 				if (chunk.item_id && chunk.name && chunk.arguments) {
 					const pendingCall = functionCallByItemId.get(chunk.item_id)
 					const callId = pendingCall?.call_id
@@ -348,7 +651,6 @@ export class OpenAiNativeHandler implements ApiHandler {
 			}
 
 			if (chunk.type === "response.completed" && chunk.response?.usage) {
-				// Handle usage information when response is complete
 				const usage = chunk.response.usage
 				const inputTokens = usage.input_tokens || 0
 				const outputTokens = usage.output_tokens || 0
@@ -357,7 +659,13 @@ export class OpenAiNativeHandler implements ApiHandler {
 				const reasoningTokens = usage.output_tokens_details?.reasoning_tokens || 0
 				const totalTokens = usage.total_tokens || 0
 				Logger.log(`Total tokens from Responses API usage: ${totalTokens}`)
-				const totalCost = calculateApiCostOpenAI(model.info, inputTokens, outputTokens + reasoningTokens, cacheWriteTokens, cacheReadTokens)
+				const totalCost = calculateApiCostOpenAI(
+					modelInfo,
+					inputTokens,
+					outputTokens + reasoningTokens,
+					cacheWriteTokens,
+					cacheReadTokens,
+				)
 				const nonCachedInputTokens = Math.max(0, inputTokens - cacheReadTokens - cacheWriteTokens)
 				yield {
 					type: "usage",
@@ -373,6 +681,12 @@ export class OpenAiNativeHandler implements ApiHandler {
 		}
 	}
 
+	abort(): void {
+		this.closeResponsesWebsocket()
+		this.abortController?.abort()
+		this.abortController = undefined
+	}
+
 	getModel(): { id: OpenAiNativeModelId; info: OpenAiCompatibleModelInfo } {
 		const modelId = this.options.apiModelId
 		if (modelId && modelId in openAiNativeModels) {

src/core/api/providers/openrouter.ts

@@ -122,7 +122,12 @@ export class OpenRouterHandler implements ApiHandler {
 
 			// Reasoning tokens are returned separately from the content
 			// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
-			if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
+			if (
+				delta &&
+				"reasoning" in delta &&
+				delta.reasoning &&
+				!shouldSkipReasoningForModel(this.options.openRouterModelId)
+			) {
 				yield {
 					type: "reasoning",
 					reasoning: typeof delta.reasoning === "string" ? delta.reasoning : JSON.stringify(delta.reasoning),
@@ -132,6 +137,7 @@ export class OpenRouterHandler implements ApiHandler {
 			// OpenRouter passes reasoning details that we can pass back unmodified in api requests to preserve reasoning traces for model
 			// See: https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks
 			if (
+				delta &&
 				"reasoning_details" in delta &&
 				delta.reasoning_details &&
 				// @ts-expect-error-next-line

src/core/api/providers/sambanova.ts

@@ -52,7 +52,7 @@ export class SambanovaHandler implements ApiHandler {
 
 		const modelId = model.id.toLowerCase()
 
-		if (modelId.includes("deepseek") || modelId.includes("qwen") || modelId.includes("qwq")) {
+		if (modelId.includes("deepseek") || modelId.includes("qwen3")) {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
@@ -60,7 +60,7 @@ export class SambanovaHandler implements ApiHandler {
 		const stream = await client.chat.completions.create({
 			model: this.getModel().id,
 			messages: openAiMessages,
-			temperature: 0,
+			temperature: model.info.temperature ?? 0,
 			stream: true,
 			stream_options: { include_usage: true },
 			...getOpenAIToolParams(tools),

src/core/api/providers/sapaicore.ts

@@ -372,12 +372,12 @@ export class SapAiCoreHandler implements ApiHandler {
 	private chunkToString(chunk: any): string {
 		if (Buffer.isBuffer(chunk)) {
 			return chunk.toString("utf-8")
-		} else if (typeof chunk === "string") {
-			return chunk
-		} else {
-			// Handle comma-separated byte values or other array-like formats
-			return Buffer.from(chunk).toString("utf-8")
 		}
+		if (typeof chunk === "string") {
+			return chunk
+		}
+		// Handle comma-separated byte values or other array-like formats
+		return Buffer.from(chunk).toString("utf-8")
 	}
 
 	private validateCredentials(): void {
@@ -526,7 +526,7 @@ export class SapAiCoreHandler implements ApiHandler {
 			if (!expiresIn) {
 				throw new Error("Destination is missing required authTokens with expiresIn")
 			}
-			this.destinationExpiresAt = Date.now() + parseInt(expiresIn, 10) * 1000
+			this.destinationExpiresAt = Date.now() + Number.parseInt(expiresIn, 10) * 1000
 		}
 	}
 
@@ -849,20 +849,21 @@ export class SapAiCoreHandler implements ApiHandler {
 
 				if (error.response.status === 404) {
 					throw new Error(`404 Not Found: ${errorMessage}`)
-				} else if (error.response.status === 400) {
+				}
+				if (error.response.status === 400) {
 					throw new Error(`400 Bad Request: ${errorMessage}`)
 				}
 
 				throw new Error(`HTTP ${error.response.status}: ${errorMessage}`)
-			} else if (error.request) {
+			}
+			if (error.request) {
 				// The request was made but no response was received
 				Logger.error("Error request:", error.request)
 				throw new Error("No response received from server")
-			} else {
-				// Something happened in setting up the request that triggered an Error
-				Logger.error("Error message:", error.message)
-				throw new Error(`Error setting up request: ${error.message}`)
 			}
+			// Something happened in setting up the request that triggered an Error
+			Logger.error("Error message:", error.message)
+			throw new Error(`Error setting up request: ${error.message}`)
 		}
 	}
 

src/core/api/providers/vercel-ai-gateway.ts

@@ -84,7 +84,12 @@ export class VercelAIGatewayHandler implements ApiHandler {
 
 				// Reasoning tokens are returned separately from the content
 				// Skip reasoning content for models that don't support it (e.g., devstral, grok-4)
-				if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
+				if (
+					delta &&
+					"reasoning" in delta &&
+					delta.reasoning &&
+					!shouldSkipReasoningForModel(this.options.openRouterModelId)
+				) {
 					yield {
 						type: "reasoning",
 						reasoning: typeof delta.reasoning === "string" ? delta.reasoning : JSON.stringify(delta.reasoning),
@@ -93,6 +98,7 @@ export class VercelAIGatewayHandler implements ApiHandler {
 
 				// Reasoning details that can be passed back in API requests to preserve reasoning traces
 				if (
+					delta &&
 					"reasoning_details" in delta &&
 					delta.reasoning_details &&
 					// @ts-expect-error-next-line

src/core/api/transform/__tests__/tool-parsing.test.ts

@@ -37,7 +37,7 @@ describe("Tool Call Parsing", () => {
 				},
 			]
 
-			const result = convertToOpenAiMessages(messages)
+			const result = convertToOpenAiMessages(messages, "openai-native")
 
 			result.should.have.length(1)
 			const msg = result[0] as any
@@ -64,7 +64,7 @@ describe("Tool Call Parsing", () => {
 				},
 			]
 
-			const result = convertToOpenAiMessages(messages)
+			const result = convertToOpenAiMessages(messages, "openai-native")
 
 			const msg = result[0] as any
 			msg.tool_calls[0].id.length.should.be.belowOrEqual(40)

src/core/api/transform/openai-format.ts

@@ -1,5 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
+import { ApiProvider } from "@/shared/api"
 import {
 	ClineAssistantRedactedThinkingBlock,
 	ClineAssistantThinkingBlock,
@@ -27,20 +28,25 @@ function isOpenAIResponseToolId(callId: string): boolean {
 
 /**
  * Transforms a tool ID to a consistent format for OpenAI's Chat Completions API.
+ * NOTE: We do not want to transform tool IDs for non-OpenAI providers that may have different requirements.
  * This function MUST be used for both tool_calls[].id (assistant) and tool_call_id (tool result)
  * to ensure they match - otherwise OpenAI will reject the request with:
  * "Invalid parameter: 'tool_call_id' of 'xxx' not found in 'tool_calls' of previous message."
  *
  * @param toolId - The original tool ID from Cline/Anthropic format
+ * @param provider - The API provider that the OpenAI formatted messages will be sent to
  * @returns The transformed ID suitable for OpenAI API
  */
-function transformToolCallId(toolId: string): string {
+function transformToolCallIdForNativeApi(toolId: string, provider?: ApiProvider): string {
 	// OpenAI Responses API uses "fc_" prefix with 53 char length
 	// Convert these to "call_" prefix format for Chat Completions API
 	if (isOpenAIResponseToolId(toolId)) {
 		// Use the last 33 chars + "call_" (5 chars) to stay under the 40-char limit.
 		return `call_${toolId.slice(toolId.length - (MAX_TOOL_CALL_ID_LENGTH - 5))}`
 	}
+	if (provider !== "openai-native") {
+		return toolId
+	}
 	// Ensure ID doesn't exceed max length
 	if (toolId.length > MAX_TOOL_CALL_ID_LENGTH) {
 		return toolId.slice(0, MAX_TOOL_CALL_ID_LENGTH)
@@ -55,10 +61,12 @@ function transformToolCallId(toolId: string): string {
  * into OpenAI's expected message structure, including tool_calls and tool_call_id fields.
  *
  * @param anthropicMessages - Array of ClineStorageMessage objects to be converted
+ * @param provider - Optional parameter to indicate the API provider, which may affect ID transformation logic
  * @returns Array of OpenAI.Chat.ChatCompletionMessageParam objects
  */
 export function convertToOpenAiMessages(
 	anthropicMessages: Omit<ClineStorageMessage, "modelInfo">[],
+	provider?: ApiProvider,
 ): OpenAI.Chat.ChatCompletionMessageParam[] {
 	const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = []
 
@@ -120,7 +128,7 @@ export function convertToOpenAiMessages(
 						role: "tool",
 						// The tool_call_id must match the id used in the assistant's tool_calls array.
 						// Use the same transformation logic as tool_calls to ensure IDs match.
-						tool_call_id: transformToolCallId(toolMessage.tool_use_id),
+						tool_call_id: transformToolCallIdForNativeApi(toolMessage.tool_use_id, provider),
 						content: content,
 					})
 				})
@@ -233,7 +241,7 @@ export function convertToOpenAiMessages(
 
 					return {
 						// Use the same transformation as tool_call_id to ensure IDs match
-						id: transformToolCallId(toolId),
+						id: transformToolCallIdForNativeApi(toolId, provider),
 						type: "function",
 						function: {
 							name: toolMessage.name,

src/core/api/transform/openai-response-format.ts

@@ -85,7 +85,10 @@ export function convertToOpenAIResponsesInput(
 	if (options?.usePreviousResponseId) {
 		for (let i = _messages.length - 1; i >= 0; i--) {
 			const msg = _messages[i]
-			if (msg.role === "assistant" && msg.id) {
+			// Must be less than 24 hours old to be considered for chaining as the previous Id is only valid for 24 hours.
+			// Set to 23 hours to account for any potential delays in processing.
+			const isLessThan23HoursOld = msg.ts ? Date.now() - msg.ts < 23 * 60 * 60 * 1000 : false
+			if (msg.role === "assistant" && msg.id && isLessThan23HoursOld) {
 				previousResponseId = msg.id
 				messages = _messages.slice(i + 1)
 				break

src/core/api/transform/openrouter-stream.ts

@@ -5,8 +5,8 @@ import {
 	OPENROUTER_PROVIDER_PREFERENCES,
 	openRouterClaudeOpus461mModelId,
 	openRouterClaudeSonnet41mModelId,
-	openRouterClaudeSonnet461mModelId,
 	openRouterClaudeSonnet451mModelId,
+	openRouterClaudeSonnet461mModelId,
 } from "@shared/api"
 import { normalizeOpenaiReasoningEffort } from "@shared/storage/types"
 import { shouldSkipReasoningForModel, supportsReasoningEffortForModel } from "@utils/model-utils"
@@ -80,6 +80,7 @@ export async function createOpenRouterStream(
 		case "minimax/minimax-m2":
 		case "minimax/minimax-m2.1":
 		case "minimax/minimax-m2.1-lightning":
+		case "minimax/minimax-m2.5":
 			openAiMessages[0] = {
 				role: "system",
 				content: [

src/core/api/transform/vercel-ai-gateway-stream.ts

@@ -4,8 +4,8 @@ import {
 	ModelInfo,
 	openRouterClaudeOpus461mModelId,
 	openRouterClaudeSonnet41mModelId,
-	openRouterClaudeSonnet461mModelId,
 	openRouterClaudeSonnet451mModelId,
+	openRouterClaudeSonnet461mModelId,
 } from "@shared/api"
 import { normalizeOpenaiReasoningEffort } from "@shared/storage/types"
 import { shouldSkipReasoningForModel, supportsReasoningEffortForModel } from "@utils/model-utils"

src/core/api/utils/messages_api_support.ts

@@ -0,0 +1,150 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index"
+import { Stream as AnthropicStream } from "@anthropic-ai/sdk/streaming"
+import type { ChatCompletionTool as OpenAITool } from "openai/resources/chat/completions"
+import { ApiStream } from "../transform/stream"
+
+export async function* handleAnthropicMessagesApiStreamResponse(
+	stream: AnthropicStream<Anthropic.RawMessageStreamEvent>,
+): ApiStream {
+	const lastStartedToolCall = { id: "", name: "", arguments: "" }
+
+	for await (const chunk of stream) {
+		switch (chunk?.type) {
+			case "message_start": {
+				const usage = chunk.message.usage
+				yield {
+					type: "usage",
+					inputTokens: usage.input_tokens || 0,
+					outputTokens: usage.output_tokens || 0,
+					cacheWriteTokens: usage.cache_creation_input_tokens || undefined,
+					cacheReadTokens: usage.cache_read_input_tokens || undefined,
+				}
+				break
+			}
+			case "message_delta":
+				yield {
+					type: "usage",
+					inputTokens: 0,
+					outputTokens: chunk.usage.output_tokens || 0,
+				}
+				break
+			case "message_stop":
+				break
+			case "content_block_start":
+				switch (chunk.content_block.type) {
+					case "thinking":
+						yield {
+							type: "reasoning",
+							reasoning: chunk.content_block.thinking || "",
+							signature: chunk.content_block.signature,
+						}
+						break
+					case "redacted_thinking":
+						// Content is encrypted, and we don't want to pass placeholder text back to the API
+						yield {
+							type: "reasoning",
+							reasoning: "[Redacted thinking block]",
+							redacted_data: chunk.content_block.data,
+						}
+						break
+					case "tool_use":
+						if (chunk.content_block.id && chunk.content_block.name) {
+							lastStartedToolCall.id = chunk.content_block.id
+							lastStartedToolCall.name = chunk.content_block.name
+							lastStartedToolCall.arguments = ""
+						}
+						break
+					case "text":
+						if (chunk.index > 0) {
+							yield {
+								type: "text",
+								text: "\n",
+							}
+						}
+						yield {
+							type: "text",
+							text: chunk.content_block.text,
+						}
+						break
+				}
+				break
+			case "content_block_delta":
+				switch (chunk.delta.type) {
+					case "thinking_delta":
+						yield {
+							type: "reasoning",
+							reasoning: chunk.delta.thinking,
+						}
+						break
+					case "signature_delta":
+						if (chunk.delta.signature) {
+							yield {
+								type: "reasoning",
+								reasoning: "",
+								signature: chunk.delta.signature,
+							}
+						}
+						break
+					case "text_delta":
+						yield {
+							type: "text",
+							text: chunk.delta.text,
+						}
+						break
+					case "input_json_delta":
+						if (lastStartedToolCall.id && lastStartedToolCall.name && chunk.delta.partial_json) {
+							yield {
+								type: "tool_calls",
+								tool_call: {
+									...lastStartedToolCall,
+									function: {
+										...lastStartedToolCall,
+										id: lastStartedToolCall.id,
+										name: lastStartedToolCall.name,
+										arguments: chunk.delta.partial_json,
+									},
+								},
+							}
+						}
+						break
+				}
+				break
+			case "content_block_stop":
+				lastStartedToolCall.id = ""
+				lastStartedToolCall.name = ""
+				lastStartedToolCall.arguments = ""
+				break
+		}
+	}
+}
+
+export function convertOpenAIToolsToAnthropicTools(tools?: OpenAITool[]): AnthropicTool[] | undefined {
+	if (!tools?.length) {
+		return undefined
+	}
+
+	const anthropicTools: AnthropicTool[] = []
+
+	for (const tool of tools) {
+		if (tool?.type !== "function" || !tool.function?.name) {
+			continue
+		}
+
+		const fn = tool.function
+
+		const hasSchemaObject = fn.parameters && typeof fn.parameters === "object"
+		const inputSchema = hasSchemaObject ? { ...fn.parameters } : {}
+		if (typeof (inputSchema as { type?: unknown }).type !== "string") {
+			;(inputSchema as { type: string }).type = "object"
+		}
+
+		anthropicTools.push({
+			name: fn.name,
+			description: fn.description || undefined,
+			input_schema: inputSchema as AnthropicTool["input_schema"],
+		})
+	}
+
+	return anthropicTools.length > 0 ? anthropicTools : undefined
+}

src/core/assistant-message/parse-assistant-message.ts

@@ -1,4 +1,4 @@
-import { ClineDefaultTool, toolUseNames } from "@shared/tools"
+import { ClineDefaultTool, getToolUseNames } from "@shared/tools"
 import { nanoid } from "nanoid"
 import { AssistantMessageContent, TextStreamContent, ToolParamName, ToolUse, toolParamNames } from "." // Assuming types are defined in index.ts or a similar file
 
@@ -35,9 +35,9 @@ export function parseAssistantMessageV2(assistantMessage: string): AssistantMess
 	let currentParamName: ToolParamName | undefined
 
 	// Precompute tags for faster lookups
-	const toolUseOpenTags = new Map<string, ClineDefaultTool>()
+	const toolUseOpenTags = new Map<string, string>()
 	const toolParamOpenTags = new Map<string, ToolParamName>()
-	for (const name of toolUseNames) {
+	for (const name of getToolUseNames()) {
 		toolUseOpenTags.set(`<${name}>`, name)
 	}
 	for (const name of toolParamNames) {
@@ -173,7 +173,7 @@ export function parseAssistantMessageV2(assistantMessage: string): AssistantMess
 					// Start the new tool use
 					currentToolUse = {
 						type: "tool_use",
-						name: toolName,
+						name: toolName as ClineDefaultTool,
 						params: {},
 						partial: true, // Assume partial until closing tag is found
 						call_id: nanoid(8),

src/core/controller/dictation/cancelRecording.ts

@@ -1,33 +0,0 @@
-import { RecordingResult } from "@shared/proto/cline/dictation"
-import { audioRecordingService } from "@/services/dictation/AudioRecordingService"
-import { telemetryService } from "@/services/telemetry"
-import { Logger } from "@/shared/services/Logger"
-import { Controller } from ".."
-
-/**
- * Cancels audio recording without saving or transcribing the audio
- * @param controller The controller instance
- * @returns RecordingResult indicating success or failure
- */
-export const cancelRecording = async (controller: Controller): Promise<RecordingResult> => {
-	const taskId = controller.task?.taskId
-	const recordingStatus = audioRecordingService.getRecordingStatus()
-	const recordingDuration = recordingStatus.durationSeconds * 1000 // Convert to milliseconds
-	let errorMessage = ""
-	let isSuccess = true
-	try {
-		const result = await audioRecordingService.cancelRecording()
-		isSuccess = !!result?.success
-		errorMessage = result?.error ?? ""
-	} catch (error) {
-		Logger.error("Error canceling recording:", error)
-		isSuccess = false
-		errorMessage = error instanceof Error ? error.message : "Unknown error occurred"
-	}
-
-	telemetryService.captureVoiceRecordingStopped(taskId, recordingDuration, false, process.platform)
-	return RecordingResult.create({
-		success: isSuccess,
-		error: errorMessage ?? "",
-	})
-}

src/core/controller/dictation/getRecordingStatus.ts

@@ -1,26 +0,0 @@
-import { RecordingStatus } from "@shared/proto/cline/dictation"
-import { audioRecordingService } from "@/services/dictation/AudioRecordingService"
-import { Logger } from "@/shared/services/Logger"
-
-/**
- * Gets the current recording status
- * @returns RecordingStatus with current status
- */
-export const getRecordingStatus = async (): Promise<RecordingStatus> => {
-	try {
-		const status = audioRecordingService.getRecordingStatus()
-
-		return RecordingStatus.create({
-			isRecording: status.isRecording,
-			durationSeconds: status.durationSeconds,
-			error: status.error ?? "",
-		})
-	} catch (error) {
-		Logger.error("Error getting recording status:", error)
-		return RecordingStatus.create({
-			isRecording: false,
-			durationSeconds: 0,
-			error: error instanceof Error ? error.message : "Unknown error occurred",
-		})
-	}
-}

src/core/controller/dictation/startRecording.ts

@@ -1,164 +0,0 @@
-import { RecordingResult } from "@shared/proto/cline/dictation"
-import * as os from "os"
-import { HostProvider } from "@/hosts/host-provider"
-import { audioRecordingService } from "@/services/dictation/AudioRecordingService"
-import { telemetryService } from "@/services/telemetry"
-import { AUDIO_PROGRAM_CONFIG } from "@/shared/audioProgramConstants"
-import { ShowMessageType } from "@/shared/proto/host/window"
-import { Logger } from "@/shared/services/Logger"
-import { Controller } from ".."
-
-/**
- * Handles the installation of missing dependencies with Cline
- */
-async function handleInstallWithCline(
-	controller: Controller,
-	dependencyName: string,
-	installCommand: string,
-	platform: string,
-): Promise<void> {
-	const platformName = platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : "Linux"
-	const installTask = `Please install ${dependencyName} for voice recording on ${platformName}.\n\nRun this command:\n\`\`\`bash\n${installCommand}\n\`\`\`\n\nThis will enable voice recording functionality in Cline.`
-
-	// Clear any existing task and start the installation task
-	await controller.clearTask()
-	await controller.postStateToWebview()
-	await controller.initTask(installTask)
-
-	Logger.log(`[handleInstallWithCline] Started task to install ${dependencyName}`)
-}
-
-/**
- * Handles copying the installation command to clipboard
- */
-async function handleCopyCommand(installCommand: string): Promise<void> {
-	await HostProvider.env.clipboardWriteText({ value: installCommand })
-	await HostProvider.window.showMessage({
-		type: ShowMessageType.INFORMATION,
-		message: `Installation command copied to clipboard: ${installCommand}`,
-		options: { items: [] },
-	})
-}
-
-/**
- * Handles missing dependency notification and user action
- */
-async function handleMissingDependency(
-	controller: Controller,
-	platform: string,
-	config: (typeof AUDIO_PROGRAM_CONFIG)[keyof typeof AUDIO_PROGRAM_CONFIG],
-): Promise<void> {
-	const installWithCline = "Install with Cline"
-	const installManually = "Copy Command"
-	const dismiss = "Dismiss"
-
-	const action = await HostProvider.window.showMessage({
-		type: ShowMessageType.INFORMATION,
-		message: `${config.dependencyName} is required for voice recording. ${config.installDescription}`,
-		options: { items: [installWithCline, installManually, dismiss] },
-	})
-
-	if (action.selectedOption === installWithCline) {
-		await handleInstallWithCline(controller, config.dependencyName, config.installCommand, platform)
-	} else if (action.selectedOption === installManually) {
-		await handleCopyCommand(config.installCommand)
-	}
-	// If dismiss, do nothing
-}
-
-/**
- * Handles sign-in errors for dictation
- */
-async function handleSignInError(controller: Controller, errorMessage: string): Promise<void> {
-	const signInAction = "Sign in to Cline"
-	const action = await HostProvider.window.showMessage({
-		type: ShowMessageType.ERROR,
-		message: `Voice recording error: ${errorMessage}`,
-		options: { items: [signInAction] },
-	})
-
-	if (action.selectedOption === signInAction) {
-		await controller.authService.createAuthRequest()
-	}
-}
-
-/**
- * Shows a generic error message
- */
-async function showGenericError(errorMessage: string): Promise<void> {
-	await HostProvider.window.showMessage({
-		type: ShowMessageType.ERROR,
-		message: `Voice recording error: ${errorMessage}`,
-		options: { items: [] },
-	})
-}
-
-/**
- * Checks if the recording error is due to missing dependencies
- */
-function isMissingDependencyError(
-	error: string | undefined,
-	config: (typeof AUDIO_PROGRAM_CONFIG)[keyof typeof AUDIO_PROGRAM_CONFIG] | undefined,
-): boolean {
-	return !!(error && config && error.includes(config.error))
-}
-
-/**
- * Starts audio recording using the Extension Host
- * @param controller The controller instance
- * @returns RecordingResult with success status
- */
-export const startRecording = async (controller: Controller): Promise<RecordingResult> => {
-	const taskId = controller.task?.taskId
-
-	try {
-		// Verify user authentication
-		const userInfo = controller.authService.getInfo()
-		if (!userInfo?.user?.uid) {
-			throw new Error("Please sign in to your Cline Account to use Dictation.")
-		}
-
-		// Attempt to start recording
-		const result = await audioRecordingService.startRecording()
-
-		// Handle successful recording start
-		if (result.success) {
-			telemetryService.captureVoiceRecordingStarted(taskId, process.platform)
-			return RecordingResult.create({
-				success: true,
-				error: "",
-			})
-		}
-
-		// Check if the error is due to missing dependencies
-		const platform = os.platform() as keyof typeof AUDIO_PROGRAM_CONFIG
-		const config = AUDIO_PROGRAM_CONFIG[platform]
-
-		if (isMissingDependencyError(result.error, config)) {
-			// Don't await - show dialog asynchronously so frontend gets immediate response
-			handleMissingDependency(controller, platform, config)
-		}
-
-		return RecordingResult.create({
-			success: false,
-			error: result.error || "",
-		})
-	} catch (error) {
-		Logger.error("Error starting recording:", error)
-		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred"
-
-		// Handle different error types
-		if (errorMessage.includes("sign in")) {
-			// Don't await - show dialog asynchronously so frontend gets immediate response
-			handleSignInError(controller, errorMessage)
-		} else {
-			// Don't await - show dialog asynchronously so frontend gets immediate response
-			showGenericError(errorMessage)
-		}
-
-		return RecordingResult.create({
-			success: false,
-			error: errorMessage,
-		})
-	}
-}

src/core/controller/dictation/stopRecording.ts

@@ -1,38 +0,0 @@
-import { RecordedAudio } from "@shared/proto/cline/dictation"
-import { audioRecordingService } from "@/services/dictation/AudioRecordingService"
-import { telemetryService } from "@/services/telemetry"
-import { Logger } from "@/shared/services/Logger"
-import { Controller } from ".."
-
-/**
- * Stops audio recording and returns the recorded audio
- * @param controller The controller instance
- * @returns RecordedAudio with audio data
- */
-export const stopRecording = async (controller: Controller): Promise<RecordedAudio> => {
-	const taskId = controller.task?.taskId
-	const recordingStatus = audioRecordingService.getRecordingStatus()
-	const recordingDuration = recordingStatus.durationSeconds * 1000 // Convert to milliseconds
-
-	try {
-		const result = await audioRecordingService.stopRecording()
-
-		telemetryService.captureVoiceRecordingStopped(taskId, recordingDuration, result.success, process.platform)
-
-		return RecordedAudio.create({
-			success: result.success,
-			audioBase64: result.audioBase64 ?? "",
-			error: result.error ?? "",
-		})
-	} catch (error) {
-		Logger.error("Error stopping recording:", error)
-
-		telemetryService.captureVoiceRecordingStopped(taskId, recordingDuration, false, process.platform)
-
-		return RecordedAudio.create({
-			success: false,
-			audioBase64: "",
-			error: error instanceof Error ? error.message : "Unknown error occurred",
-		})
-	}
-}

src/core/controller/dictation/transcribeAudio.ts

@@ -1,74 +0,0 @@
-import { TranscribeAudioRequest, Transcription } from "@shared/proto/cline/dictation"
-import { HostProvider } from "@/hosts/host-provider"
-import { getVoiceTranscriptionService } from "@/services/dictation/VoiceTranscriptionService"
-import { telemetryService } from "@/services/telemetry"
-import { ShowMessageType } from "@/shared/proto/host/window"
-import { Logger } from "@/shared/services/Logger"
-import { Controller } from ".."
-
-/**
- * Transcribes audio using Cline transcription service
- * @param controller The controller instance
- * @param request TranscribeAudioRequest containing base64 audio data
- * @returns Transcription with transcribed text or error
- */
-export const transcribeAudio = async (controller: Controller, request: TranscribeAudioRequest): Promise<Transcription> => {
-	const taskId = controller.task?.taskId
-	const startTime = Date.now()
-
-	// Capture telemetry for transcription start
-	telemetryService.captureVoiceTranscriptionStarted(taskId, request.language ?? "en")
-
-	try {
-		// Transcribe the audio
-		const result = await getVoiceTranscriptionService().transcribeAudio(request.audioBase64, request.language ?? "en")
-		const durationMs = Date.now() - startTime
-
-		if (result.error) {
-			let errorType = "api_error"
-			if (result.error.includes("Authentication failed")) {
-				errorType = "invalid_jwt_token"
-			} else if (result.error.includes("Insufficient credits")) {
-				errorType = "insufficient_credits"
-			} else if (result.error.includes("Invalid audio format")) {
-				errorType = "invalid_audio_format"
-			} else if (result.error.includes("No internet connection")) {
-				errorType = "no_internet"
-			} else if (result.error.includes("Cannot connect")) {
-				errorType = "connection_error"
-			} else if (result.error.includes("Connection timed out")) {
-				errorType = "timeout_error"
-			} else if (result.error.includes("Network error")) {
-				errorType = "network_error"
-			}
-
-			telemetryService.captureVoiceTranscriptionError(taskId, errorType, result.error, durationMs)
-
-			// Use the error message directly from the service as it's already user-friendly
-			const errorMessage = result.error
-
-			HostProvider.window.showMessage({
-				type: ShowMessageType.ERROR,
-				message: errorMessage,
-			})
-		} else if (result.text) {
-			telemetryService.captureVoiceTranscriptionCompleted(taskId, result.text.length, durationMs, request.language ?? "en")
-		}
-
-		return Transcription.create({
-			text: result.text ?? "",
-			error: result.error ?? "",
-		})
-	} catch (error) {
-		Logger.error("Error transcribing audio:", error)
-		const durationMs = Date.now() - startTime
-		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred"
-
-		telemetryService.captureVoiceTranscriptionError(taskId, "unexpected_error", errorMessage, durationMs)
-
-		return Transcription.create({
-			text: "",
-			error: errorMessage,
-		})
-	}
-}