docs.json

changeset
migrate custom model config section
2026-09-12 09:14:50 +08:00 · 2025-05-06 13:04:58 -05:00 · 2025-05-05 11:38:32 -05:00 · 2025-05-05 11:38:03 -05:00
262 changed files with 3495 additions and 20233 deletions
@@ -1,5 +0,0 @@
---
-"claude-dev": patch
---
-
-fix eternal loading states when the last message is a checkpoint
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Add the o4-mini model in the isOminiModel
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Allow option to collect events to send them in a bundle to avoid sending too many events
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+add open ai cache to ui
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Moved rule file conversions
@@ -1,5 +0,0 @@
---
-"claude-dev": minor
---
-
-Recent task list is now collapsible, allowing users to hide their recent tasks (e.g. when sharing their screen).
@@ -1,5 +0,0 @@
---
-"claude-dev": minor
---
-
-Add detection for new users to display special components
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+getRelativePaths protobus migration
@@ -1,5 +0,0 @@
---
-"claude-dev": patch
---
-
-selectImages protos migration
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Add confirmation dialog to Delete All History button
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+breakpoint just in system prompt for gemini for OR and cline provider
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add npm script for issue creation
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Extend ReasoningEffort to non-o3-mini reasoning models for all providers
@@ -1,5 +0,0 @@
---
-"claude-dev": patch
---
-
-askResponse protobus migration
@@ -1,5 +0,0 @@
---
-"claude-dev": patch
---
-
-Finishing the migration of Vscode Advanced settings to Settings Webview
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+updated gemini caching for OR and cline provider
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+adding quote reply support
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Make Previous Updates in the Announcement a dropdown
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate prompting section to new docs
@@ -1,5 +0,0 @@
---
-"claude-dev": minor
---
-
-adds global endpoint for vertex ai users
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate custom model config section to new docs
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+add ui for windsurf and cursor rules
@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Batch selection and deletion of tasks in history
@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Migrate getting-started section to new docs
@@ -1,5 +0,0 @@
---
-"claude-dev": minor
---
-
-Add Tailwind CSS IntelliSense to the the recommended extensions list
@@ -2,4 +2,4 @@
 "claude-dev": minor
 ---

-new workflow feature
+Task Timeline
@@ -209,7 +209,7 @@ class Task {
        switch (chunk.type) {
          case "text":
            // Parse into content blocks
-            this.assistantMessageContent = parseAssistantMessageV2(chunk.text)
+            this.assistantMessageContent = parseAssistantMessage(chunk.text)
            // Present blocks to user
            await this.presentAssistantMessage()
            break
@@ -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-[var(--vscode-foreground)]",
-						indicator:
-							"text-[var(--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>
@@ -1,4 +1,4 @@
-blank_issues_enabled: true
+blank_issues_enabled: false
 contact_links:
    - name: ✨ Feature Request
      url: https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop
@@ -33,7 +33,6 @@ jobs:
              uses: morfien101/actions-authorized-user@4a3cfbf0bcb3cafe4a71710a278920c5d94bb38b
              with:
                  username: ${{ github.actor }}
-                  org: ${{ github.repository_owner }}
                  team: "deployer"
                  github_token: ${{ secrets.GITHUB_TOKEN }}

@@ -23,7 +23,7 @@ jobs:
        uses: ./.github/workflows/test.yml

    publish:
-        needs: test
+        # needs: test
        name: Publish Extension
        runs-on: ubuntu-latest
        environment: publish
@@ -1,6 +1,5 @@
 out
 dist
-dist-standalone
 node_modules
 tmp
 .vscode-test/
@@ -19,4 +18,4 @@ coverage
 # But don't ignore the coverage scripts in .github/scripts/
 !.github/scripts/coverage/

-*evals.env
+*evals.env
@@ -1,10 +1,5 @@
 {
 	// See http://go.microsoft.com/fwlink/?LinkId=827846
 	// for the documentation about the extensions.json format
-	"recommendations": [
-		"dbaeumer.vscode-eslint",
-		"connor4312.esbuild-problem-matchers",
-		"ms-vscode.extension-test-runner",
-		"bradlc.vscode-tailwindcss"
-	]
+	"recommendations": ["dbaeumer.vscode-eslint", "connor4312.esbuild-problem-matchers", "ms-vscode.extension-test-runner"]
 }
@@ -16,45 +16,6 @@
 				"IS_DEV": "true",
 				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
 			}
-		},
-		{
-			"name": "Run Extension (Fresh Install Mode)",
-			"type": "extensionHost",
-			"request": "launch",
-			"runtimeExecutable": "${execPath}",
-			"args": [
-				"--profile-temp",
-				"--sync",
-				"off",
-				"--disable-extensions",
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"${workspaceFolder}"
-			],
-			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
-			"preLaunchTask": "clean-sandbox",
-			"internalConsoleOptions": "openOnSessionStart",
-			"postDebugTask": "stop",
-			"env": {
-				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
-			}
-		},
-		{
-			"type": "node",
-			"request": "launch",
-			"name": "Run Standalone Extension",
-			"skipFiles": ["<node_internals>/**"],
-			"sourceMaps": true,
-			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
-			"cwd": "${workspaceFolder}/dist-standalone",
-			"outFiles": ["${workspaceFolder}/dist-standalone/**/*.js"],
-			"preLaunchTask": "compile-standalone",
-			"env": {
-				"GRPC_TRACE": "all",
-				"GRPC_VERBOSITY": "DEBUG",
-				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules"
-			},
-			"program": "standalone.js"
 		}
 	]
 }
@@ -3,16 +3,6 @@
 {
 	"version": "2.0.0",
 	"tasks": [
-		{
-			"label": "compile-standalone",
-			"type": "npm",
-			"script": "compile-standalone",
-			"group": "build",
-			"problemMatcher": [],
-			"presentation": {
-				"reveal": "always"
-			}
-		},
 		{
 			"label": "npm: protos",
 			"type": "npm",
@@ -195,12 +185,6 @@
 			"label": "stop",
 			"command": "echo ${input:terminate}",
 			"type": "shell"
-		},
-		{
-			"label": "clean-sandbox",
-			"type": "shell",
-			"dependsOn": ["watch"],
-			"command": "rm -rf .vscode-dev"
 		}
 	],
 	"inputs": [
@@ -1,78 +1,5 @@
 # Changelog

-## [3.15.5]
-
-   Fix inefficient memory management in the task timeline 
-   Fix Gemini rate limitation response not being handled properly (Thanks @BarreiroT!)
-
-## [3.15.4]
-
-   Add gemini model back to vertex provider
-   Add gemini telemetry
-   Add filtering for tasks tied to the current workspace
-
-## [3.15.3]
-
-   Add Fireworks API Provider
-   Fix minor visual issues with auto-approve menu
-   Fix one instance of terminal not getting output
-   Fix 'Chrome was launched but debug port is not responding' error
-
-## [3.15.2]
-
-   Added details to auto approve menu and more sensible default controls
-   Add detailed configuration options for LiteLLM provider
-   Add webview telemetry for users who have opted in to telemetry
-   Update Gemini in OpenRouter/Cline providers to use implicit caching
-   Fix freezing issues during rendering of large streaming text
-   Fix grey screen webview crashes by releasing memory after every diff edit
-   Fix breaking out of diff auto-scroll
-   Fix IME composition Enter auto‑sending edited message
-
-## [3.15.1]
-
-   Fix bug where PowerShell commands weren't given enough time before giving up and showing an error
-
-## [3.15.0]
-
-   Add Task Timeline visualization to tasks (Thanks eomcaleb!)
-   Add cache to ui for OpenAi provider
-   Add FeatureFlagProvider service for the Node.js extension side
-   Add copy buttons to task header and assistant messages
-   Add a more simplified home header was added
-   Add ability to favorite a task, allowing it to be kept when clearing all tasks
-   Add npm script for issue creation (Thanks DaveFres!)
-   Add confirmation dialog to Delete All History button
-   Add ability to allow the user to type their next message into the chat while Cline is taking action
-   Add ability to generate commit message via cline (Thanks zapp88!)
-   Add improvements to caching for gemini models on OpenRouter and Cline providers
-   Add improvements to allow scrolling the file being edited.
-   Add ui for windsurf and cursor rules
-   Add mistral medium-3 model
-   Add option to collect events to send them in a bundle to avoid sending too many events
-   Add support to quote a previous message in chat
-   Add support for Gemini Implicit Caching
-   Add support for batch selection and deletion of tasks in history (Thanks danix800!)
-   Update change suggested models
-   Update fetch cache details from generation endpoint
-   Update converted docs to Mintlify
-   Update the isOminiModel to include o4-mini model (Thanks PeterDaveHello!)
-   Update file size that can be read by Cline, allowing larger files
-   Update defaults for bedrock API models (Thanks Watany!)
-   Update to extend ReasoningEffort to non-o3-mini reasoning models for all providers (Thanks PeterDaveHello!)
-   Update to give error when a user tries to upload an image larger than 7500x7500 pixels
-   Update announcement so that previous updates are in a dropdown
-   Update UI for auto approve with favorited settings
-   Fix bug where certain terminal commands would lock you out of a task
-   Fix only initialize posthog in the webview if the user has opted into telemetry
-   Fix bug where autocapture was on for front-end telemetry
-   Fix for markdown copy excessively escaping characters (Thanks weshoke!)
-   Fix an issue where loading never finished when using an application inference profile for the model ID (Thanks WinterYukky!)
-
-## [3.14.1]
-
-   Disables autocaptures when initializing feature flags
-
 ## [3.14.0]

 -   Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile (Thanks @clicube!)
@@ -36,7 +36,7 @@ Cline offers the option of utilizing AWS credentials or AWS profiles to access A

 <Frame>
 	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-aws-setup-markup%20(1).png"
+		src="/assets/robot_panel_dark.png"
 		alt="AWS Bedrock configuration in Cline settings showing profile authentication setup"
 	/>
 </Frame>
@@ -44,16 +44,16 @@ This guide is tailored for organizations with established GCP environments (leve

 #### 2.1 Choose and Confirm a Region

-Vertex AI supports multiple regions. Select a region that meets your latency, compliance, and capacity needs. Examples include:
+Vertex AI supports eight regions. Select a region that meets your latency, compliance, and capacity needs. Examples include:

 -   **us-east5 (Columbus, Ohio)**
+-   **us-east1 (South Carolina)**
+-   **us-east4 (Northern Virginia)**
 -   **us-central1 (Iowa)**
+-   **us-west1 (The Dalles, Oregon)**
+-   **us-west4 (Las Vegas, Nevada)**
 -   **europe-west1 (Belgium)**
-   **europe-west4 (Netherlands)**
 -   **asia-southeast1 (Singapore)**
-   **global (Global)**
-
-The Global endpoint may offer higher availability and reduce resource exhausted errors. Only Gemini models are supported.

 #### 2.2 Enable the Claude 3.5 Sonnet v2 Model

@@ -76,10 +76,7 @@ The Global endpoint may offer higher availability and reduce resource exhausted
    -   Search for **Cline** and install the extension

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-extension-arrow.png"
-		alt="Cline extension in VS Code"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Cline extension in VS Code" />
 </Frame>

 #### 3.2 Configure Cline Settings
@@ -62,15 +62,10 @@
 					"getting-started/installing-dev-essentials",
 					"getting-started/model-selection-guide",
 					"getting-started/our-favorite-tech-stack",
-					"getting-started/task-management",
 					"getting-started/understanding-context-management",
 					"getting-started/what-is-cline"
 				]
 			},
-			{
-				"group": "Improving Your Prompting Skills",
-				"pages": ["prompting/prompt-engineering-guide", "prompting/cline-memory-bank"]
-			},
 			{
 				"group": "Exploring Cline's Tools",
 				"pages": [
@@ -83,25 +78,8 @@
 				]
 			},
 			{
-				"group": "Enterprise Solutions",
-				"pages": [
-					"enterprise-solutions/cloud-provider-integration",
-					"enterprise-solutions/custom-instructions",
-					"enterprise-solutions/mcp-servers",
-					"enterprise-solutions/security-concerns"
-				]
-			},
-			{
-				"group": "MCP Servers",
-				"pages": [
-					"mcp/mcp-overview",
-					"mcp/adding-mcp-servers-from-github",
-					"mcp/configuring-mcp-servers",
-					"mcp/connecting-to-a-remote-server",
-					"mcp/mcp-marketplace",
-					"mcp/mcp-server-development-protocol",
-					"mcp/mcp-transport-mechanisms"
-				]
+				"group": "Improving Your Prompting Skills",
+				"pages": ["prompting/prompt-engineering-guide", "prompting/cline-memory-bank"]
 			},
 			{
 				"group": "Custom Model Configurations",
@@ -111,18 +89,6 @@
 					"custom-model-configs/gcp-vertex-ai",
 					"custom-model-configs/litellm-and-cline-using-codestral"
 				]
-			},
-			{
-				"group": "Running Models Locally",
-				"pages": [
-					"running-models-locally/read-me-first",
-					"running-models-locally/lm-studio",
-					"running-models-locally/ollama"
-				]
-			},
-			{
-				"group": "More Info",
-				"pages": ["more-info/telemetry"]
 			}
 		]
 	},
@@ -1,39 +0,0 @@
---
-title: "Cloud Provider Integration"
---
-
-Cline supports major cloud providers like AWS Bedrock and Google's Cloud Vertex; whichever your team currently uses is appropriate, and there's no need to change providers to utilize Cline's features.
-
-For the purpose of this document, we assume your organization will use cloud-based frontier models. Cloud inference providers offer cutting-edge capabilities and the flexibility to select models which best suit your needs.
-
-Certain scenarios may warrant using local models, including handling highly sensitive data, applications requiring consistent low-latency responses, or compliance with strict data sovereignty requirements. If your team needs to utilize local models, see [Running Local Models ](/running-models-locally/read-me-first.mdx)with Cline.
-
---
-
-## AWS Bedrock Setup Guides
-
-#### [IAM Security Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (For administrators)
-
-#### [AWS Bedrock setup for Legacy IAM (AWS Credentials)](/custom-model-configs/aws-bedrock-with-credentials-authentication.mdx)
-
-#### [AWS Bedrock setup for SSO token (AWS Profile)](/custom-model-configs/aws-bedrock-with-profile-authentication.mdx)
-
-#### VPC Endpoint Setup
-
-To protect your team's data, Cline supports VPC (Virtual Private Cloud) endpoints, which create private connections between your data and AWS Bedrock. AWS VPCs enhance security by eliminating the need for public IP addresses, network gateways, or complex firewall rules—essentially creating a private highway for data that bypasses the public internet entirely. By keeping traffic within AWS's private network, teams also benefit from lower latency and more predictable performance when accessing services like AWS Bedrock or custom APIs. For those working with confidential information or operating in highly regulated industries like healthcare or finance, VPCs offers the perfect balance between the accessibility of cloud services and the security of private infrastructure.
-
---
-
-1. Consult the [AWS guide](https://docs.aws.amazon.com/bedrock/latest/userguide/vpc-interface-endpoints.html) to creating VPC endpoints. This document specifies pre-requisites and describes the syntax used for creating VPC endpoints.
-2. Follow the directions for [creating a VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) in the AWS console. The image below pertains to steps 4 and 5 of the AWS guide linked above.
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/vpc-console.png" alt="VPC Console" />
-</Frame>
-
-3. Note the IP address of your VPC endpoint, open Cline's settings menu, and select `AWS Bedrock`from the API Provider dropdown.
-4. Click the `Use Custom VPC endpoint`checkbox and enter the IP address of your VPC endpoint
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/vpc-settings-menu.png" alt="VPC Settings Menu" />
-</Frame>
@@ -1,22 +0,0 @@
---
-title: "Custom Instructions"
---
-
-## Building Custom Instructions for Teams
-
-**Creating standardized project instructions ensures that all team members work within consistent guidelines. Start by documenting your project's technical foundation, then identify which information needs to be included in the instructions. The exact scope will vary depending on your team's needs, but generally it's best to provide as much information as possible. By creating comprehensive instructions that all team members follow, you establish a shared understanding of how code should be written, tested, and deployed across your project, resulting in more maintainable and consistent software.**
-
---
-
-Here are a few topics and examples to consider for your team's custom instructions:
-
-1. **Testing framework and specific commands**
-    - "All components must include Jest tests with at least 85% coverage. Run tests using `npm run test:coverage` before submitting any pull request."
-2. **Explicit library preferences**
-    - "Use React Query for data fetching and state management. Avoid Redux unless specifically required for complex global state. For styling, use Tailwind CSS with our custom theme configuration found in `src/styles/theme.js.`"
-3. **Where to find documentation**
-    - "All API documentation is available in our internal Notion workspace under 'Engineering > API Reference'. For component usage examples, refer to our Storybook instance at `https://storybook.internal.company.com`"
-4. **Which MCP servers to use, and for which purposes**
-    - "For database operations, use the Postgres MCP server with credentials stored in 1Password under 'Development > Database'. For deployments, use the AWS MCP server which requires the deployment role from IAM. Refer to `docs/mcp-setup.md` for configuration instructions."
-5. **Coding conventions specific to your project**
-    - "Name all React components using PascalCase and all helper functions using camelCase. Place components in the `src/components` directory organized by feature, not by type. Always use TypeScript interfaces for prop definitions."
@@ -1,25 +0,0 @@
---
-title: "MCP Servers"
---
-
-**Model Context Protocol (MCP) servers expand Cline's capabilities by providing standardized access to external data sources and executable functions. By implementing MCP servers, LLM tools can dynamically retrieve and incorporate relevant information from both local and remote data sources. This capability ensures that the models operate with the most current and contextually appropriate data, improving the accuracy and relevance of their outputs.**
-
---
-
-### Secure Architecture Fundamentals
-
-MCP servers follow a client-server architecture where hosts (LLM applications like Cline) initiate connections through a transport layer to MCP servers. This architecture inherently provides security benefits as it maintains clear separation between components. Enterprise deployments should focus on the proper implementation of this architecture to ensure secure operations, particularly regarding the message exchange patterns and connection lifecycle management. For MCP architecture details, see [MCP Architecture](https://modelcontextprotocol.io/docs/concepts/architecture), and for latest specifications, see [MCP Specifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/).
-
-### Transport Layer Security
-
-For enterprise environments, selecting the appropriate transport mechanism is crucial. While stdio transport works efficiently for local processes, HTTP with Server-Sent Events (SSE) transport requires additional security measures. TLS should be used for all remote connections whenever possible. This is especially important when MCP servers are deployed across different network segments within corporate infrastructure.
-
-### Message Validation and Access Control
-
-The MCP architecture defines standard error codes and message types (Requests, Results, Errors, and Notifications), providing a structured framework for secure communication. Security teams should consider message validation, sanitizing inputs, checking message size limits, and verifying JSON-RPC format. Additionally, implementing resource protection through access controls, path validation, and request rate limiting helps prevent potential abuse of MCP server capabilities.
-
-### Monitoring and Compliance
-
-For enterprise compliance requirements, implementing comprehensive logging of protocol events, message flows, and errors is essential. The MCP architecture supports diagnostic capabilities including health checks, connection state monitoring, and resource usage tracking. Organizations should extend these capabilities to meet their specific compliance needs, particularly for audit trails of all MCP server interactions and resource access patterns.
-
-By leveraging the client-server design of the MCP architecture and implementing appropriate security controls at each layer, enterprises can safely integrate MCP servers into their environments while maintaining their security posture and meeting regulatory requirements.
@@ -1,63 +0,0 @@
---
-title: "Security Concerns"
---
-
-## Enterprise Security with Cline
-
-#### Cline addresses enterprise security concerns through its unique client-side architecture that prioritizes data privacy, secure cloud integration, and transparent operations. Below is a comprehensive overview of how Cline maintains robust security measures for enterprise environments.
-
---
-
-### Client-Side Architecture
-
-Cline operates exclusively as a client-side VSCode extension with zero server-side components. This fundamental design choice ensures that your code and data remain within your secure environment at all times. Unlike traditional AI assistants that send data to external servers for processing, Cline connects directly to your chosen cloud provider's AI endpoints, keeping all sensitive information within your infrastructure boundaries.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-arch.png"
-		alt="Cline's relationship to local and remote assets"
-	/>
-</Frame>
-
-### Data Privacy Commitment
-
-Cline implements a strict zero data retention policy, meaning your intellectual property never leaves your secure environment. The extension does not collect, store, or transmit your code to any central servers. This approach significantly reduces potential attack vectors that might otherwise be introduced through data transmission to third-party systems. Telemetry collection is optional and requires explicit consent.
-
-### Cloud Provider Integration
-
-Enterprise teams can access cutting-edge AI models through their existing cloud deployments. Cline supports seamless integration with:
-
-   AWS Bedrock
-   Google Cloud Vertex AI
-   Microsoft Azure
-
-These integrations utilize your organization's existing security credentials, including native IAM role assumption for AWS. This ensures that all AI processing occurs within your corporate cloud environment, maintaining compliance with your established security protocols.
-
-### Open-Source Transparency
-
-Cline's codebase is completely open-source, allowing for comprehensive security auditing by your internal teams. This transparency enables security professionals to verify exactly how the extension functions and confirm that it adheres to your organization's security requirements. Organizations can review the code to ensure it aligns with their security policies before deployment.
-
-### Controlled Modifications
-
-The extension implements safeguards against unauthorized changes to your codebase. Cline requires explicit user approval for all file modifications and terminal commands, preventing accidental or unwanted alterations. This approval-based workflow maintains the integrity of your projects while still providing AI assistance.
-
-### Enterprise Deployment Support
-
-For organizations with strict security review processes, Cline provides comprehensive documentation including detailed deployment diagrams, sequence diagrams illustrating all data flows, and complete security posture documentation. These materials facilitate thorough security reviews and help demonstrate compliance with enterprise data handling standards and regulations.
-
-### Access Control
-
-Enterprise editions of Cline (planned for Q2 2025) will include centralized administration features that allow organizations to:
-
-   Manage user access with customizable permission levels
-   Provision accounts with corporate credentials
-   Immediately revoke access when needed
-   Control which AI providers and LLM endpoints can be used
-   Deploy standardized settings across the organization
-   Prevent unauthorized use of personal API keys
-
-### Compliance and Governance
-
-Cline's architecture supports compliance with data sovereignty requirements and enterprise data handling regulations. The planned Enterprise Complete edition will further enhance governance with detailed audit logging, compliance reporting, and automated policy enforcement mechanisms.
-
-By combining client-side processing, direct cloud provider integration, and transparent operations, Cline offers enterprise teams a secure way to leverage AI assistance while maintaining strict control over their sensitive code and data.
@@ -28,10 +28,7 @@ After each tool use, you can:
 2. Click the "Restore" button to open restore options

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(13).png"
-		alt="Checkpoint comparison and restore options"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Checkpoint comparison and restore options" />
 </Frame>

 #### Rolling Back
@@ -63,7 +60,7 @@ Checkpoints let you be more experimental with Cline. While human coding is often
 -   Ideal for exploring different design patterns or architectural approaches

 <Frame caption="In this case, I didn't like the changes Cline made to my robot dog-walking website (still working on the robots) and I wanted to revert both the codebase and the task to before any changes were made so I could start fresh.">
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/checkpointsDemo.gif" alt="Checkpoint restore demo" />
+	<img src="/assets/robot_panel_dark.png" alt="Checkpoint restore demo" />
 </Frame>

 ### ✨ Best Practices
@@ -107,8 +104,5 @@ Perhaps you didn't get the results you wanted, thought of a better way to phrase
 -   Shift + Enter: Insert new line / line break

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/message-editing.png"
-		alt="Message editing interface"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Message editing interface" />
 </Frame>
@@ -7,10 +7,7 @@ title: "Plan & Act Modes: A Guide to Effective AI Development"
 Plan & Act modes represent Cline's approach to structured AI development, emphasizing thoughtful planning before implementation. This dual-mode system helps developers create more maintainable, accurate code while reducing iteration time.

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/planningThenActing%20(1).gif"
-		alt="Use Plan to gather context before using Act to implement the plan"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Use Plan to gather context before using Act to implement the plan" />
 </Frame>

 ### Understanding the Modes
@@ -30,7 +27,7 @@ Plan & Act modes represent Cline's approach to structured AI development, emphas
 -   Can execute changes to your codebase

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(5).png" alt="Act mode capabilities" />
+	<img src="/assets/robot_panel_dark.png" alt="Act mode capabilities" />
 </Frame>

 ### Workflow Guide
@@ -42,7 +39,7 @@ Begin every significant development task in Plan mode:
 In this mode:

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(5)%20(1).png" alt="Plan mode workflow" />
+	<img src="/assets/robot_panel_dark.png" alt="Plan mode workflow" />
 </Frame>

 -   Share your requirements
@@ -51,10 +48,7 @@ In this mode:
 -   Develop implementation strategy

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2)%20(1)%20(1)%20(1).png"
-		alt="Planning phase"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Planning phase" />
 </Frame>

 #### 2. Switch to Act Mode
@@ -62,7 +56,7 @@ In this mode:
 Once you have a clear plan, switch to Act mode:

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/switching-to-act.gif" alt="Switching to Act mode" />
+	<img src="/assets/robot_panel_dark.png" alt="Switching to Act mode" />
 </Frame>

 Act mode allows Cline to:
@@ -96,10 +90,7 @@ Complex projects often require multiple plan-act cycles:
 4. Document significant decisions

 <Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(3)%20(1).png"
-		alt="Implementation best practices"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="Implementation best practices" />
 </Frame>

 ### Power User Tips
@@ -128,7 +119,7 @@ Complex projects often require multiple plan-act cycles:
 -   Executing test cases

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(6).png" alt="Mode usage patterns" />
+	<img src="/assets/robot_panel_dark.png" alt="Mode usage patterns" />
 </Frame>

 ### Contributing
@@ -22,10 +22,7 @@ Follow these steps to get Cline up and running:
 4.  **Search for 'Cline':** In the Extensions search bar, type `Cline`.

 <Frame caption="VS Code marketplace with Cline extension ready to install">
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(20).png"
-		alt="VS Code marketplace showing Cline extension"
-	/>
+	<img src="/assets/robot_panel_dark.png" alt="VS Code marketplace showing Cline extension" />
 </Frame>

 1. **Install the Extension:** Click the "Install" button next to the Cline extension.
@@ -28,10 +28,7 @@ Cline helps you manage this limitation with its Context Window Progress Bar, whi
 -   The total capacity for your chosen model

 <Frame caption="Visual representation of the context window usage in Cline">
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(11).png"
-		alt="Context window progress bar example"
-	/>
+	<img src="/assets/robot_panel_light.png" alt="Context window progress bar example" />
 </Frame>

 This visibility helps you work more effectively with Cline by letting you know when you might need to start fresh or break tasks into smaller chunks.
@@ -1,67 +0,0 @@
---
-title: "Task Management in Cline"
-description: "Learn how to effectively manage your task history, use favorites, and organize your work in Cline."
---
-
-# Task Management
-
-As you use Cline, you'll accumulate many tasks over time. The task management system helps you organize, filter, search, and clean up your task history to keep your workspace efficient.
-
-## Accessing Task History
-
-You can access your task history by:
-
-1. Clicking on the "History" button in the Cline sidebar
-2. Using the command palette to search for "Cline: Show Task History"
-
-## Task History Features
-
-The task history view provides several powerful features:
-
-### Searching and Filtering
-
-   **Search Bar**: Use the fuzzy search at the top to quickly find tasks by content
-   **Sort Options**: Sort tasks by:
-    -   Newest (default)
-    -   Oldest
-    -   Most Expensive (highest API cost)
-    -   Most Tokens (highest token usage)
-    -   Most Relevant (when searching)
-   **Favorites Filter**: Toggle to show only favorited tasks
-
-### Task Actions
-
-Each task in the history view has several actions available:
-
-   **Open**: Click on a task to reopen it in the Cline chat
-   **Favorite**: Click the star icon to mark a task as a favorite
-   **Delete**: Remove individual tasks (favorites are protected from deletion)
-   **Export**: Export a task's conversation to markdown
-
-## ⭐ Task Favorites
-
-The favorites feature allows you to mark important tasks that you want to preserve and find quickly.
-
-### How Favorites Work
-
-   **Marking Favorites**: Click the star icon next to any task to toggle its favorite status
-   **Protection**: Favorited tasks are protected from individual and bulk deletion operations (can be overridden)
-   **Filtering**: Use the favorites filter to quickly access your important tasks
-
-## Batch Operations
-
-The task history view supports several batch operations:
-
-   **Select Multiple**: Use the checkboxes to select multiple tasks
-   **Select All/None**: Quickly select or deselect all tasks
-   **Delete Selected**: Remove all selected tasks
-   **Delete All**: Remove all tasks from history (favorites are preserved unless you choose to include them)
-
-## Best Practices
-
-1. **Favorite Important Tasks**: Mark reference tasks or frequently accessed conversations as favorites
-2. **Regular Cleanup**: Periodically remove old or unused tasks to improve performance
-3. **Use Search**: Leverage the fuzzy search to quickly find specific conversations
-4. **Export Valuable Tasks**: Export important tasks to markdown for external reference
-
-Task management helps you maintain an organized workflow when using Cline, allowing you to quickly find past conversations, preserve important work, and keep your history clean and efficient.
@@ -14,7 +14,7 @@ description: "Context is key to getting the most out of Cline"

 <Frame caption="In a world of infinite context, the context window is what Cline currently has available">
 	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2).png"
+		src="/assets/robot_panel_dark.png"
 		alt="In a world of infinite context, the context window is what Cline currently has available"
 	/>
 </Frame>
@@ -65,10 +65,7 @@ Think of context like a whiteboard you and Cline share:
 Cline provides a visual way to monitor your context window usage through a progress bar:

 <Frame caption="Visual representation of the context window usage">
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(1)%20(1).png"
-		alt="Context window progress bar"
-	/>
+	<img src="/assets/robot_panel_light.png" alt="Context window progress bar" />
 </Frame>

 ### Reading the Bar
@@ -1,69 +0,0 @@
---
-title: "Adding MCP Servers from GitHub"
---
-
-This guide provides a step-by-step walkthrough of how to use Cline to build an existing MCP server from a GitHub repository.
-
-## **Finding an MCP Server**
-
-There are multiple places online to find MCP servers:
-
-   **Cline can automatically add MCP servers to its list, which you can then edit.** Cline can clone repositories directly from GitHub and build the servers for you.
-   **GitHub:** Two of the most common places to find MCP servers on GitHub include:
-    -   [Official MCP servers repository](https://github.com/modelcontextprotocol/servers)
-    -   [Awesome-MCP servers repository](https://github.com/punkpeye/awesome-mcp-servers)
-   **Online directories:** Several websites list MCP servers including:
-
-    -   [mcpservers.org](https://mcpservers.org/)
-    -   [mcp.so](https://mcp.so/)
-    -   [glama.ai/mcp/servers](https://glama.ai/mcp/servers)
-
-    These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.
-
-   **PulseMCP:** This website has a blog post discussing how AI could use MCP servers to make websites obsolete. PulseMCP also includes an FAQ section about MCP servers: [https://www.pulsemcp.com/](https://www.pulsemcp.com/)
-
-## **Building with Cline**
-
-1. **Initiate the Process:** Provide Cline with the following information:
-    - **GitHub Repository URL:** The URL of the server's repository.
-    - **README.md Contents:** This is optional but helpful for Cline to understand the server's purpose and configuration. You can copy the README.md file from the GitHub repository.
-2. **Example Interaction with Cline:**
-
-    ```
-    User: "Cline, I want to add the MCP server for Brave browser control. Here's the GitHub link: @https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search Can you add it?"
-
-    Cline: "OK. Cloning the repository to the MCP directory. It needs to be built because it has a 'package.json' file. Should I run 'npm run build'?"
-
-    User: "Yes, build it."
-
-    Cline: "Build complete. This server needs a browser path. Where's your Brave browser executable?"
-
-    User: "It's in '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'."
-
-    Cline: "OK. I've updated the server config with that path and added it to 'cline_mcp_settings.json'. Anything else?"
-
-    User: "No, that's all. Let's test it."
-
-    Cline: "Great! Starting the MCP Inspector to test the server connection. After that, we can try controlling the browser from Cline."
-    ```
-
-3. **Cline's Actions:** Based on your instructions, Cline will perform the following:
-    - **Repository Cloning:** Cline will clone the repository to your local machine, usually in the directory specified in your configuration.
-    - **Tweaking:** You can guide Cline to modify the server's configuration. For instance:
-        - **User:** "This server requires an API key. Can you find where it should be added?"
-        - Cline may automatically update the `cline_mcp_settings.json` file or other relevant files based on your instructions.
-    - **Building the Server:** Cline will run the appropriate build command for the server, which is commonly `npm run build`.
-    - **Adding Server to Settings:** Cline will add the server's configuration to the `cline_mcp_settings.json` file.
-
-## **Testing and Troubleshooting**
-
-1. **Test the Server:** Once Cline finishes the build process, test the server to make sure it works as expected. Cline can assist you if you encounter any problems.
-2. **MCP Inspector:** You can use the MCP Inspector to test the server's connection and functionality.
-
-## **Best Practices**
-
-   **Understand the Basics:** While Cline simplifies the process, it's beneficial to have a basic understanding of the server's code, the MCP protocol ([learn more](/mcp/mcp-overview)), and how to configure the server. This allows for more effective troubleshooting and customization.
-   **Clear Instructions:** Provide clear and specific instructions to Cline throughout the process.
-   **Testing:** Thoroughly test the server after installation and configuration to ensure it functions correctly.
-   **Version Control:** Use a version control system (like Git) to track changes to the server's code.
-   **Stay Updated:** Keep your MCP servers updated to benefit from the latest features and security patches.
@@ -1,166 +0,0 @@
---
-title: "Configuring MCP Servers"
---
-
-## Global MCP Server Inclusion Mode
-
-Utilizing MCP servers will increase your token usage. Cline offers the ability to restrict or disable MCP server functionality as desired.
-
-1. Click the "MCP Servers" icon in the top navigation bar of the Cline extension.
-2. Select the "Installed" tab, and then Click the "Advanced MCP Settings" link at the bottom of that pane.
-3. Cline will open a new settings window. find `Cline>Mcp:Mode` and make your selection from the dropdown menu.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/MCP-settings-edit%20(1).png"
-		alt="MCP settings edit"
-	/>
-</Frame>
-
-## Managing Individual MCP Servers
-
-Each MCP server has its own configuration panel where you can modify settings, manage tools, and control its operation. To access these settings:
-
-1. Click the "MCP Servers" icon in the top navigation bar of the Cline extension.
-2. Locate the MCP server you want to manage in the list, and open it by clicking on its name.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/MCP-settings-individual.png"
-		alt="MCP settings individual"
-	/>
-</Frame>
-
-### Deleting a Server
-
-1. Click the Trash icon next to the MCP server you would like to delete, or the red Delete Server button at the bottom of the MCP server config box.
-
-**NOTE:** There is no delete confirmation dialog box
-
-### Restarting a Server
-
-1. Click the Restart button next to the MCP server you would like to restart, or the gray Restart Server button at the bottom of the MCP server config box.
-
-### Enabling or Disabling a Server
-
-1. Click the toggle switch next to the MCP server to enable/disable servers individually.
-
-### Network Timeout
-
-To set the maximum time to wait for a response after a tool call to the MCP server:
-
-1. Click the `Network Timeout` dropdown at the bottom of the individual MCP server's config box and change the time. Default is 1 minute but it can be set between 30 seconds and 1 hour.
-
-## Editing MCP Settings Files
-
-Settings for all installed MCP servers are located in the `cline_mcp_settings.json` file:
-
-1. Click the MCP Servers icon at the top navigation bar of the Cline pane.
-2. Select the "Installed" tab.
-3. Click the "Configure MCP Servers" button at the bottom of the pane.
-
-The file uses a JSON format with a `mcpServers` object containing named server configurations:
-
-```json
-{
-	"mcpServers": {
-		"server1": {
-			"command": "python",
-			"args": ["/path/to/server.py"],
-			"env": {
-				"API_KEY": "your_api_key"
-			},
-			"alwaysAllow": ["tool1", "tool2"],
-			"disabled": false
-		}
-	}
-}
-```
-
-_Example of MCP Server config in Cline (STDIO Transport)_
-
---
-
-## Understanding Transport Types
-
-MCP supports two transport types for server communication:
-
-### STDIO Transport
-
-Used for local servers running on your machine:
-
-   Communicates via standard input/output streams
-   Lower latency (no network overhead)
-   Better security (no network exposure)
-   Simpler setup (no HTTP server needed)
-   Runs as a child process on your machine
-
-For more in-depth information about how STDIO transport works, see [MCP Transport Mechanisms](/mcp/mcp-transport-mechanisms).
-
-STDIO configuration example:
-
-```json
-{
-	"mcpServers": {
-		"local-server": {
-			"command": "node",
-			"args": ["/path/to/server.js"],
-			"env": {
-				"API_KEY": "your_api_key"
-			},
-			"alwaysAllow": ["tool1", "tool2"],
-			"disabled": false
-		}
-	}
-}
-```
-
-### SSE Transport
-
-Used for remote servers accessed over HTTP/HTTPS:
-
-   Communicates via Server-Sent Events protocol
-   Can be hosted on a different machine
-   Supports multiple client connections
-   Requires network access
-   Allows centralized deployment and management
-
-For more in-depth information about how SSE transport works, see [MCP Transport Mechanisms](/mcp/mcp-transport-mechanisms).
-
-SSE configuration example:
-
-```json
-{
-	"mcpServers": {
-		"remote-server": {
-			"url": "https://your-server-url.com/mcp",
-			"headers": {
-				"Authorization": "Bearer your-token"
-			},
-			"alwaysAllow": ["tool3"],
-			"disabled": false
-		}
-	}
-}
-```
-
---
-
-## Using MCP Tools in Your Workflow
-
-After configuring an MCP server, Cline will automatically detect available tools and resources. To use them:
-
-1. Type your request in Cline's conversation window
-2. Cline will identify when an MCP tool can help with your task
-3. Approve the tool use when prompted (or use auto-approval)
-
-Example: "Analyze the performance of my API" might use an MCP tool that tests API endpoints.
-
-## Troubleshooting MCP Servers
-
-Common issues and solutions:
-
-   **Server Not Responding:** Check if the server process is running and verify network connectivity
-   **Permission Errors:** Ensure proper API keys and credentials are configured in your `mcp_settings.json` file
-   **Tool Not Available:** Confirm the server is properly implementing the tool and it's not disabled in settings
-   **Slow Performance:** Try adjusting the network timeout value for the specific MCP server
@@ -1,132 +0,0 @@
---
-title: "Connecting to a Remote Server"
-description: "The Model Context Protocol (MCP) allows Cline to communicate with external servers that provide additional tools and resources to extend its capabilities. This guide explains how to add and connect to remote MCP servers through the MCP Servers interface."
---
-
-## Adding and Managing Remote MCP Servers
-
-### Accessing the MCP Servers Interface
-
-To access the MCP Servers interface in Cline:
-
-1. Click on the Cline icon in the VSCode sidebar
-2. Open the menu (⋮) in the top right corner of the Cline panel
-3. Select "MCP Servers" from the dropdown menu
-
-### Understanding the MCP Servers Interface
-
-The MCP Servers interface is divided into three main tabs:
-
-   **Marketplace**: Discover and install pre-configured MCP servers (if enabled)
-   **Remote Servers**: Connect to existing MCP servers via URL endpoints
-   **Installed**: Manage your connected MCP servers
-
-### Adding a Remote MCP Server
-
-The "Remote Servers" tab allows you to connect to any MCP server that's accessible via a URL endpoint:
-
-1. Click on the "Remote Servers" tab in the MCP Servers interface
-2. Fill in the required information:
-    - **Server Name**: Provide a unique, descriptive name for the server
-    - **Server URL**: Enter the complete URL endpoint of the MCP server (e.g., `https://example.com/mcp-sse`)
-3. Click "Add Server" to initiate the connection
-4. Cline will attempt to connect to the server and display the connection status
-
-> **Note**: When connecting to a remote server, ensure you trust the source, as MCP servers can execute code in your environment.
-
-### Remote Server Discovery
-
-If you're looking for MCP servers to connect to, several third-party marketplaces provide directories of available servers with various capabilities.
-
-> **Warning**: The following third-party marketplaces are listed for informational purposes only. Cline does not endorse, verify, or take responsibility for any servers listed on these marketplaces. These servers are cloud-hosted services that process your requests and may have access to data you share with them. Always review privacy policies and terms of use before connecting to third-party services.
-
-#### Composio MCP Integration
-
-[Composio's MCP Marketplace](https://mcp.composio.dev/) provides access to a wide range of third-party servers that support the Model Context Protocol (MCP). These servers expose APIs for services like GitHub, Notion, Slack, and others. Each server includes configuration instructions and built-in authentication support (e.g. OAuth or API keys). To connect, locate the desired service in the marketplace and follow the integration steps provided there.
-
-#### Connecting via Smithery
-
-Smithery is a third-party MCP server marketplace that allows users to discover and connect to a variety of Model Context Protocol (MCP) servers. If you're using an MCP-compatible client (such as Cursor, Claude Desktop, or Cline), you can browse available servers and integrate them directly into your workflow.
-
-To explore available options, visit the Smithery marketplace: [https://smithery.ai](https://smithery.ai)
-
-Please note: Smithery is maintained independently and is not affiliated with our project. Use at your own discretion.
-
-### Managing Installed MCP Servers
-
-Once added, your MCP servers appear in the "Installed" tab where you can:
-
-#### View Server Status
-
-Each server displays its current status:
-
-   **Green dot**: Connected and ready to use
-   **Yellow dot**: In the process of connecting
-   **Red dot**: Disconnected or experiencing errors
-
-#### Configure Server Settings
-
-Click on a server to expand its settings panel:
-
-1. **Tools & Resources**:
-    - View all available tools and resources from the server
-    - Configure auto-approval settings for tools (if enabled)
-2. **Request Timeout**:
-    - Set how long Cline should wait for server responses
-    - Options range from 30 seconds to 1 hour
-3. **Server Management**:
-    - **Restart Server**: Reconnect if the server becomes unresponsive
-    - **Delete Server**: Remove the server from your configuration
-
-#### Enable/Disable Servers
-
-Toggle the switch next to each server to enable or disable it:
-
-   **Enabled**: Cline can use the server's tools and resources
-   **Disabled**: The server remains in your configuration but is not active
-
-### Troubleshooting Connection Issues
-
-If a server fails to connect:
-
-1. An error message will be displayed with details about the failure
-2. Check that the server URL is correct and the server is running
-3. Use the "Restart Server" button to attempt reconnection
-4. If problems persist, you can delete the server and try adding it again
-
-### Advanced Configuration
-
-For advanced users, Cline stores MCP server configurations in a JSON file that can be modified:
-
-1. In the "Installed" tab, click "Configure MCP Servers" to access the settings file
-2. The configuration for each server follows this format:
-
-```json
-{
-	"mcpServers": {
-		"exampleServer": {
-			"url": "https://example.com/mcp-sse",
-			"disabled": false,
-			"autoApprove": ["tool1", "tool2"],
-			"timeout": 30
-		}
-	}
-}
-```
-
-Key configuration options:
-
-   **url**: The endpoint URL (for remote servers)
-   **disabled**: Whether the server is currently enabled (true/false)
-   **autoApprove**: List of tool names that don't require confirmation
-   **timeout**: Maximum time in seconds to wait for server responses
-
-For additional MCP settings, click the "Advanced MCP Settings" link to access VSCode settings.
-
-### Using MCP Server Tools
-
-Once connected, Cline can use the tools and resources provided by the MCP server. When Cline suggests using an MCP tool:
-
-1. A tool approval prompt will appear (unless auto-approved)
-2. Review the tool details and parameters before approving
-3. The tool will execute and return results to Cline
@@ -1,199 +0,0 @@
---
-title: "MCP Made Easy"
-description: "Learn how to use the MCP Marketplace to discover, install, and configure MCP servers that enhance Cline's capabilities with additional tools and resources."
---
-
-## What's an MCP Server?
-
-MCP servers are specialized extensions that enhance Cline's capabilities. They enable Cline to perform additional tasks like fetching web pages, processing images, accessing APIs, and much more.
-
-## MCP Marketplace Walkthrough
-
-The MCP Marketplace provides a one-click installation experience for hundreds of MCP servers across various categories.
-
-### 1. Access the Marketplace
-
-   In Cline, click the "Extensions" button (square icon) in the top toolbar
-   The MCP marketplace will open, showing available servers by category
-
-### 2. Browse and Select a Server
-
-   Browse servers by category (Search, File-systems, Browser-automation, Research-data, etc.)
-   Click on a server to see details about its capabilities and requirements
-
-### 3. Install and Configure
-
-   Click the install button for your chosen server
-   If the server requires an API key (most do), Cline will guide you through:
-    -   Where to get the API key
-    -   How to enter it securely
-   The server will be added to your MCP settings automatically
-
-### 4. Verify Installation
-
-   Cline will show confirmation when installation is complete
-   Check the server status in Cline's MCP settings UI
-
-### 5. Using Your New Server
-
-   After successful installation, Cline will automatically integrate the server's capabilities
-   You'll see new tools and resources available in Cline's system prompt
-   Simply ask Cline to use the capabilities of your new server
-   Example: "Search the web for recent React updates using Perplexity"
-
-**Corporate Users:** If you're using Cline in a corporate environment, ensure you have permission to install third-party MCP servers according to your organization's security policies.
-
-## What Happens Behind the Scenes
-
-When you install an MCP server, several things happen automatically:
-
-### 1. Installation Process
-
-   The server code is cloned/installed to `/Users/<username>/Documents/Cline/MCP/`
-   Dependencies are installed
-   The server is built (TypeScript/JavaScript compilation or Python package installation)
-
-### 2. Configuration
-
-   The MCP settings file is updated with your server configuration
-   This file is located at: `/Users/<username>/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
-   Environment variables (like API keys) are securely stored
-   The server path is registered
-
-### 3. Server Launch
-
-   Cline detects the configuration change
-   Cline launches your server as a separate process
-   Communication is established via stdio or HTTP
-
-### 4. Integration with Cline
-
-   Your server's capabilities are added to Cline's system prompt
-   Tools become available via `use_mcp_tool` commands
-   Resources become available via `access_mcp_resource` commands
-   Cline can now use these capabilities when prompted by the user
-
-## Troubleshooting
-
-### System Requirements
-
-Make sure your system meets these requirements:
-
-   **Node.js 18.x or newer**
-    -   Check by running: `node --version`
-    -   Install from: https://nodejs.org/
-    -   Required for JavaScript/TypeScript implementations
-   **Python 3.10 or newer**
-    -   Check by running: `python --version`
-    -   Install from: https://python.org/
-    -   Note: Some specialized implementations may require Python 3.11+
-   **UV Package Manager**
-    -   Modern Python package manager for dependency isolation
-    -   Install using:
-        ```bash
-        curl -LsSf https://astral.sh/uv/install.sh | sh
-        ```
-        Or: `pip install uv`
-    -   Verify with: `uv --version`
-
-If any of these commands fail or show older versions, please install/update before continuing!
-
-### Common Installation Issues
-
-   Ensure your internet connection is stable
-   Check that you have the necessary permissions to install new software
-   Verify that the API key was entered correctly (if required)
-   Check the server status in the MCP settings UI for any error messages
-
-### How to Remove an MCP Server
-
-To completely remove a faulty MCP server:
-
-1. Open the MCP settings file: `/Users/<username>/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
-2. Delete the entire entry for your server from the `mcpServers` object
-3. Save the file
-4. Restart Cline
-
-### I'm Still Getting an Error
-
-If you're getting an error when using an MCP server, you can try the following:
-
-   Check the MCP settings file for errors
-   Use a Claude Sonnet model for installation
-   Verify that paths to your server's files are correct
-   Ensure all required environment variables are set
-   Check if another process is using the same port (for HTTP-based servers)
-   Try removing and reinstalling the server (remove from both the `cline_mcp_settings.json` file and the `/Users/<username>/Documents/Cline/MCP/` directory)
-   Use a terminal and run the command with its arguments directly. This will allow you to see the same errors that Cline is seeing
-
-## MCP Server Rules
-
-Cline is already aware of your active MCP servers and what they are for, but when you have a lot of MCP servers enabled, it can be useful to define when to use each server.
-
-Utilize a `.clinerules` file or custom instructions to support intelligent MCP server activation through keyword-based triggers, making Cline's tool selection more intuitive and context-aware.
-
-### How MCP Rules Work
-
-MCP Rules group your connected MCP servers into functional categories and define trigger keywords that activate them automatically when detected in your conversations with Cline.
-
-```json
-{
-	"mcpRules": {
-		"webInteraction": {
-			"servers": ["firecrawl-mcp-server", "fetch-mcp"],
-			"triggers": ["web", "scrape", "browse", "website"],
-			"description": "Tools for web browsing and scraping"
-		}
-	}
-}
-```
-
-### Configuration Structure
-
-1. **Categories**: Group related servers (e.g., "webInteraction", "mediaAndDesign")
-2. **Servers**: List server names in each category
-3. **Triggers**: Keywords that activate these servers
-4. **Description**: Human-readable category explanation
-
-### Benefits of MCP Rules
-
-   **Contextual Tool Selection**: Cline selects appropriate tools based on conversation context
-   **Reduced Friction**: No need to manually specify which tool to use
-   **Organized Capabilities**: Logically group related tools and servers
-   **Prioritization**: Handle ambiguous cases with explicit priority ordering
-
-### Example Usage
-
-When you write "Can you scrape this website?", Cline detects "scrape" and "website" as triggers, automatically selecting web-related MCP servers.
-
-For finance tasks like "What's Apple's stock price?", keywords like "stock" and "price" trigger finance-related servers.
-
-### Quick Start Template
-
-```json
-{
-	"mcpRules": {
-		"category1": {
-			"servers": ["server-name-1", "server-name-2"],
-			"triggers": ["keyword1", "keyword2", "phrase1", "phrase2"],
-			"description": "Description of what these tools do"
-		},
-		"category2": {
-			"servers": ["server-name-3"],
-			"triggers": ["keyword3", "keyword4", "phrase3"],
-			"description": "Description of what these tools do"
-		},
-		"category3": {
-			"servers": ["server-name-4", "server-name-5"],
-			"triggers": ["keyword5", "keyword6", "phrase4"],
-			"description": "Description of what these tools do"
-		}
-	},
-	"defaultBehavior": {
-		"priorityOrder": ["category1", "category2", "category3"],
-		"fallbackBehavior": "Ask user which tool would be most appropriate"
-	}
-}
-```
-
-Add this to your `.clinerules` file or to your custom instructions to make Cline's MCP server selection more intuitive and context-aware.
@@ -1,107 +0,0 @@
---
-title: "MCP Overview"
-description: "Learn about Model Context Protocol (MCP) servers, their capabilities, and how Cline can help build and use them. MCP standardizes how applications provide context to LLMs, acting like a USB-C port for AI applications."
---
-
-## Quick Links
-
-   [Building MCP Servers from GitHub](/mcp/adding-mcp-servers-from-github)
-   [Building Custom MCP Servers from Scratch](/mcp/mcp-server-development-protocol)
-
-## Overview
-
-Model Context Protocol is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications; it provides a standardized way to connect AI models to different data sources and tools. MCP servers act as intermediaries between large language models (LLMs), such as Claude, and external tools or data sources. They are small programs that expose functionalities to LLMs, enabling them to interact with the outside world through the MCP. An MCP server is essentially like an API that an LLM can use.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/mcp-diagram.png"
-		alt="MCP diagram showing how MCP servers connect LLMs to external tools and data sources"
-	/>
-</Frame>
-
-## Key Concepts
-
-MCP servers define a set of "**tools,**" which are functions the LLM can execute. These tools offer a wide range of capabilities.
-
-**Here's how MCP works:**
-
-   **MCP hosts** discover the capabilities of connected servers and load their tools, prompts, and resources.
-   **Resources** provide consistent access to read-only data, akin to file paths or database queries.
-   **Security** is ensured as servers isolate credentials and sensitive data. Interactions require explicit user approval.
-
-## Use Cases
-
-The potential of MCP servers is vast. They can be used for a variety of purposes.
-
-**Here are some concrete examples of how MCP servers can be used:**
-
-   **Web Services and API Integration:**
-    -   Monitor GitHub repositories for new issues
-    -   Post updates to Twitter based on specific triggers
-    -   Retrieve real-time weather data for location-based services
-   **Browser Automation:**
-    -   Automate web application testing
-    -   Scrape e-commerce sites for price comparisons
-    -   Generate screenshots for website monitoring
-   **Database Queries:**
-    -   Generate weekly sales reports
-    -   Analyze customer behavior patterns
-    -   Create real-time dashboards for business metrics
-   **Project and Task Management:**
-    -   Automate Jira ticket creation based on code commits
-    -   Generate weekly progress reports
-    -   Create task dependencies based on project requirements
-   **Codebase Documentation:**
-    -   Generate API documentation from code comments
-    -   Create architecture diagrams from code structure
-    -   Maintain up-to-date README files
-
-## Getting Started
-
-Cline does not come with any pre-installed MCP servers. You'll need to find and install them separately.
-
-**Choose the right approach for your needs:**
-
-   **Community Repositories:** Check for community-maintained lists of MCP servers on GitHub. See [Adding MCP Servers from Github](/mcp/adding-mcp-servers-from-github)
-   **Cline Marketplace:** Install one from Cline's [MCP Marketplace](/mcp/mcp-marketplace)
-   **Ask Cline:** You can ask Cline to help you find or create MCP servers
-   **Build Your Own:** Create custom MCP servers using the [MCP SDK](https://github.com/modelcontextprotocol/)
-   **Customize Existing Servers:** Modify existing servers to fit your specific requirements
-
-## Integration with Cline
-
-Cline simplifies the building and use of MCP servers through its AI capabilities.
-
-### Building MCP Servers
-
-   **Natural language understanding:** Instruct Cline in natural language to build an MCP server by describing its functionalities. Cline will interpret your instructions and generate the necessary code.
-   **Cloning and building servers:** Cline can clone existing MCP server repositories from GitHub and build them automatically.
-   **Configuration and dependency management:** Cline handles configuration files, environment variables, and dependencies.
-   **Troubleshooting and debugging:** Cline helps identify and resolve errors during development.
-
-### Using MCP Servers
-
-   **Tool execution:** Cline seamlessly integrates with MCP servers, allowing you to execute their defined tools.
-   **Context-aware interactions:** Cline can intelligently suggest using relevant tools based on conversation context.
-   **Dynamic integrations:** Combine multiple MCP server capabilities for complex tasks. For example, Cline could use a GitHub server to get data and a Notion server to create a formatted report.
-
-## Security Considerations
-
-When working with MCP servers, it's important to follow security best practices:
-
-   **Authentication:** Always use secure authentication methods for API access
-   **Environment Variables:** Store sensitive information in environment variables
-   **Access Control:** Limit server access to authorized users only
-   **Data Validation:** Validate all inputs to prevent injection attacks
-   **Logging:** Implement secure logging practices without exposing sensitive data
-
-## Resources
-
-There are various resources available for finding and learning about MCP servers.
-
-**Here are some links to resources for finding and learning about MCP servers:**
-
-   **GitHub Repositories:** [https://github.com/modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers) and [https://github.com/punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
-   **Online Directories:** [https://mcpservers.org/](https://mcpservers.org/), [https://mcp.so/](https://mcp.so/), and [https://glama.ai/mcp/servers](https://glama.ai/mcp/servers)
-   **PulseMCP:** [https://www.pulsemcp.com/](https://www.pulsemcp.com/)
-   **YouTube Tutorial (AI-Driven Coder):** A video guide for building and using MCP servers: [https://www.youtube.com/watch?v=b5pqTNiuuJg](https://www.youtube.com/watch?v=b5pqTNiuuJg)
@@ -1,705 +0,0 @@
---
-title: "MCP Server Development Protocol"
-description: "This protocol is designed to streamline the development process of building MCP servers with Cline."
---
-
-> 🚀 **Build and share your MCP servers with the world.** Once you've created a great MCP server, submit it to the [Cline MCP Marketplace](https://github.com/cline/mcp-marketplace) to make it discoverable and one-click installable by thousands of developers.
-
-## What Are MCP Servers?
-
-Model Context Protocol (MCP) servers extend AI assistants like Cline by giving them the ability to:
-
-   Access external APIs and services
-   Retrieve real-time data
-   Control applications and local systems
-   Perform actions beyond what text prompts alone can achieve
-
-Without MCP, AI assistants are powerful but isolated. With MCP, they gain the ability to interact with virtually any digital system.
-
-## The Development Protocol
-
-The heart of effective MCP server development is following a structured protocol. This protocol is implemented through a `.clinerules` file that lives at the **root** of your MCP working directory (/Users/your-name/Documents/Cline/MCP).
-
-### Using `.clinerules` Files
-
-A `.clinerules` file is a special configuration that Cline reads automatically when working in the directory where it's placed. These files:
-
-   Configure Cline's behavior and enforce best practices
-   Switch Cline into a specialized MCP development mode
-   Provide a step-by-step protocol for building servers
-   Implement safety measures like preventing premature completion
-   Guide you through planning, implementation, and testing phases
-
-Here's the complete MCP Server Development Protocol that should be placed in your `.clinerules` file:
-
-````markdown
-# MCP Server Development Protocol
-
-⚠️ CRITICAL: DO NOT USE attempt_completion BEFORE TESTING ⚠️
-
-## Step 1: Planning (PLAN MODE)
-
-   What problem does this tool solve?
-   What API/service will it use?
-   What are the authentication requirements?
-    □ Standard API key
-    □ OAuth (requires separate setup script)
-    □ Other credentials
-
-## Step 2: Implementation (ACT MODE)
-
-1. Bootstrap
-
-    - For web services, JavaScript integration, or Node.js environments:
-        ```bash
-        npx @modelcontextprotocol/create-server my-server
-        cd my-server
-        npm install
-        ```
-    - For data science, ML workflows, or Python environments:
-        ```bash
-        pip install mcp
-        # Or with uv (recommended)
-        uv add "mcp[cli]"
-        ```
-
-2. Core Implementation
-
-    - Use MCP SDK
-    - Implement comprehensive logging
-        - TypeScript (for web/JS projects):
-            ```typescript
-            console.error("[Setup] Initializing server...")
-            console.error("[API] Request to endpoint:", endpoint)
-            console.error("[Error] Failed with:", error)
-            ```
-        - Python (for data science/ML projects):
-            ```python
-            import logging
-            logging.error('[Setup] Initializing server...')
-            logging.error(f'[API] Request to endpoint: {endpoint}')
-            logging.error(f'[Error] Failed with: {str(error)}')
-            ```
-    - Add type definitions
-    - Handle errors with context
-    - Implement rate limiting if needed
-
-3. Configuration
-
-    - Get credentials from user if needed
-    - Add to MCP settings:
-
-        - For TypeScript projects:
-            ```json
-            {
-            	"mcpServers": {
-            		"my-server": {
-            			"command": "node",
-            			"args": ["path/to/build/index.js"],
-            			"env": {
-            				"API_KEY": "key"
-            			},
-            			"disabled": false,
-            			"autoApprove": []
-            		}
-            	}
-            }
-            ```
-        - For Python projects:
-
-            ```bash
-            # Directly with command line
-            mcp install server.py -v API_KEY=key
-
-            # Or in settings.json
-            {
-              "mcpServers": {
-                "my-server": {
-                  "command": "python",
-                  "args": ["server.py"],
-                  "env": {
-                    "API_KEY": "key"
-                  },
-                  "disabled": false,
-                  "autoApprove": []
-                }
-              }
-            }
-            ```
-
-## Step 3: Testing (BLOCKER ⛔️)
-
-<thinking>
-BEFORE using attempt_completion, I MUST verify:
-□ Have I tested EVERY tool?
-□ Have I confirmed success from the user for each test?
-□ Have I documented the test results?
-
-If ANY answer is "no", I MUST NOT use attempt_completion.
-</thinking>
-
-1. Test Each Tool (REQUIRED)
-   □ Test each tool with valid inputs
-   □ Verify output format is correct
-   ⚠️ DO NOT PROCEED UNTIL ALL TOOLS TESTED
-
-## Step 4: Completion
-
-❗ STOP AND VERIFY:
-□ Every tool has been tested with valid inputs
-□ Output format is correct for each tool
-
-Only after ALL tools have been tested can attempt_completion be used.
-
-## Key Requirements
-
-   ✓ Must use MCP SDK
-   ✓ Must have comprehensive logging
-   ✓ Must test each tool individually
-   ✓ Must handle errors gracefully
-   ⛔️ NEVER skip testing before completion
-````
-
-When this `.clinerules` file is present in your working directory, Cline will:
-
-1. Start in **PLAN MODE** to design your server before implementation
-2. Enforce proper implementation patterns in **ACT MODE**
-3. Require testing of all tools before allowing completion
-4. Guide you through the entire development lifecycle
-
-## Getting Started
-
-Creating an MCP server requires just a few simple steps to get started:
-
-### 1. Create a `.clinerules` file (🚨 IMPORTANT)
-
-First, add a `.clinerules` file to the root of your MCP working directory using the protocol above. This file configures Cline to use the MCP development protocol when working in this folder.
-
-### 2. Start a Chat with a Clear Description
-
-Begin your Cline chat by clearly describing what you want to build. Be specific about:
-
-   The purpose of your MCP server
-   Which API or service you want to integrate with
-   Any specific tools or features you need
-
-For example:
-
-```plaintext
-I want to build an MCP server for the AlphaAdvantage financial API.
-It should allow me to get real-time stock data, perform technical
-analysis, and retrieve company financial information.
-```
-
-### 3. Work Through the Protocol
-
-Cline will automatically start in PLAN MODE, guiding you through the planning process:
-
-   Discussing the problem scope
-   Reviewing API documentation
-   Planning authentication methods
-   Designing tool interfaces
-
-When ready, switch to ACT MODE using the toggle at the bottom of the chat to begin implementation.
-
-### 4. Provide API Documentation Early
-
-One of the most effective ways to help Cline build your MCP server is to share official API documentation right at the start:
-
-```plaintext
-Here's the API documentation for the service:
-[Paste API documentation here]
-```
-
-Providing comprehensive API details (endpoints, authentication, data structures) significantly improves Cline's ability to implement an effective MCP server.
-
-## Understanding the Two Modes
-
-### PLAN MODE
-
-In this collaborative phase, you work with Cline to design your MCP server:
-
-   Define the problem scope
-   Choose appropriate APIs
-   Plan authentication methods
-   Design the tool interfaces
-   Determine data formats
-
-### ACT MODE
-
-Once planning is complete, Cline helps implement the server:
-
-   Set up the project structure
-   Write the implementation code
-   Configure settings
-   Test each component thoroughly
-   Finalize documentation
-
-## Case Study: AlphaAdvantage Stock Analysis Server
-
-Let's walk through the development process of our AlphaAdvantage MCP server, which provides stock data analysis and reporting capabilities.
-
-### Planning Phase
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/planning-phase.gif"
-		alt="Planning phase demonstration"
-	/>
-</Frame>
-
-During the planning phase, we:
-
-1. **Defined the problem**: Users need access to financial data, stock analysis, and market insights directly through their AI assistant
-2. **Selected the API**: AlphaAdvantage API for financial market data
-    - Standard API key authentication
-    - Rate limits of 5 requests per minute (free tier)
-    - Various endpoints for different financial data types
-3. **Designed the tools needed**:
-    - Stock overview information (current price, company details)
-    - Technical analysis with indicators (RSI, MACD, etc.)
-    - Fundamental analysis (financial statements, ratios)
-    - Earnings report data
-    - News and sentiment analysis
-4. **Planned data formatting**:
-    - Clean, well-formatted markdown output
-    - Tables for structured data
-    - Visual indicators (↑/↓) for trends
-    - Proper formatting of financial numbers
-
-### Implementation
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/building-mcp-plugin.gif"
-		alt="Building MCP plugin demonstration"
-	/>
-</Frame>
-
-We began by bootstrapping the project:
-
-```bash
-npx @modelcontextprotocol/create-server alphaadvantage-mcp
-cd alphaadvantage-mcp
-npm install axios node-cache
-```
-
-Next, we structured our project with:
-
-```plaintext
-src/
-  ├── api/
-  │   └── alphaAdvantageClient.ts  # API client with rate limiting & caching
-  ├── formatters/
-  │   └── markdownFormatter.ts     # Output formatters for clean markdown
-  └── index.ts                     # Main MCP server implementation
-```
-
-#### API Client Implementation
-
-The API client implementation included:
-
-   **Rate limiting**: Enforcing the 5 requests per minute limit
-   **Caching**: Reducing API calls with strategic caching
-   **Error handling**: Robust error detection and reporting
-   **Typed interfaces**: Clear TypeScript types for all data
-
-Key implementation details:
-
-```typescript
-/**
- * Manage rate limiting based on free tier (5 calls per minute)
- */
-private async enforceRateLimit() {
-  if (this.requestsThisMinute >= 5) {
-    console.error("[Rate Limit] Rate limit reached. Waiting for next minute...");
-    return new Promise<void>((resolve) => {
-      const remainingMs = 60 * 1000 - (Date.now() % (60 * 1000));
-      setTimeout(resolve, remainingMs + 100); // Add 100ms buffer
-    });
-  }
-
-  this.requestsThisMinute++;
-  return Promise.resolve();
-}
-```
-
-#### Markdown Formatting
-
-We implemented formatters to display financial data beautifully:
-
-```typescript
-/**
- * Format company overview into markdown
- */
-export function formatStockOverview(overviewData: any, quoteData: any): string {
-	// Extract data
-	const overview = overviewData
-	const quote = quoteData["Global Quote"]
-
-	// Calculate price change
-	const currentPrice = parseFloat(quote["05. price"] || "0")
-	const priceChange = parseFloat(quote["09. change"] || "0")
-	const changePercent = parseFloat(quote["10. change percent"]?.replace("%", "") || "0")
-
-	// Format markdown
-	let markdown = `# ${overview.Symbol} (${overview.Name}) - ${formatCurrency(currentPrice)} ${addTrendIndicator(priceChange)}${changePercent > 0 ? "+" : ""}${changePercent.toFixed(2)}%\n\n`
-
-	// Add more details...
-
-	return markdown
-}
-```
-
-#### Tool Implementation
-
-We defined five tools with clear interfaces:
-
-```typescript
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-	console.error("[Setup] Listing available tools")
-
-	return {
-		tools: [
-			{
-				name: "get_stock_overview",
-				description: "Get basic company info and current quote for a stock symbol",
-				inputSchema: {
-					type: "object",
-					properties: {
-						symbol: {
-							type: "string",
-							description: "Stock symbol (e.g., 'AAPL')",
-						},
-						market: {
-							type: "string",
-							description: "Optional market (e.g., 'US')",
-							default: "US",
-						},
-					},
-					required: ["symbol"],
-				},
-			},
-			// Additional tools defined here...
-		],
-	}
-})
-```
-
-Each tool's handler included:
-
-   Input validation
-   API client calls with error handling
-   Markdown formatting of responses
-   Comprehensive logging
-
-### Testing Phase
-
-This critical phase involved systematically testing each tool:
-
-1. First, we configured the MCP server in the settings:
-
-```json
-{
-	"mcpServers": {
-		"alphaadvantage-mcp": {
-			"command": "node",
-			"args": ["/path/to/alphaadvantage-mcp/build/index.js"],
-			"env": {
-				"ALPHAVANTAGE_API_KEY": "YOUR_API_KEY"
-			},
-			"disabled": false,
-			"autoApprove": []
-		}
-	}
-}
-```
-
-2. Then we tested each tool individually:
-
-   **get_stock_overview**: Retrieved AAPL stock overview information
-
-    ```markdown
-    # AAPL (Apple Inc) - $241.84 ↑+1.91%
-
-    **Sector:** TECHNOLOGY
-    **Industry:** ELECTRONIC COMPUTERS
-    **Market Cap:** 3.63T
-    **P/E Ratio:** 38.26
-    ...
-    ```
-
-   **get_technical_analysis**: Obtained price action and RSI data
-
-    ```markdown
-    # Technical Analysis: AAPL
-
-    ## Daily Price Action
-
-    Current Price: $241.84 (↑$4.54, +1.91%)
-
-    ### Recent Daily Prices
-
-    | Date       | Open    | High    | Low     | Close   | Volume |
-    | ---------- | ------- | ------- | ------- | ------- | ------ |
-    | 2025-02-28 | $236.95 | $242.09 | $230.20 | $241.84 | 56.83M |
-
-    ...
-    ```
-
-   **get_earnings_report**: Retrieved MSFT earnings history and formatted report
-
-    ```markdown
-    # Earnings Report: MSFT (Microsoft Corporation)
-
-    **Sector:** TECHNOLOGY
-    **Industry:** SERVICES-PREPACKAGED SOFTWARE
-    **Current EPS:** $12.43
-
-    ## Recent Quarterly Earnings
-
-    | Quarter    | Date       | EPS Estimate | EPS Actual | Surprise % |
-    | ---------- | ---------- | ------------ | ---------- | ---------- |
-    | 2024-12-31 | 2025-01-29 | $3.11        | $3.23      | ↑4.01%     |
-
-    ...
-    ```
-
-### Challenges and Solutions
-
-During development, we encountered several challenges:
-
-1. **API Rate Limiting**:
-    - **Challenge**: Free tier limited to 5 calls per minute
-    - **Solution**: Implemented queuing, enforced rate limits, and added comprehensive caching
-2. **Data Formatting**:
-    - **Challenge**: Raw API data not user-friendly
-    - **Solution**: Created formatting utilities for consistent display of financial data
-3. **Timeout Issues**:
-    - **Challenge**: Complex tools making multiple API calls could timeout
-    - **Solution**: Suggested breaking complex tools into smaller pieces, optimizing caching
-
-### Lessons Learned
-
-Our AlphaAdvantage implementation taught us several key lessons:
-
-1. **Plan for API Limits**: Understand and design around API rate limits from the beginning
-2. **Cache Strategically**: Identify high-value caching opportunities to improve performance
-3. **Format for Readability**: Invest in good data formatting for improved user experience
-4. **Test Every Path**: Test all tools individually before completion
-5. **Handle API Complexity**: For APIs requiring multiple calls, design tools with simpler scopes
-
-## Core Implementation Best Practices
-
-### Comprehensive Logging
-
-Effective logging is essential for debugging MCP servers:
-
-```typescript
-// Start-up logging
-console.error("[Setup] Initializing AlphaAdvantage MCP server...")
-
-// API request logging
-console.error(`[API] Getting stock overview for ${symbol}`)
-
-// Error handling with context
-console.error(`[Error] Tool execution failed: ${error.message}`)
-
-// Cache operations
-console.error(`[Cache] Using cached data for: ${cacheKey}`)
-```
-
-### Strong Typing
-
-Type definitions prevent errors and improve maintainability:
-
-```typescript
-export interface AlphaAdvantageConfig {
-	apiKey: string
-	cacheTTL?: Partial<typeof DEFAULT_CACHE_TTL>
-	baseURL?: string
-}
-
-/**
- * Validate that a stock symbol is provided and looks valid
- */
-function validateSymbol(symbol: unknown): asserts symbol is string {
-	if (typeof symbol !== "string" || symbol.trim() === "") {
-		throw new McpError(ErrorCode.InvalidParams, "A valid stock symbol is required")
-	}
-
-	// Basic symbol validation (letters, numbers, dots)
-	const symbolRegex = /^[A-Za-z0-9.]+$/
-	if (!symbolRegex.test(symbol)) {
-		throw new McpError(ErrorCode.InvalidParams, `Invalid stock symbol: ${symbol}`)
-	}
-}
-```
-
-### Intelligent Caching
-
-Reduce API calls and improve performance:
-
-```typescript
-// Default cache TTL in seconds
-const DEFAULT_CACHE_TTL = {
-	STOCK_OVERVIEW: 60 * 60, // 1 hour
-	TECHNICAL_ANALYSIS: 60 * 30, // 30 minutes
-	FUNDAMENTAL_ANALYSIS: 60 * 60 * 24, // 24 hours
-	EARNINGS_REPORT: 60 * 60 * 24, // 24 hours
-	NEWS: 60 * 15, // 15 minutes
-}
-
-// Check cache first
-const cachedData = this.cache.get<T>(cacheKey)
-if (cachedData) {
-	console.error(`[Cache] Using cached data for: ${cacheKey}`)
-	return cachedData
-}
-
-// Cache successful responses
-this.cache.set(cacheKey, response.data, cacheTTL)
-```
-
-### Graceful Error Handling
-
-Implement robust error handling that maintains a good user experience:
-
-```typescript
-try {
-	switch (request.params.name) {
-		case "get_stock_overview": {
-			// Implementation...
-		}
-
-		// Other cases...
-
-		default:
-			throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`)
-	}
-} catch (error) {
-	console.error(`[Error] Tool execution failed: ${error instanceof Error ? error.message : String(error)}`)
-
-	if (error instanceof McpError) {
-		throw error
-	}
-
-	return {
-		content: [
-			{
-				type: "text",
-				text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-			},
-		],
-		isError: true,
-	}
-}
-```
-
-## MCP Resources
-
-Resources let your MCP servers expose data to Cline without executing code. They're perfect for providing context like files, API responses, or database records that Cline can reference during conversations.
-
-### Adding Resources to Your MCP Server
-
-1. **Define the resources** your server will expose:
-
-```typescript
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-	return {
-		resources: [
-			{
-				uri: "file:///project/readme.md",
-				name: "Project README",
-				mimeType: "text/markdown",
-			},
-		],
-	}
-})
-```
-
-2. **Implement read handlers** to deliver the content:
-
-```typescript
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-	if (request.params.uri === "file:///project/readme.md") {
-		const content = await fs.promises.readFile("/path/to/readme.md", "utf-8")
-		return {
-			contents: [
-				{
-					uri: request.params.uri,
-					mimeType: "text/markdown",
-					text: content,
-				},
-			],
-		}
-	}
-
-	throw new Error("Resource not found")
-})
-```
-
-Resources make your MCP servers more context-aware, allowing Cline to access specific information without requiring you to copy/paste. For more information, refer to the [official documentation](https://modelcontextprotocol.io/docs/concepts/resources).
-
-## Common Challenges and Solutions
-
-### API Authentication Complexities
-
-**Challenge**: APIs often have different authentication methods.
-
-**Solution**:
-
-   For API keys, use environment variables in the MCP configuration
-   For OAuth, create a separate script to obtain refresh tokens
-   Store sensitive tokens securely
-
-```typescript
-// Authenticate using API key from environment
-const API_KEY = process.env.ALPHAVANTAGE_API_KEY
-if (!API_KEY) {
-	console.error("[Error] Missing ALPHAVANTAGE_API_KEY environment variable")
-	process.exit(1)
-}
-
-// Initialize API client
-const apiClient = new AlphaAdvantageClient({
-	apiKey: API_KEY,
-})
-```
-
-### Missing or Limited API Features
-
-**Challenge**: APIs may not provide all the functionality you need.
-
-**Solution**:
-
-   Implement fallbacks using available endpoints
-   Create simulated functionality where necessary
-   Transform API data to match your needs
-
-### API Rate Limiting
-
-**Challenge**: Most APIs have rate limits that can cause failures.
-
-**Solution**:
-
-   Implement proper rate limiting
-   Add intelligent caching
-   Provide graceful degradation
-   Add transparent errors about rate limits
-
-```typescript
-if (this.requestsThisMinute >= 5) {
-	console.error("[Rate Limit] Rate limit reached. Waiting for next minute...")
-	return new Promise<void>((resolve) => {
-		const remainingMs = 60 * 1000 - (Date.now() % (60 * 1000))
-		setTimeout(resolve, remainingMs + 100) // Add 100ms buffer
-	})
-}
-```
-
-## Additional Resources
-
-   [MCP Protocol Documentation](https://github.com/modelcontextprotocol/mcp)
-   [MCP SDK Documentation](https://github.com/modelcontextprotocol/sdk-js)
-   [MCP Server Examples](https://github.com/modelcontextprotocol/servers)
@@ -1,197 +0,0 @@
---
-title: "MCP Transport Mechanisms"
-description: "Learn about the two primary transport mechanisms for communication between Cline and MCP servers: Standard Input/Output (STDIO) and Server-Sent Events (SSE). Each has distinct characteristics, advantages, and use cases."
---
-
-Model Context Protocol (MCP) supports two primary transport mechanisms for communication between Cline and MCP servers: Standard Input/Output (STDIO) and Server-Sent Events (SSE). Each has distinct characteristics, advantages, and use cases.
-
-## STDIO Transport
-
-STDIO transport runs locally on your machine and communicates via standard input/output streams.
-
-### How STDIO Transport Works
-
-1. The client (Cline) spawns an MCP server as a child process
-2. Communication happens through process streams: client writes to server's STDIN, server responds to STDOUT
-3. Each message is delimited by a newline character
-4. Messages are formatted as JSON-RPC 2.0
-
-```plaintext
-Client                    Server
-  |                         |
-  |<---- JSON message ----->| (via STDIN)
-  |                         | (processes request)
-  |<---- JSON message ------| (via STDOUT)
-  |                         |
-```
-
-### STDIO Characteristics
-
-   **Locality**: Runs on the same machine as Cline
-   **Performance**: Very low latency and overhead (no network stack involved)
-   **Simplicity**: Direct process communication without network configuration
-   **Relationship**: One-to-one relationship between client and server
-   **Security**: Inherently more secure as no network exposure
-
-### When to Use STDIO
-
-STDIO transport is ideal for:
-
-   Local integrations and tools running on the same machine
-   Security-sensitive operations
-   Low-latency requirements
-   Single-client scenarios (one Cline instance per server)
-   Command-line tools or IDE extensions
-
-### STDIO Implementation Example
-
-```typescript
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-
-const server = new Server({ name: "local-server", version: "1.0.0" })
-// Register tools...
-
-// Use STDIO transport
-const transport = new StdioServerTransport(server)
-transport.listen()
-```
-
-## SSE Transport
-
-Server-Sent Events (SSE) transport runs on a remote server and communicates over HTTP/HTTPS.
-
-### How SSE Transport Works
-
-1. The client (Cline) connects to the server's SSE endpoint via HTTP GET request
-2. This establishes a persistent connection where the server can push events to the client
-3. For client-to-server communication, the client makes HTTP POST requests to a separate endpoint
-4. Communication happens over two channels:
-    - Event Stream (GET): Server-to-client updates
-    - Message Endpoint (POST): Client-to-server requests
-
-```plaintext
-Client                             Server
-  |                                  |
-  |---- HTTP GET /events ----------->| (establish SSE connection)
-  |<---- SSE event stream -----------| (persistent connection)
-  |                                  |
-  |---- HTTP POST /message --------->| (client request)
-  |<---- SSE event with response ----| (server response)
-  |                                  |
-```
-
-### SSE Characteristics
-
-   **Remote Access**: Can be hosted on a different machine from your Cline instance
-   **Scalability**: Can handle multiple client connections concurrently
-   **Protocol**: Works over standard HTTP (no special protocols needed)
-   **Persistence**: Maintains a persistent connection for server-to-client messages
-   **Authentication**: Can use standard HTTP authentication mechanisms
-
-### When to Use SSE
-
-SSE transport is better for:
-
-   Remote access across networks
-   Multi-client scenarios
-   Public services
-   Centralized tools that many users need to access
-   Integration with web services
-
-### SSE Implementation Example
-
-```typescript
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js"
-import express from "express"
-
-const app = express()
-const server = new Server({ name: "remote-server", version: "1.0.0" })
-// Register tools...
-
-// Use SSE transport
-const transport = new SSEServerTransport(server)
-app.use("/mcp", transport.requestHandler())
-app.listen(3000, () => {
-	console.log("MCP server listening on port 3000")
-})
-```
-
-## Local vs. Hosted: Deployment Aspects
-
-The choice between STDIO and SSE transports directly impacts how you'll deploy and manage your MCP servers.
-
-### STDIO: Local Deployment Model
-
-STDIO servers run locally on the same machine as Cline, which has several important implications:
-
-   **Installation**: The server executable must be installed on each user's machine
-   **Distribution**: You need to provide installation packages for different operating systems
-   **Updates**: Each instance must be updated separately
-   **Resources**: Uses the local machine's CPU, memory, and disk
-   **Access Control**: Relies on the local machine's filesystem permissions
-   **Integration**: Easy integration with local system resources (files, processes)
-   **Execution**: Starts and stops with Cline (child process lifecycle)
-   **Dependencies**: Any dependencies must be installed on the user's machine
-
-#### Practical Example
-
-A local file search tool using STDIO would:
-
-   Run on the user's machine
-   Have direct access to the local filesystem
-   Start when needed by Cline
-   Not require network configuration
-   Need to be installed alongside Cline or via a package manager
-
-### SSE: Hosted Deployment Model
-
-SSE servers can be deployed to remote servers and accessed over the network:
-
-   **Installation**: Installed once on a server, accessed by many users
-   **Distribution**: Single deployment serves multiple clients
-   **Updates**: Centralized updates affect all users immediately
-   **Resources**: Uses server resources, not local machine resources
-   **Access Control**: Managed through authentication and authorization systems
-   **Integration**: More complex integration with user-specific resources
-   **Execution**: Runs as an independent service (often continuously)
-   **Dependencies**: Managed on the server, not on user machines
-
-#### Practical Example
-
-A database query tool using SSE would:
-
-   Run on a central server
-   Connect to databases with server-side credentials
-   Be continuously available for multiple users
-   Require proper network security configuration
-   Be deployed using container or cloud technologies
-
-### Hybrid Approaches
-
-Some scenarios benefit from a hybrid approach:
-
-1. **STDIO with Network Access**: A local STDIO server that acts as a proxy to remote services
-2. **SSE with Local Commands**: A remote SSE server that can trigger operations on the client machine through callbacks
-3. **Gateway Pattern**: STDIO servers for local operations that connect to SSE servers for specialized functions
-
-## Choosing Between STDIO and SSE
-
-| Consideration        | STDIO                    | SSE                                 |
-| -------------------- | ------------------------ | ----------------------------------- |
-| **Location**         | Local machine only       | Local or remote                     |
-| **Clients**          | Single client            | Multiple clients                    |
-| **Performance**      | Lower latency            | Higher latency (network overhead)   |
-| **Setup Complexity** | Simpler                  | More complex (requires HTTP server) |
-| **Security**         | Inherently secure        | Requires explicit security measures |
-| **Network Access**   | Not needed               | Required                            |
-| **Scalability**      | Limited to local machine | Can distribute across network       |
-| **Deployment**       | Per-user installation    | Centralized installation            |
-| **Updates**          | Distributed updates      | Centralized updates                 |
-| **Resource Usage**   | Uses client resources    | Uses server resources               |
-| **Dependencies**     | Client-side dependencies | Server-side dependencies            |
-
-## Configuring Transports in Cline
-
-For detailed information on configuring STDIO and SSE transports in Cline, including examples, see [Configuring MCP Servers](/mcp/configuring-mcp-servers).
@@ -1,34 +0,0 @@
---
-title: "Telemetry"
---
-
-### Overview
-
-To help make Cline better for everyone, we collect anonymous usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
-
-We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see exactly what we track.
-
-### Tracking Policy
-
-Privacy is our priority. All collected data is anonymized before being sent to PostHog, with no personally identifiable information (PII) included. Your code, prompts, and conversation content always remain private and are never collected.
-
-### What We Track
-
-We collect basic anonymous usage data including:
-
-**Task Interactions:** When tasks start and finish, conversation flow (without content)\
-**Mode and Tool Usage:** Switches between plan/act modes, which tools are being used\
-**Token Usage:** Basic metrics about conversation length to estimate cost (not the actual content of the tokens)\
-**System Context:** OS type and VS Code environment details\
-**UI Activity:** Navigation patterns and feature usage
-
-For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see the exact events we track.
-
-### How to Opt Out
-
-Telemetry in Cline is entirely optional:
-
-   When you update or install our VS Code extension, you'll see a message about our anonymous telemetry
-   You can change your preference anytime in settings
-
-Cline also respects VS Code's global telemetry settings. If you've disabled telemetry at the VS Code level, Cline's telemetry will automatically be disabled as well.
@@ -13,7 +13,7 @@ To get started with Cline Memory Bank:
 3. **Paste into Cline** - Add as custom instructions or in a .clinerules file
 4. **Initialize** - Ask Cline to "initialize memory bank"

-[See detailed setup instructions](#getting-started-with-memory-bank)
+[See detailed setup instructions](cline-memory-bank.md#getting-started-with-memory-bank)

 ### Cline Memory Bank Custom Instructions \[COPY THIS]

@@ -152,7 +152,7 @@ The Memory Bank is a structured documentation system that allows Cline to mainta
 The Memory Bank isn't a Cline-specific feature - it's a methodology for managing AI context through structured documentation. When you instruct Cline to "follow custom instructions," it reads the Memory Bank files to rebuild its understanding of your project.

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(15).png" alt="Memory Bank Workflow" />
+	<img src="/assets/robot_panel_dark.png" alt="Memory Bank Workflow" />
 </Frame>

 #### Understanding the Files
@@ -162,7 +162,7 @@ Memory Bank files are simply markdown files you create in your project. They're
 Files are organized in a hierarchical structure that builds up a complete picture of your project:

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(16).png" alt="Memory Bank File Structure" />
+	<img src="/assets/robot_panel_dark.png" alt="Memory Bank File Structure" />
 </Frame>

 ### Memory Bank Files Explained
@@ -223,7 +223,7 @@ Create additional files when needed to organize:
 3. Ask Cline to "initialize memory bank"

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(17).png" alt="Memory Bank Setup" />
+	<img src="/assets/robot_panel_dark.png" alt="Memory Bank Setup" />
 </Frame>

 #### Project Brief Tips
@@ -287,7 +287,7 @@ As you work with Cline, your context window will eventually fill up (note the pr
 This workflow ensures that important context is preserved in your Memory Bank files before the context window is cleared, allowing you to continue seamlessly in a fresh conversation.

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(18).png" alt="Memory Bank Context Window" />
+	<img src="/assets/robot_panel_dark.png" alt="Memory Bank Context Window" />
 </Frame>

 #### How often should I update the memory bank?
@@ -22,7 +22,7 @@ To add custom instructions:
 4. Paste your instructions

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(1).png" alt="Cline Logo" />
+	<img src="/assets/robot_panel_dark.png" alt="Cline Logo" />
 </Frame>

 Custom instructions are powerful for:
@@ -207,7 +207,7 @@ Located conveniently under the chat input field, this popover allows you to:
 This UI significantly simplifies switching contexts and managing different sets of instructions without needing to manually edit files or configurations during a conversation.

 <Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(1).png" alt="Cline Logo" />
+	<img src="/assets/robot_panel_dark.png" alt="Cline Logo" />
 </Frame>

 ## .clineignore File Guide
@@ -1,90 +0,0 @@
---
-title: "LM Studio"
-description: "A quick guide to setting up LM Studio for local AI model execution with Cline."
---
-
-## 🤖 Setting Up LM Studio with Cline
-
-Run AI models locally using LM Studio with Cline.
-
-### 📋 Prerequisites
-
-   Windows, macOS, or Linux computer with AVX2 support
-   Cline installed in VS Code
-
-### 🚀 Setup Steps
-
-#### 1. Install LM Studio
-
-   Visit [lmstudio.ai](https://lmstudio.ai)
-   Download and install for your operating system
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(7).png" alt="LM Studio download page" />
-</Frame>
-
-#### 2. Launch LM Studio
-
-   Open the installed application
-   You'll see four tabs on the left: **Chat**, **Developer** (where you will start the server), **My Models** (where your downloaded models are stored), **Discover** (add new models)
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(10).png"
-		alt="LM Studio interface overview"
-	/>
-</Frame>
-
-#### 3. Download a Model
-
-   Browse the "Discover" page
-   Select and download your preferred model
-   Wait for download to complete
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/lm-studio-download-model.gif"
-		alt="Downloading a model in LM Studio"
-	/>
-</Frame>
-
-#### 4. Start the Server
-
-   Navigate to the "Developer" tab
-   Toggle the server switch to "Running"
-   Note: The server will run at `http://localhost:1234`
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/lm-studio-starting-server.gif"
-		alt="Starting the LM Studio server"
-	/>
-</Frame>
-
-#### 5. Configure Cline
-
-1. Open VS Code
-2. Click Cline settings icon
-3. Select "LM Studio" as API provider
-4. Select your model from the available options
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/lm-studio-select-model-cline.gif"
-		alt="Configuring Cline with LM Studio"
-	/>
-</Frame>
-
-### ⚠️ Important Notes
-
-   Start LM Studio before using with Cline
-   Keep LM Studio running in background
-   First model download may take several minutes depending on size
-   Models are stored locally after download
-
-### 🔧 Troubleshooting
-
-1. If Cline can't connect to LM Studio:
-2. Verify LM Studio server is running (check Developer tab)
-3. Ensure a model is loaded
-4. Check your system meets hardware requirements
@@ -1,88 +0,0 @@
---
-title: "Ollama"
-description: "A quick guide to setting up Ollama for local AI model execution with Cline."
---
-
-### 📋 Prerequisites
-
-   Windows, macOS, or Linux computer
-   Cline installed in VS Code
-
-### 🚀 Setup Steps
-
-#### 1. Install Ollama
-
-   Visit [ollama.com](https://ollama.com)
-   Download and install for your operating system
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2)%20(1)%20(1).png"
-		alt="Ollama download page"
-	/>
-</Frame>
-
-#### 2. Choose and Download a Model
-
-   Browse models at [ollama.com/search](https://ollama.com/search)
-   Select model and copy command:
-
-    ```bash
-    ollama run [model-name]
-    ```
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/ollama-model-grab%20(2).gif"
-		alt="Selecting a model in Ollama"
-	/>
-</Frame>
-
-   Open your Terminal and run the command:
-
-    -   Example:
-
-        ```bash
-        ollama run llama2
-        ```
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/starting-ollama-terminal%20(2).gif"
-		alt="Running Ollama in terminal"
-	/>
-</Frame>
-
-**✨ Your model is now ready to use within Cline!**
-
-#### 3. Configure Cline
-
-1. Open VS Code
-2. Click Cline settings icon
-3. Select "Ollama" as API provider
-4. Enter configuration:
-    - Base URL: `http://localhost:11434/` (default value, can be left as is)
-    - Select the model from your available options
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/selecting-ollama-model-cline%20(3).gif"
-		alt="Configuring Cline with Ollama"
-	/>
-</Frame>
-
-### ⚠️ Important Notes
-
-   Start Ollama before using with Cline
-   Keep Ollama running in background
-   First model download may take several minutes
-
-### 🔧 Troubleshooting
-
-If Cline can't connect to Ollama:
-
-1. Verify Ollama is running
-2. Check base URL is correct
-3. Ensure model is downloaded
-
-Need more info? Read the [Ollama Docs](https://github.com/ollama/ollama/blob/main/docs/api.md).
@@ -1,109 +0,0 @@
---
-title: "Read Me First"
---
-
-## Running Local Models with Cline: What You Need to Know 🤖
-
-Cline is a powerful AI coding assistant that uses tool-calling to help you write, analyze, and modify code. While running models locally can save on API costs, there's an important trade-off: local models are significantly less reliable at using these essential tools.
-
-## Why Local Models Are Different 🔬
-
-When you run a "local version" of a model, you're actually running a drastically simplified copy of the original. This process, called distillation, is like trying to compress a professional chef's knowledge into a basic cookbook – you keep the simple recipes but lose the complex techniques and intuition.
-
-Local models are created by training a smaller model to imitate a larger one, but they typically only retain 1-26% of the original model's capacity. This massive reduction means:
-
-   Less ability to understand complex contexts
-   Reduced capability for multi-step reasoning
-   Limited tool-use abilities
-   Simplified decision-making process
-
-Think of it like running your development environment on a calculator instead of a computer – it might handle basic tasks, but complex operations become unreliable or impossible.
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(4).png"
-		alt="Local model comparison diagram"
-	/>
-</Frame>
-
-### What Actually Happens
-
-When you run a local model with Cline:
-
-#### Performance Impact 📉
-
-   Responses are 5-10x slower than cloud services
-   System resources (CPU, GPU, RAM) get heavily utilized
-   Your computer may become less responsive for other tasks
-
-#### Tool Reliability Issues 🛠️
-
-   Code analysis becomes less accurate
-   File operations may be unreliable
-   Browser automation capabilities are reduced
-   Terminal commands might fail more often
-   Complex multi-step tasks often break down
-
-### Hardware Requirements 💻
-
-You'll need at minimum:
-
-   Modern GPU with 8GB+ VRAM (RTX 3070 or better)
-   32GB+ system RAM
-   Fast SSD storage
-   Good cooling solution
-
-Even with this hardware, you'll be running smaller, less capable versions of models:
-
-| Model Size | What You Get                                            |
-| ---------- | ------------------------------------------------------- |
-| 7B models  | Basic coding, limited tool use                          |
-| 14B models | Better coding, unstable tool use                        |
-| 32B models | Good coding, inconsistent tool use                      |
-| 70B models | Best local performance, but requires expensive hardware |
-
-Put simply, the cloud (API) versions of these models are the full-bore version of the model. The full version of DeepSeek-R1 is 671B. These distilled models are essentially "watered-down" versions of the cloud model.
-
-### Practical Recommendations 💡
-
-#### Consider This Approach
-
-1. Use cloud models for:
-    - Complex development tasks
-    - When tool reliability is crucial
-    - Multi-step operations
-    - Critical code changes
-2. Use local models for:
-    - Simple code completion
-    - Basic documentation
-    - When privacy is paramount
-    - Learning and experimentation
-
-#### If You Must Go Local
-
-   Start with smaller models
-   Keep tasks simple and focused
-   Save work frequently
-   Be prepared to switch to cloud models for complex operations
-   Monitor system resources
-
-### Common Issues 🚨
-
-   **"Tool execution failed":** Local models often struggle with complex tool chains. Simplify your prompt.
-   **"No connection could be made because the target machine actively refused it":** This usually means that the Ollama or LM Studio server isn't running, or is running on a different port/address than Cline is configured to use. Double-check the Base URL address in your API Provider settings.
-   **"Cline is having trouble...":** Increase your model's context length to its maximum size.
-   **Slow or incomplete responses:** Local models can be slower than cloud-based models, especially on less powerful hardware. If performance is an issue, try using a smaller model. Expect significantly longer processing times.
-   **System stability:** Watch for high GPU/CPU usage and temperature
-   **Context limitations:** Local models often have smaller context windows than cloud models. Break tasks down into smaller pieces.
-
-### Looking Ahead 🔮
-
-Local model capabilities are improving, but they're not yet a complete replacement for cloud services, especially for Cline's tool-based functionality. Consider your specific needs and hardware capabilities carefully before committing to a local-only approach.
-
-### Need Help? 🤝
-
-   Join our [Discord](https://discord.gg/cline) community and [r/cline](https://www.reddit.com/r/CLine/)
-   Check the latest compatibility guides
-   Share your experiences with other developers
-
-Remember: When in doubt, prioritize reliability over cost savings for important development work.
@@ -4,8 +4,6 @@ const path = require("path")

 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")
-const standalone = process.argv.includes("--standalone")
-const destDir = standalone ? "dist-standalone" : "dist"

 /**
 * @type {import('esbuild').Plugin}
@@ -87,7 +85,7 @@ const copyWasmFiles = {
 		build.onEnd(() => {
 			// tree sitter
 			const sourceDir = path.join(__dirname, "node_modules", "web-tree-sitter")
-			const targetDir = path.join(__dirname, destDir)
+			const targetDir = path.join(__dirname, "dist")

 			// Copy tree-sitter.wasm
 			fs.copyFileSync(path.join(sourceDir, "tree-sitter.wasm"), path.join(targetDir, "tree-sitter.wasm"))
@@ -119,8 +117,7 @@ const copyWasmFiles = {
 	},
 }

-// Base configuration shared between extension and standalone builds
-const baseConfig = {
+const extensionConfig = {
 	bundle: true,
 	minify: production,
 	sourcemap: !production,
@@ -143,32 +140,16 @@ const baseConfig = {
 			},
 		},
 	],
+	entryPoints: ["src/extension.ts"],
 	format: "cjs",
 	sourcesContent: false,
 	platform: "node",
-}
-
-// Extension-specific configuration
-const extensionConfig = {
-	...baseConfig,
-	entryPoints: ["src/extension.ts"],
-	outfile: `${destDir}/extension.js`,
+	outfile: "dist/extension.js",
 	external: ["vscode"],
 }

-// Standalone-specific configuration
-const standaloneConfig = {
-	...baseConfig,
-	entryPoints: ["src/standalone/standalone.ts"],
-	outfile: `${destDir}/standalone.js`,
-	// These gRPC protos need to load files from the module directory at runtime,
-	// so they cannot be bundled.
-	external: ["vscode", "@grpc/reflection", "grpc-health-check"],
-}
-
 async function main() {
-	const config = standalone ? standaloneConfig : extensionConfig
-	const extensionCtx = await esbuild.context(config)
+	const extensionCtx = await esbuild.context(extensionConfig)
 	if (watch) {
 		await extensionCtx.watch()
 	} else {
@@ -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.15.5",
+	"version": "3.14.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -40,8 +40,6 @@
 		"llama"
 	],
 	"activationEvents": [
-		"onLanguage",
-		"onStartupFinished",
 		"workspaceContains:evals.env"
 	],
 	"main": "./dist/extension.js",
@@ -120,12 +118,6 @@
 				"command": "cline.focusChatInput",
 				"title": "Jump to Chat Input",
 				"category": "Cline"
-			},
-			{
-				"command": "cline.generateGitCommitMessage",
-				"title": "Generate Commit Message with Cline",
-				"category": "Cline",
-				"icon": "$(robot)"
 			}
 		],
 		"keybindings": [
@@ -136,10 +128,6 @@
 				"win": "ctrl+'",
 				"linux": "ctrl+'",
 				"when": "editorHasSelection"
-			},
-			{
-				"command": "cline.generateGitCommitMessage",
-				"when": "scmProvider == git"
 			}
 		],
 		"menus": {
@@ -219,37 +207,91 @@
 					"command": "cline.addTerminalOutputToChat",
 					"group": "navigation"
 				}
-			],
-			"scm/title": [
-				{
-					"command": "cline.generateGitCommitMessage",
-					"group": "navigation",
-					"when": "scmProvider == git"
-				}
-			],
-			"commandPalette": [
-				{
-					"command": "cline.generateGitCommitMessage",
-					"when": "scmProvider == git"
-				}
 			]
 		},
 		"configuration": {
 			"title": "Cline",
-			"properties": {}
+			"properties": {
+				"cline.vsCodeLmModelSelector": {
+					"type": "object",
+					"properties": {
+						"vendor": {
+							"type": "string",
+							"description": "The vendor of the language model (e.g. copilot)"
+						},
+						"family": {
+							"type": "string",
+							"description": "The family of the language model (e.g. gpt-4)"
+						}
+					},
+					"description": "Settings for VSCode Language Model API"
+				},
+				"cline.enableCheckpoints": {
+					"type": "boolean",
+					"default": true,
+					"description": "Enables extension to save checkpoints of workspace throughout the task. Uses git under the hood which may not work well with large workspaces."
+				},
+				"cline.disableBrowserTool": {
+					"type": "boolean",
+					"default": false,
+					"description": "Disables extension from spawning browser session."
+				},
+				"cline.modelSettings.o3Mini.reasoningEffort": {
+					"type": "string",
+					"enum": [
+						"low",
+						"medium",
+						"high"
+					],
+					"default": "medium",
+					"description": "Controls the reasoning effort when using an OpenAI reasoning model. Higher values may result in more thorough but slower responses."
+				},
+				"cline.chromeExecutablePath": {
+					"type": "string",
+					"default": null,
+					"description": "Path to Chrome executable for browser use functionality. If not set, the extension will attempt to find or download it automatically."
+				},
+				"cline.preferredLanguage": {
+					"type": "string",
+					"enum": [
+						"English",
+						"Arabic - العربية",
+						"Portuguese - Português (Brasil)",
+						"Czech - Čeština",
+						"French - Français",
+						"German - Deutsch",
+						"Hindi - हिन्दी",
+						"Hungarian - Magyar",
+						"Italian - Italiano",
+						"Japanese - 日本語",
+						"Korean - 한국어",
+						"Polish - Polski",
+						"Portuguese - Português (Portugal)",
+						"Russian - Русский",
+						"Simplified Chinese - 简体中文",
+						"Spanish - Español",
+						"Traditional Chinese - 繁體中文",
+						"Turkish - Türkçe"
+					],
+					"default": "English",
+					"description": "The language that Cline should use for communication."
+				},
+				"cline.mcpMarketplace.enabled": {
+					"type": "boolean",
+					"default": true,
+					"description": "Controls whether the MCP Marketplace is enabled."
+				}
+			}
 		}
 	},
 	"scripts": {
 		"vscode:prepublish": "npm run package",
 		"compile": "npm run check-types && npm run lint && node esbuild.js",
-		"compile-standalone": "npm run protos && npm run check-types && npm run lint && node esbuild.js --standalone",
-		"postcompile-standalone": "node scripts/package-standalone.mjs",
 		"watch": "npm-run-all -p watch:*",
 		"watch:esbuild": "node esbuild.js --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
 		"package": "npm run build:webview && npm run check-types && npm run lint && node esbuild.js --production",
-		"protos": "node proto/build-proto.js && node scripts/generate-server-setup.mjs",
-		"postprotos": "prettier src/shared/proto src/core/controller webview-ui/src/services src/standalone/server-setup.ts --write --log-level silent",
+		"protos": "node proto/build-proto.js && prettier src/shared/proto --write && prettier src/core/controller --write",
 		"compile-tests": "node ./scripts/build-tests.js",
 		"watch-tests": "tsc -p . -w --outDir out",
 		"pretest": "npm run compile-tests && npm run compile && npm run lint",
@@ -271,9 +313,7 @@
 		"prepare": "husky",
 		"changeset": "changeset",
 		"version-packages": "changeset version",
-		"docs": "cd docs && mintlify dev",
-		"docs:check-links": "cd docs && mintlify broken-links",
-		"docs:rename-file": "cd docs && mintlify rename",
+		"docs:preview": "cd docs && mintlify dev",
 		"report-issue": "node scripts/report-issue.js"
 	},
 	"devDependencies": {
@@ -319,9 +359,8 @@
 		"@aws-sdk/client-bedrock-runtime": "^3.758.0",
 		"@bufbuild/protobuf": "^2.2.5",
 		"@google-cloud/vertexai": "^1.9.3",
-		"@google/genai": "^0.13.0",
+		"@google/genai": "^0.9.0",
 		"@grpc/grpc-js": "^1.9.15",
-		"@grpc/reflection": "^1.0.4",
 		"@mistralai/mistralai": "^1.5.0",
 		"@modelcontextprotocol/sdk": "^1.7.0",
 		"@opentelemetry/api": "^1.4.1",
@@ -332,7 +371,6 @@
 		"@opentelemetry/semantic-conventions": "^1.30.0",
 		"@sentry/browser": "^9.12.0",
 		"@vscode/codicons": "^0.0.36",
-		"archiver": "^7.0.1",
 		"axios": "^1.8.2",
 		"cheerio": "^1.0.0",
 		"chokidar": "^4.0.1",
@@ -346,16 +384,14 @@
 		"fzf": "^0.5.2",
 		"get-folder-size": "^5.0.0",
 		"globby": "^14.0.2",
-		"grpc-health-check": "^2.0.2",
 		"iconv-lite": "^0.6.3",
 		"ignore": "^7.0.3",
-		"image-size": "^2.0.2",
 		"isbinaryfile": "^5.0.2",
 		"jschardet": "^3.1.4",
 		"mammoth": "^1.8.0",
 		"monaco-vscode-textmate-theme-converter": "^0.1.7",
+		"node-cache": "^5.1.2",
 		"ollama": "^0.5.13",
-		"open": "^10.1.2",
 		"open-graph-scraper": "^6.9.0",
 		"openai": "^4.83.0",
 		"os-name": "^6.0.0",
@@ -369,7 +405,6 @@
 		"simple-git": "^3.27.0",
 		"strip-ansi": "^7.1.0",
 		"tree-sitter-wasms": "^0.1.11",
-		"ts-morph": "^25.0.1",
 		"turndown": "^7.2.0",
 		"web-tree-sitter": "^0.22.6",
 		"zod": "^3.24.2"
@@ -40,8 +40,6 @@ message BrowserSettings {
  Viewport viewport = 1;
  optional string remote_browser_host = 2;
  optional bool remote_browser_enabled = 3;
-  optional string chrome_executable_path = 4;
-  optional bool disable_tool_use = 5;
 }

 message UpdateBrowserSettingsRequest {
@@ -49,6 +47,4 @@ message UpdateBrowserSettingsRequest {
  Viewport viewport = 2;
  optional string remote_browser_host = 3;
  optional bool remote_browser_enabled = 4;
-  optional string chrome_executable_path = 5;
-  optional bool disable_tool_use = 6;
 }
@@ -12,28 +12,11 @@ const require = createRequire(import.meta.url)
 const protoc = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 const tsProtoPlugin = require.resolve("ts-proto/protoc-gen-ts_proto")

+// Get script directory and root directory
 const __filename = fileURLToPath(import.meta.url)
 const SCRIPT_DIR = path.dirname(__filename)
 const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")

-// List of gRPC services
-// To add a new service, simply add it to this map and run this script
-// The service handler will be automatically discovered and used by grpc-handler.ts
-const serviceNameMap = {
-	account: "cline.AccountService",
-	browser: "cline.BrowserService",
-	checkpoints: "cline.CheckpointsService",
-	file: "cline.FileService",
-	mcp: "cline.McpService",
-	state: "cline.StateService",
-	task: "cline.TaskService",
-	web: "cline.WebService",
-	models: "cline.ModelsService",
-	slash: "cline.SlashService",
-	// Add new services here - no other code changes needed!
-}
-const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src", "core", "controller", serviceKey))
-
 async function main() {
 	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))

@@ -50,181 +33,72 @@ async function main() {
 		await fs.unlink(path.join(TS_OUT_DIR, file))
 	}

-	// Check for missing proto files for services in serviceNameMap
-	await ensureProtoFilesExist()
-
 	// Process all proto files
 	console.log(chalk.cyan("Processing proto files from"), SCRIPT_DIR)
-	const protoFiles = await globby("*.proto", { cwd: SCRIPT_DIR, absolute: true })
+	const protoFiles = await globby("*.proto", { cwd: SCRIPT_DIR })

-	// Build the protoc command with proper path handling for cross-platform
-	const tsProtocCommand = [
-		protoc,
-		`--proto_path="${SCRIPT_DIR}"`,
-		`--plugin=protoc-gen-ts_proto="${tsProtoPlugin}"`,
-		`--ts_proto_out="${TS_OUT_DIR}"`,
-		"--ts_proto_opt=outputServices=generic-definitions,env=node,esModuleInterop=true,useDate=false,useOptionals=messages",
-		...protoFiles,
-	].join(" ")
-	try {
-		console.log(chalk.cyan(`Generating TypeScript code for:\n${protoFiles.join("\n")}...`))
-		execSync(tsProtocCommand, { stdio: "inherit" })
-	} catch (error) {
-		console.error(chalk.red("Error generating TypeScript for proto files:"), error)
-		process.exit(1)
-	}
+	for (const protoFile of protoFiles) {
+		console.log(chalk.cyan(`Generating TypeScript code for ${protoFile}...`))

-	const descriptorOutDir = path.join(ROOT_DIR, "dist-standalone", "proto")
-	await fs.mkdir(descriptorOutDir, { recursive: true })
+		// Build the protoc command with proper path handling for cross-platform
+		const protocCommand = [
+			protoc,
+			`--plugin=protoc-gen-ts_proto="${tsProtoPlugin}"`,
+			`--ts_proto_out="${TS_OUT_DIR}"`,
+			"--ts_proto_opt=outputServices=generic-definitions,env=node,esModuleInterop=true,useDate=false,useOptionals=messages",
+			`--proto_path="${SCRIPT_DIR}"`,
+			`"${path.join(SCRIPT_DIR, protoFile)}"`,
+		].join(" ")

-	const descriptorFile = path.join(descriptorOutDir, "descriptor_set.pb")
-	const descriptorProtocCommand = [
-		protoc,
-		`--proto_path="${SCRIPT_DIR}"`,
-		`--descriptor_set_out="${descriptorFile}"`,
-		"--include_imports",
-		...protoFiles,
-	].join(" ")
-	try {
-		console.log(chalk.cyan("Generating descriptor set..."))
-		execSync(descriptorProtocCommand, { stdio: "inherit" })
-	} catch (error) {
-		console.error(chalk.red("Error generating descriptor set for proto file:"), error)
-		process.exit(1)
+		try {
+			const execOptions = {
+				stdio: "inherit",
+			}
+			execSync(protocCommand, execOptions)
+		} catch (error) {
+			console.error(chalk.red(`Error generating TypeScript for ${protoFile}:`), error)
+			process.exit(1)
+		}
 	}

 	console.log(chalk.green("Protocol Buffer code generation completed successfully."))
 	console.log(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))

+	// Generate method registration files
 	await generateMethodRegistrations()
-	await generateServiceConfig()
-	await generateGrpcClientConfig()
-}

-/**
- * Generate a gRPC client configuration file for the webview
- * This eliminates the need for manual imports and client creation in grpc-client.ts
- */
-async function generateGrpcClientConfig() {
-	console.log(chalk.cyan("Generating gRPC client configuration..."))
-
-	const serviceImports = []
-	const serviceClientCreations = []
-	const serviceExports = []
-
-	// Process each service in the serviceNameMap
-	for (const [dirName, fullServiceName] of Object.entries(serviceNameMap)) {
-		const capitalizedName = dirName.charAt(0).toUpperCase() + dirName.slice(1)
-
-		// Add import statement
-		serviceImports.push(`import { ${capitalizedName}ServiceDefinition } from "@shared/proto/${dirName}"`)
-
-		// Add client creation
-		serviceClientCreations.push(
-			`const ${capitalizedName}ServiceClient = createGrpcClient(${capitalizedName}ServiceDefinition)`,
-		)
-
-		// Add to exports
-		serviceExports.push(`${capitalizedName}ServiceClient`)
+	// Make the script executable
+	try {
+		await fs.chmod(path.join(SCRIPT_DIR, "build-proto.js"), 0o755)
+	} catch (error) {
+		console.warn(chalk.yellow("Warning: Could not make script executable:"), error)
 	}
-
-	// Generate the file content
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { createGrpcClient } from "./grpc-client-base"
-${serviceImports.join("\n")}
-
-${serviceClientCreations.join("\n")}
-
-export {
-	${serviceExports.join(",\n\t")}
-}`
-
-	const configPath = path.join(ROOT_DIR, "webview-ui", "src", "services", "grpc-client.ts")
-	await fs.writeFile(configPath, content)
-	console.log(chalk.green(`Generated gRPC client at ${configPath}`))
-}
-
-/**
- * Parse proto files to extract streaming method information
- * @param protoFiles Array of proto file names
- * @param scriptDir Directory containing proto files
- * @returns Map of service names to their streaming methods
- */
-async function parseProtoForStreamingMethods(protoFiles, scriptDir) {
-	console.log(chalk.cyan("Parsing proto files for streaming methods..."))
-
-	// Map of service name to array of streaming method names
-	const streamingMethodsMap = new Map()
-
-	for (const protoFile of protoFiles) {
-		const content = await fs.readFile(path.join(scriptDir, protoFile), "utf8")
-
-		// Extract package name
-		const packageMatch = content.match(/package\s+([^;]+);/)
-		const packageName = packageMatch ? packageMatch[1].trim() : "unknown"
-
-		// Extract service definitions
-		const serviceMatches = Array.from(content.matchAll(/service\s+(\w+)\s*\{([^}]+)\}/g))
-		for (const serviceMatch of serviceMatches) {
-			const serviceName = serviceMatch[1]
-			const serviceBody = serviceMatch[2]
-			const fullServiceName = `${packageName}.${serviceName}`
-
-			// Extract method definitions with streaming
-			const methodMatches = Array.from(
-				serviceBody.matchAll(/rpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s*returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g),
-			)
-
-			const streamingMethods = []
-			for (const methodMatch of methodMatches) {
-				const methodName = methodMatch[1]
-				const isRequestStreaming = !!methodMatch[2]
-				const requestType = methodMatch[3]
-				const isResponseStreaming = !!methodMatch[4]
-				const responseType = methodMatch[5]
-
-				if (isResponseStreaming) {
-					streamingMethods.push({
-						name: methodName,
-						requestType,
-						responseType,
-						isRequestStreaming,
-					})
-				}
-			}
-
-			if (streamingMethods.length > 0) {
-				streamingMethodsMap.set(fullServiceName, streamingMethods)
-			}
-		}
-	}
-
-	return streamingMethodsMap
 }

 async function generateMethodRegistrations() {
 	console.log(chalk.cyan("Generating method registration files..."))

-	// Parse proto files for streaming methods
-	const protoFiles = await globby("*.proto", { cwd: SCRIPT_DIR })
-	const streamingMethodsMap = await parseProtoForStreamingMethods(protoFiles, SCRIPT_DIR)
+	const serviceDirs = [
+		path.join(ROOT_DIR, "src", "core", "controller", "account"),
+		path.join(ROOT_DIR, "src", "core", "controller", "browser"),
+		path.join(ROOT_DIR, "src", "core", "controller", "checkpoints"),
+		path.join(ROOT_DIR, "src", "core", "controller", "file"),
+		path.join(ROOT_DIR, "src", "core", "controller", "mcp"),
+		path.join(ROOT_DIR, "src", "core", "controller", "task"),
+		path.join(ROOT_DIR, "src", "core", "controller", "web-content"),
+		// Add more service directories here as needed
+	]

 	for (const serviceDir of serviceDirs) {
 		try {
 			await fs.access(serviceDir)
 		} catch (error) {
-			console.log(chalk.cyan(`Creating directory ${serviceDir} for new service`))
-			await fs.mkdir(serviceDir, { recursive: true })
+			console.log(chalk.gray(`Skipping ${serviceDir} - directory does not exist`))
+			continue
 		}

 		const serviceName = path.basename(serviceDir)
 		const registryFile = path.join(serviceDir, "methods.ts")
-		const indexFile = path.join(serviceDir, "index.ts")
-
-		const fullServiceName = serviceNameMap[serviceName]
-		const streamingMethods = streamingMethodsMap.get(fullServiceName) || []

 		console.log(chalk.cyan(`Generating method registrations for ${serviceName}...`))

@@ -234,8 +108,8 @@ async function generateMethodRegistrations() {
 		// Filter out index.ts and methods.ts
 		const implementationFiles = files.filter((file) => file !== "index.ts" && file !== "methods.ts")

-		// Create the methods.ts file with header
-		let methodsContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
+		// Create the output file with header
+		let content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
 // Generated by proto/build-proto.js

 // Import all method implementations
@@ -244,177 +118,31 @@ import { registerMethod } from "./index"\n`
 		// Add imports for all implementation files
 		for (const file of implementationFiles) {
 			const baseName = path.basename(file, ".ts")
-			methodsContent += `import { ${baseName} } from "./${baseName}"\n`
-		}
-
-		// Add streaming methods information
-		if (streamingMethods.length > 0) {
-			methodsContent += `\n// Streaming methods for this service
-export const streamingMethods = ${JSON.stringify(
-				streamingMethods.map((m) => m.name),
-				null,
-				2,
-			)}\n`
+			content += `import { ${baseName} } from "./${baseName}"\n`
 		}

 		// Add registration function
-		methodsContent += `\n// Register all ${serviceName} service methods
+		content += `\n// Register all ${serviceName} service methods
 export function registerAllMethods(): void {
 \t// Register each method with the registry\n`

 		// Add registration statements
 		for (const file of implementationFiles) {
 			const baseName = path.basename(file, ".ts")
-			const isStreaming = streamingMethods.some((m) => m.name === baseName)
-
-			if (isStreaming) {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName}, { isStreaming: true })\n`
-			} else {
-				methodsContent += `\tregisterMethod("${baseName}", ${baseName})\n`
-			}
+			content += `\tregisterMethod("${baseName}", ${baseName})\n`
 		}

 		// Close the function
-		methodsContent += `}`
+		content += `}`

-		// Write the methods.ts file
-		await fs.writeFile(registryFile, methodsContent)
+		// Write the file
+		await fs.writeFile(registryFile, content)
 		console.log(chalk.green(`Generated ${registryFile}`))
-
-		// Generate index.ts file
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1)
-		const indexContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
-import { registerAllMethods } from "./methods"
-
-// Create ${serviceName} service registry
-const ${serviceName}Service = createServiceRegistry("${serviceName}")
-
-// Export the method handler types and registration function
-export type ${capitalizedServiceName}MethodHandler = ServiceMethodHandler
-export type ${capitalizedServiceName}StreamingMethodHandler = StreamingMethodHandler
-export const registerMethod = ${serviceName}Service.registerMethod
-
-// Export the request handlers
-export const handle${capitalizedServiceName}ServiceRequest = ${serviceName}Service.handleRequest
-export const handle${capitalizedServiceName}ServiceStreamingRequest = ${serviceName}Service.handleStreamingRequest
-export const isStreamingMethod = ${serviceName}Service.isStreamingMethod
-
-// Register all ${serviceName} methods
-registerAllMethods()`
-
-		// Write the index.ts file
-		await fs.writeFile(indexFile, indexContent)
-		console.log(chalk.green(`Generated ${indexFile}`))
 	}

 	console.log(chalk.green("Method registration files generated successfully."))
 }

-/**
- * Generate a service configuration file that maps service names to their handlers
- * This eliminates the need for manual switch/case statements in grpc-handler.ts
- */
-async function generateServiceConfig() {
-	console.log(chalk.cyan("Generating service configuration file..."))
-
-	const serviceImports = []
-	const serviceConfigs = []
-
-	// Add all services from the serviceNameMap
-	for (const [dirName, fullServiceName] of Object.entries(serviceNameMap)) {
-		const capitalizedName = dirName.charAt(0).toUpperCase() + dirName.slice(1)
-		serviceImports.push(
-			`import { handle${capitalizedName}ServiceRequest, handle${capitalizedName}ServiceStreamingRequest } from "./${dirName}/index"`,
-		)
-		serviceConfigs.push(`
-  "${fullServiceName}": {
-    requestHandler: handle${capitalizedName}ServiceRequest,
-    streamingHandler: handle${capitalizedName}ServiceStreamingRequest
-  }`)
-	}
-
-	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { Controller } from "./index"
-import { StreamingResponseHandler } from "./grpc-handler"
-${serviceImports.join("\n")}
-
-/**
- * Configuration for a service handler
- */
-export interface ServiceHandlerConfig {
-  requestHandler: (controller: Controller, method: string, message: any) => Promise<any>;
-  streamingHandler: (controller: Controller, method: string, message: any, responseStream: StreamingResponseHandler, requestId?: string) => Promise<void>;
-}
-
-/**
- * Map of service names to their handler configurations
- */
-export const serviceHandlers: Record<string, ServiceHandlerConfig> = {${serviceConfigs.join(",")}
-};`
-
-	const configPath = path.join(ROOT_DIR, "src", "core", "controller", "grpc-service-config.ts")
-	await fs.writeFile(configPath, content)
-	console.log(chalk.green(`Generated service configuration at ${configPath}`))
-}
-
-/**
- * Ensure that a .proto file exists for each service in the serviceNameMap
- * If a .proto file doesn't exist, create a template file
- */
-async function ensureProtoFilesExist() {
-	console.log(chalk.cyan("Checking for missing proto files..."))
-
-	// Get existing proto files
-	const existingProtoFiles = await globby("*.proto", { cwd: SCRIPT_DIR })
-	const existingProtoServices = existingProtoFiles.map((file) => path.basename(file, ".proto"))
-
-	// Check each service in serviceNameMap
-	for (const [serviceName, fullServiceName] of Object.entries(serviceNameMap)) {
-		if (!existingProtoServices.includes(serviceName)) {
-			console.log(chalk.yellow(`Creating template proto file for ${serviceName}...`))
-
-			// Extract service class name from full name (e.g., "cline.ModelsService" -> "ModelsService")
-			const serviceClassName = fullServiceName.split(".").pop()
-
-			// Create template proto file
-			const protoContent = `syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// ${serviceClassName} provides methods for managing ${serviceName}
-service ${serviceClassName} {
-  // Add your RPC methods here
-  // Example (String is from common.proto, responses should be generic types):
-  // rpc YourMethod(YourRequest) returns (String);
-}
-
-// Add your message definitions here
-// Example (Requests must always start with Metadata):
-// message YourRequest {
-//   Metadata metadata = 1;
-//   string stringField = 2;
-//   int32 int32Field = 3;
-// }
-`
-
-			// Write the template proto file
-			const protoFilePath = path.join(SCRIPT_DIR, `${serviceName}.proto`)
-			await fs.writeFile(protoFilePath, protoContent)
-			console.log(chalk.green(`Created template proto file at ${protoFilePath}`))
-		}
-	}
-}
-
 // Run the main function
 main().catch((error) => {
 	console.error(chalk.red("Error:"), error)
@@ -54,7 +54,3 @@ message BooleanRequest {
 message Boolean {
  bool value = 1;
 }
-
-message StringArray {
-  repeated string values = 1;
-}
@@ -22,15 +22,9 @@ service FileService {
  
  // Search git commits in the workspace
  rpc searchCommits(StringRequest) returns (GitCommits);
-
-  // Select images from the file system and return as data URLs
-  rpc selectImages(EmptyRequest) returns (StringArray);
  
  // Convert URIs to workspace-relative paths
  rpc getRelativePaths(RelativePathsRequest) returns (RelativePaths);
-
-  // Search for files in the workspace with fuzzy matching
-  rpc searchFiles(FileSearchRequest) returns (FileSearchResults);
 }

 // Request to convert a list of URIs to relative paths
@@ -44,27 +38,6 @@ message RelativePaths {
  repeated string paths = 1;
 }

-// Request for file search operations
-message FileSearchRequest {
-  Metadata metadata = 1;
-  string query = 2;                  // Search query string
-  optional string mentions_request_id = 3;  // Optional request ID for tracking requests
-  optional int32 limit = 4;          // Optional limit for results (default: 20)
-}
-
-// Result for file search operations
-message FileSearchResults {
-  repeated FileInfo results = 1;     // Array of file/folder results
-  optional string mentions_request_id = 2;  // Echo of the request ID for tracking
-}
-
-// File information structure for search results
-message FileInfo {
-  string path = 1;                   // Relative path from workspace root
-  string type = 2;                   // "file" or "folder"
-  optional string label = 3;         // Display name (usually basename)
-}
-
 // Response for searchCommits
 message GitCommits {
  repeated GitCommit commits = 1;
@@ -85,7 +58,6 @@ message RuleFileRequest {
  bool is_global = 2;            // Common field for all operations
  optional string rule_path = 3; // Path field for deleteRuleFile (optional)
  optional string filename = 4;  // Filename field for createRuleFile (optional)
-  optional string type = 5;      // Type of the file to create (optional)
 }

 // Result for rule file operations with meaningful data only
@@ -94,3 +66,4 @@ message RuleFile {
  string display_name = 2;  // Filename for display purposes
  bool already_exists = 3;  // For createRuleFile, indicates if file already existed
 }
+
@@ -10,7 +10,6 @@ service McpService {
  rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
  rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
  rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
-  rpc downloadMcp(StringRequest) returns (Empty);
 }

 message ToggleMcpServerRequest {
@@ -1,61 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// Service for model-related operations
-service ModelsService {
-  // Fetches available models from Ollama
-  rpc getOllamaModels(StringRequest) returns (StringArray);
-  // Fetches available models from LM Studio
-  rpc getLmStudioModels(StringRequest) returns (StringArray);
-  // Fetches available models from VS Code LM API
-  rpc getVsCodeLmModels(EmptyRequest) returns (VsCodeLmModelsArray);
-  // Refreshes and returns OpenRouter models
-  rpc refreshOpenRouterModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
-  // Refreshes and returns OpenAI models
-  rpc refreshOpenAiModels(OpenAiModelsRequest) returns (StringArray);
-  // Refreshes and returns Requesty models
-  rpc refreshRequestyModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
-}
-
-// List of VS Code LM models
-message VsCodeLmModelsArray {
-  repeated VsCodeLmModel models = 1;
-}
-
-// Structure representing a VS Code LM model
-message VsCodeLmModel {
-  string vendor = 1;
-  string family = 2;
-  string version = 3;
-  string id = 4;
-}
-
-// For OpenRouterCompatibleModelInfo structure in OpenRouterModels
-message OpenRouterModelInfo {
-  int32 max_tokens = 1;
-  int32 context_window = 2;
-  bool supports_images = 3;
-  bool supports_prompt_cache = 4;
-  double input_price = 5;
-  double output_price = 6;
-  double cache_writes_price = 7;
-  double cache_reads_price = 8;
-  string description = 9;
-}
-
-// Shared response message for model information
-message OpenRouterCompatibleModelInfo {
-  map<string, OpenRouterModelInfo> models = 1;
-}
-
-// Request for fetching OpenAI models
-message OpenAiModelsRequest {
-  Metadata metadata = 1;
-  string baseUrl = 2;
-  string apiKey = 3;
-}
@@ -1,14 +0,0 @@
-syntax = "proto3";
-
-package cline;
-option java_package = "bot.cline.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// SlashService provides methods for managing slash
-service SlashService {
-  // Sends button click message
-  rpc reportBug(StringRequest) returns (Empty);
-  rpc condense(StringRequest) returns (Empty);
-}
@@ -1,14 +0,0 @@
-syntax = "proto3";
-package cline;
-
-import "common.proto";
-
-service StateService {
-  rpc getLatestState(EmptyRequest) returns (State);
-  rpc subscribeToState(EmptyRequest) returns (stream State);
-  rpc toggleFavoriteModel(StringRequest) returns (Empty);
-}
-
-message State {
-  string state_json = 1;
-}
@@ -15,18 +15,6 @@ service TaskService {
  rpc deleteTasksWithIds(StringArrayRequest) returns (Empty);
  // Creates a new task with the given text and optional images
  rpc newTask(NewTaskRequest) returns (Empty);
-  // Shows a task with the specified ID
-  rpc showTaskWithId(StringRequest) returns (TaskResponse);
-  // Exports a task with the given ID to markdown
-  rpc exportTaskWithId(StringRequest) returns (Empty);
-  // Toggles the favorite status of a task
-  rpc toggleTaskFavorite(TaskFavoriteRequest) returns (Empty);
-  // Deletes all non-favorited tasks
-  rpc deleteNonFavoritedTasks(EmptyRequest) returns (DeleteNonFavoritedTasksResults);
-  // Gets filtered task history
-  rpc getTaskHistory(GetTaskHistoryRequest) returns (TaskHistoryArray);
-  // Sends a response to a previous ask operation
-  rpc askResponse(AskResponseRequest) returns (Empty);
 }

 // Request message for creating a new task
@@ -35,67 +23,3 @@ message NewTaskRequest {
  string text = 2;
  repeated string images = 3;
 }
-
-// Request message for toggling task favorite status
-message TaskFavoriteRequest {
-  Metadata metadata = 1;
-  string task_id = 2;
-  bool is_favorited = 3;
-}
-
-// Response for task details
-message TaskResponse {
-  string id = 1;
-  string task = 2;
-  int64 ts = 3;
-  bool is_favorited = 4;
-  int64 size = 5;
-  double total_cost = 6;
-  int32 tokens_in = 7;
-  int32 tokens_out = 8;
-  int32 cache_writes = 9;
-  int32 cache_reads = 10;
-}
-
-// Results returned when deleting non-favorited tasks
-message DeleteNonFavoritedTasksResults {
-  int32 tasks_preserved = 1;
-  int32 tasks_deleted = 2;
-}
-
-// Request for getting task history with filtering
-message GetTaskHistoryRequest {
-  Metadata metadata = 1;
-  bool favorites_only = 2;
-  string search_query = 3;
-  string sort_by = 4;
-  bool current_workspace_only = 5;
-}
-
-// Response for task history
-message TaskHistoryArray {
-  repeated TaskItem tasks = 1;
-  int32 total_count = 2;
-}
-
-// Task item details for history list
-message TaskItem {
-  string id = 1;
-  string task = 2;
-  int64 ts = 3;
-  bool is_favorited = 4;
-  int64 size = 5;
-  double total_cost = 6;
-  int32 tokens_in = 7;
-  int32 tokens_out = 8;
-  int32 cache_writes = 9;
-  int32 cache_reads = 10;
-}
-
-// Request for ask response operation
-message AskResponseRequest {
-  Metadata metadata = 1;
-  string response_type = 2; 
-  string text = 3;
-  repeated string images = 4;
-}
@@ -6,7 +6,7 @@ option java_multiple_files = true;

 import "common.proto";

-service WebService {
+service WebContentService {
  rpc checkIsImageUrl(StringRequest) returns (IsImageUrl);
 }

@@ -1,79 +0,0 @@
-import * as fs from "fs"
-import * as grpc from "@grpc/grpc-js"
-import * as protoLoader from "@grpc/proto-loader"
-import * as health from "grpc-health-check"
-import { fileURLToPath } from "url"
-import path from "path"
-
-const OUT_FILE = path.resolve("src/standalone/server-setup.ts")
-const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
-
-// Load service definitions.
-const clineDef = protoLoader.loadFileDescriptorSetFromBuffer(fs.readFileSync(DESCRIPTOR_SET))
-const healthDef = protoLoader.loadSync(health.protoPath)
-const packageDefinition = { ...clineDef, ...healthDef }
-const proto = grpc.loadPackageDefinition(packageDefinition)
-
-/**
- * Generate imports and function to add all the handlers to the server for all services defined in the proto files.
- */
-function generateHandlersAndExports() {
-	let imports = []
-	let handlerSetup = []
-
-	for (const [name, def] of Object.entries(proto.cline)) {
-		if (!def || !("service" in def)) {
-			continue
-		}
-		const domain = name.replace(/Service$/, "")
-		const dir = domain.charAt(0).toLowerCase() + domain.slice(1)
-		imports.push(`// ${domain} Service`)
-		handlerSetup.push(`    // ${domain} Service`)
-		handlerSetup.push(`    server.addService(proto.cline.${name}.service, {`)
-		for (const [rpcName, rpc] of Object.entries(def.service)) {
-			imports.push(`import { ${rpcName} } from "../core/controller/${dir}/${rpcName}"`)
-			if (rpc.requestStream) {
-				throw new Error("Request streaming is not supported")
-			}
-			if (rpc.responseStream) {
-				handlerSetup.push(`        ${rpcName}: wrapStreamingResponse(${rpcName}, controller),`)
-			} else {
-				handlerSetup.push(`         ${rpcName}: wrapper(${rpcName}, controller),`)
-			}
-		}
-		handlerSetup.push(`    });`)
-		imports.push("")
-		handlerSetup.push("")
-	}
-	return {
-		imports: imports.join("\n"),
-		handlerSetup: handlerSetup.join("\n"),
-	}
-}
-
-const { imports, handlerSetup } = generateHandlersAndExports()
-const scriptName = path.basename(fileURLToPath(import.meta.url))
-
-// Create output file
-let output = `// GENERATED CODE -- DO NOT EDIT!
-// Generated by ${scriptName}
-import * as grpc from "@grpc/grpc-js"
-import { Controller } from "../core/controller"
-import { GrpcHandlerWrapper, GrpcStreamingResponseHandlerWrapper } from "./grpc-types"
-
-${imports}
-
-export function addServices(
-	server: grpc.Server,
-	proto: any,
-	controller: Controller,
-	wrapper: GrpcHandlerWrapper,
-	wrapStreamingResponse: GrpcStreamingResponseHandlerWrapper,
-): void {
-${handlerSetup}
-}
-`
-// Write output file
-fs.writeFileSync(OUT_FILE, output)
-
-console.log(`Generated service handlers in ${OUT_FILE}.`)
@@ -1,96 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-const { Project, SyntaxKind } = require("ts-morph")
-
-function traverse(container, output, prefix = "") {
-	for (const node of container.getStatements()) {
-		const kind = node.getKind()
-
-		if (kind === SyntaxKind.ModuleDeclaration) {
-			const name = node.getName().replace(/^['"]|['"]$/g, "")
-			var fullPrefix
-			if (prefix) {
-				fullPrefix = `${prefix}.${name}`
-			} else {
-				fullPrefix = name
-			}
-			output.push(`${fullPrefix} = {};`)
-			const body = node.getBody()
-			if (body && body.getKind() === SyntaxKind.ModuleBlock) {
-				traverse(body, output, fullPrefix)
-			}
-		} else if (kind === SyntaxKind.FunctionDeclaration) {
-			const name = node.getName()
-			const params = node.getParameters().map((p, i) => sanitizeParam(p.getName(), i))
-			const typeNode = node.getReturnTypeNode()
-			const returnType = typeNode ? typeNode.getText() : ""
-			const ret = mapReturn(returnType)
-			output.push(
-				`${prefix}.${name} = function(${params.join(", ")}) { console.log('Called stubbed function: ${prefix}.${name}');  ${ret} };`,
-			)
-		} else if (kind === SyntaxKind.EnumDeclaration) {
-			const name = node.getName()
-			const members = node.getMembers().map((m) => m.getName())
-			output.push(`${prefix}.${name} = { ${members.map((m) => `${m}: 0`).join(", ")} };`)
-		} else if (kind === SyntaxKind.VariableStatement) {
-			for (const decl of node.getDeclarations()) {
-				const name = decl.getName()
-				output.push(`${prefix}.${name} = createStub("${prefix}.${name}");`)
-			}
-		} else if (kind == SyntaxKind.ClassDeclaration) {
-			const name = node.getName()
-			output.push(
-				`${prefix}.${name} = class { constructor(...args) {
-  console.log('Constructed stubbed class: new ${prefix}.${name}(', args, ')');
-  return createStub(${prefix}.${name});
-}};`,
-			)
-		} else if (kind === SyntaxKind.TypeAliasDeclaration || kind === SyntaxKind.InterfaceDeclaration) {
-			//console.log("Skipping", SyntaxKind[kind], node.getName())
-			// Skip interfaces and type aliases because they are only used at compile time by typescript.
-		} else {
-			console.log("Can't handle: ", SyntaxKind[kind])
-		}
-	}
-}
-
-function mapReturn(typeStr) {
-	if (!typeStr) return ""
-	if (typeStr.includes("void")) return ""
-	if (typeStr.includes("string")) return `return '';`
-	if (typeStr.includes("number")) return `return 0;`
-	if (typeStr.includes("boolean")) return `return false;`
-	if (typeStr.includes("[]")) return `return [];`
-	if (typeStr.includes("Thenable")) return `return Promise.resolve(null);`
-	return `return createStub("unknown");`
-}
-
-function sanitizeParam(name, index) {
-	return name || `arg${index}`
-}
-
-async function main() {
-	const inputPath = "node_modules/@types/vscode/index.d.ts"
-	const outputPath = "standalone/runtime-files/vscode/vscode-stubs.js"
-
-	const project = new Project()
-	const sourceFile = project.addSourceFileAtPath(inputPath)
-
-	const output = []
-	output.push("// GENERATED CODE -- DO NOT EDIT!")
-	output.push('console.log("Loading stubs...");')
-	output.push('const { createStub } = require("./stub-utils")')
-	traverse(sourceFile, output)
-	output.push("module.exports = vscode;")
-	output.push('console.log("Finished loading stubs");')
-
-	fs.mkdirSync(path.dirname(outputPath), { recursive: true })
-	fs.writeFileSync(outputPath, output.join("\n"))
-
-	console.log(`Wrote vscode SDK stubs to ${outputPath}`)
-}
-
-main().catch((err) => {
-	console.error(err)
-	process.exit(1)
-})
@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-DIR=${1:-src/}
-DEST_DIR=dist-standalone
-DEST=dist-standalone/vscode-uses.txt
-mkdir -p $DEST_DIR
-
-{
-git grep -h 'vscode\.' $DIR |
-grep -Ev '//.*vscode' | # remove commented out code
-sed 's|.*vscode\.|vscode.|'| # remove everything before vscode.
-sed 's/[^a-zA-Z0-9_.].*$//' | # remove everything after last identifier
-sort | uniq > $DEST
-}
-
-echo Done, wrote uses of the vscode SDK to $(realpath $DEST)
-
@@ -1,51 +0,0 @@
-import fs from "fs"
-import path from "path"
-import { glob } from "glob"
-import archiver from "archiver"
-import { cp } from "fs/promises"
-import { execSync } from "child_process"
-
-const BUILD_DIR = "dist-standalone"
-const SOURCE_DIR = "standalone/runtime-files"
-
-await cp(SOURCE_DIR, BUILD_DIR, { recursive: true })
-
-// Run npm install in the distribution directory
-console.log("Running npm install in distribution directory...")
-const cwd = process.cwd()
-process.chdir(BUILD_DIR)
-try {
-	execSync("npm install", { stdio: "inherit" })
-} catch (error) {
-	console.error("Error running npm install:", error)
-	process.exit(1)
-} finally {
-	process.chdir(cwd)
-}
-
-// Check for native .node modules.
-const nativeModules = await glob("**/*.node", { cwd: BUILD_DIR, nodir: true })
-if (nativeModules.length > 0) {
-	console.error("Native node modules cannot be included in the standalone distribution:\n", nativeModules.join("\n"))
-	process.exit(1)
-}
-
-// Zip the build directory (excluding any pre-existing output zip).
-const zipPath = path.join(BUILD_DIR, "standalone.zip")
-const output = fs.createWriteStream(zipPath)
-const archive = archiver("zip", { zlib: { level: 9 } })
-
-output.on("close", () => {
-	console.log(`Created ${zipPath} (${archive.pointer()} bytes)`)
-})
-
-archive.on("error", (err) => {
-	throw err
-})
-
-archive.pipe(output)
-archive.glob("**/*", {
-	cwd: BUILD_DIR,
-	ignore: ["standalone.zip"],
-})
-await archive.finalize()
@@ -19,7 +19,6 @@ import { DoubaoHandler } from "./providers/doubao"
 import { VsCodeLmHandler } from "./providers/vscode-lm"
 import { ClineHandler } from "./providers/cline"
 import { LiteLlmHandler } from "./providers/litellm"
-import { FireworksHandler } from "./providers/fireworks"
 import { AskSageHandler } from "./providers/asksage"
 import { XAIHandler } from "./providers/xai"
 import { SambanovaHandler } from "./providers/sambanova"
@@ -59,8 +58,6 @@ export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
 			return new DeepSeekHandler(options)
 		case "requesty":
 			return new RequestyHandler(options)
-		case "fireworks":
-			return new FireworksHandler(options)
 		case "together":
 			return new TogetherHandler(options)
 		case "qwen":
@@ -272,14 +272,10 @@ export class AwsBedrockHandler implements ApiHandler {
 	}

 	/**
-	 * Gets the appropriate model ID, accounting for cross-region inference if enabled.
-	 * If the model ID is an ARN that contains a slash, you will get the URL encoded ARN.
+	 * Gets the appropriate model ID, accounting for cross-region inference if enabled
 	 */
 	async getModelId(): Promise<string> {
-		if (this.options.awsBedrockCustomSelected && this.getModel().id.includes("/")) {
-			return encodeURIComponent(this.getModel().id)
-		}
-		if (!this.options.awsBedrockCustomSelected && this.options.awsUseCrossRegionInference) {
+		if (this.options.awsUseCrossRegionInference) {
 			const regionPrefix = this.getRegion().slice(0, 3)
 			switch (regionPrefix) {
 				case "us-":
@@ -33,7 +33,7 @@ export class ClineHandler implements ApiHandler {
 			systemPrompt,
 			messages,
 			this.getModel(),
-			this.options.reasoningEffort,
+			this.options.o3MiniReasoningEffort,
 			this.options.thinkingBudgetTokens,
 			this.options.openRouterProviderSorting,
 		)
@@ -107,8 +107,9 @@ export class ClineHandler implements ApiHandler {
 				const generation = response.data
 				return {
 					type: "usage",
+					// at this time there's no support for gatting cached_tokens from generation endpoint
 					cacheWriteTokens: 0,
-					cacheReadTokens: generation?.native_tokens_cached || 0,
+					cacheReadTokens: 0,
 					inputTokens: generation?.native_tokens_prompt || 0,
 					outputTokens: generation?.native_tokens_completion || 0,
 					totalCost: generation?.total_cost || 0,
@@ -1,94 +0,0 @@
-import { Anthropic } from "@anthropic-ai/sdk"
-import OpenAI from "openai"
-import { withRetry } from "../retry"
-import { ApiHandler } from ".."
-import {
-	ApiHandlerOptions,
-	DeepSeekModelId,
-	ModelInfo,
-	deepSeekDefaultModelId,
-	deepSeekModels,
-	openAiModelInfoSaneDefaults,
-} from "../../shared/api"
-import { convertToOpenAiMessages } from "../transform/openai-format"
-import { ApiStream } from "../transform/stream"
-
-export class FireworksHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
-
-	constructor(options: ApiHandlerOptions) {
-		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.fireworks.ai/inference/v1",
-			apiKey: this.options.fireworksApiKey,
-		})
-	}
-
-	@withRetry()
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const modelId = this.options.fireworksModelId ?? ""
-
-		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
-			{ role: "system", content: systemPrompt },
-			...convertToOpenAiMessages(messages),
-		]
-
-		const stream = await this.client.chat.completions.create({
-			model: modelId,
-			...(this.options.fireworksModelMaxCompletionTokens
-				? { max_completion_tokens: this.options.fireworksModelMaxCompletionTokens }
-				: {}),
-			...(this.options.fireworksModelMaxTokens ? { max_tokens: this.options.fireworksModelMaxTokens } : {}),
-			messages: openAiMessages,
-			stream: true,
-			stream_options: { include_usage: true },
-			temperature: 0,
-		})
-
-		let reasoning: string | null = null
-		for await (const chunk of stream) {
-			const delta = chunk.choices[0]?.delta
-			if (reasoning || delta?.content?.includes("<think>")) {
-				reasoning = (reasoning || "") + (delta.content ?? "")
-			}
-
-			if (delta?.content && !reasoning) {
-				yield {
-					type: "text",
-					text: delta.content,
-				}
-			}
-
-			if (reasoning || ("reasoning_content" in delta && delta.reasoning_content)) {
-				yield {
-					type: "reasoning",
-					reasoning: delta.content || ((delta as any).reasoning_content as string | undefined) || "",
-				}
-				if (reasoning?.includes("</think>")) {
-					// Reset so the next chunk is regular content
-					reasoning = null
-				}
-			}
-
-			if (chunk.usage) {
-				yield {
-					type: "usage",
-					inputTokens: chunk.usage.prompt_tokens || 0, // (deepseek reports total input AND cache reads/writes, see context caching: https://api-docs.deepseek.com/guides/kv_cache) where the input tokens is the sum of the cache hits/misses, while anthropic reports them as separate tokens. This is important to know for 1) context management truncation algorithm, and 2) cost calculation (NOTE: we report both input and cache stats but for now set input price to 0 since all the cost calculation will be done using cache hits/misses)
-					outputTokens: chunk.usage.completion_tokens || 0,
-					// @ts-ignore-next-line
-					cacheReadTokens: chunk.usage.prompt_cache_hit_tokens || 0,
-					// @ts-ignore-next-line
-					cacheWriteTokens: chunk.usage.prompt_cache_miss_tokens || 0,
-				}
-			}
-		}
-	}
-
-	getModel(): { id: string; info: ModelInfo } {
-		return {
-			id: this.options.fireworksModelId ?? "",
-			info: openAiModelInfoSaneDefaults,
-		}
-	}
-}
@@ -1,12 +1,12 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
 // Restore GenerateContentConfig import and add GenerateContentResponseUsageMetadata
-import { GoogleGenAI, type GenerateContentConfig, type GenerateContentResponseUsageMetadata } from "@google/genai"
+import { GoogleGenAI, type Content, type GenerateContentConfig, type GenerateContentResponseUsageMetadata } from "@google/genai"
+import NodeCache from "node-cache"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
 import { ApiHandlerOptions, geminiDefaultModelId, GeminiModelId, geminiModels, ModelInfo } from "@shared/api"
 import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
 import { ApiStream } from "../transform/stream"
-import { telemetryService } from "@services/posthog/telemetry/TelemetryService"

 // Define a default TTL for the cache (e.g., 15 minutes in seconds)
 const DEFAULT_CACHE_TTL_SECONDS = 900
@@ -39,6 +39,12 @@ export class GeminiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
 	private client: GoogleGenAI

+	// Enhanced caching system
+	private contentCaches: NodeCache // Stores cache details (key, count, etc.)
+	private isCacheBusy = false
+	private taskCacheNames: Map<string, string> = new Map() // Maps taskId to cache name for stable lookup
+	private taskCacheTokens: Map<string, number> = new Map() // Maps taskId to total tokens in cache
+
 	constructor(options: GeminiHandlerOptions) {
 		// Store the options
 		this.options = options
@@ -61,13 +67,26 @@ export class GeminiHandler implements ApiHandler {

 			this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
 		}
+
+		// Initialize cache with TTL and check period
+		this.contentCaches = new NodeCache({
+			stdTTL: DEFAULT_CACHE_TTL_SECONDS,
+			checkperiod: DEFAULT_CACHE_TTL_SECONDS,
+		})
 	}

 	/**
-	 * Creates a message using the Gemini API with implicit caching.
+	 * Creates a message using the Gemini API with optimized caching and split cost accounting.
+	 *
+	 * This method implements a task-based caching strategy:
+	 * 1. Each task gets its own cache, identified by taskId
+	 * 2. On first call for a task, a new cache is created
+	 * 3. On subsequent calls, the existing cache is reused and only new messages are sent
+	 * 4. Cache operations are tracked for accurate cost accounting
 	 *
 	 * Cost accounting:
 	 * - Immediate costs (returned in the usage object): Input tokens, output tokens, cache read costs
+	 * - Ongoing costs (tracked at task level): Cache storage costs for the TTL period
 	 *
 	 * @param systemPrompt The system prompt to use for the message
 	 * @param messages The conversation history to include in the message
@@ -75,9 +94,57 @@ export class GeminiHandler implements ApiHandler {
 	 */
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const { id: modelId, info } = this.getModel()
+		const { id: model, info } = this.getModel()
 		const contents = messages.map(convertAnthropicMessageToGemini)

+		// Ensure we have a stable cache key (taskId)
+		if (!this.options.taskId) {
+			console.warn("[GeminiHandler] No taskId provided, caching will be disabled")
+		}
+
+		const taskId = this.options.taskId
+
+		// Calculate total content length for cache eligibility check
+		const contentsLength = systemPrompt.length + this.getMessagesLength(contents)
+
+		// Minimum token threshold for caching (approx 4096 tokens)
+		const CONTEXT_CACHE_TOKEN_MINIMUM = 4096
+
+		let uncachedContent: Content[] | undefined = undefined
+		let cachedContent: string | undefined = undefined
+
+		// Check if caching is available and content is large enough to benefit from caching
+		// We only enable caching for conversations above a certain size to avoid overhead for small requests
+		const isCacheAvailable = info.supportsPromptCache && contentsLength > 4 * CONTEXT_CACHE_TOKEN_MINIMUM && taskId
+
+		// This flag tracks whether this operation involves a cache write/update
+		// It's used to track task-level ongoing costs, not immediate costs
+		let cacheWrite = false
+
+		if (isCacheAvailable) {
+			// Check if we already have a cache for this task
+			const existingCacheName = this.taskCacheNames.get(taskId)
+			const cacheEntry = existingCacheName ? this.contentCaches.get<{ key: string; count: number }>(taskId) : undefined
+
+			if (cacheEntry) {
+				// Use existing cache
+				uncachedContent = contents.slice(cacheEntry.count, contents.length)
+				cachedContent = cacheEntry.key
+				console.log(
+					`[GeminiHandler] using existing cache for task ${taskId}: ${cacheEntry.count} cached messages (${cacheEntry.key}) and ${uncachedContent.length} uncached messages`,
+				)
+			}
+
+			// Create or update cache only if there's new content to add
+			const shouldUpdateCache = !existingCacheName || (cacheEntry && uncachedContent && uncachedContent.length > 0)
+
+			if (shouldUpdateCache) {
+				// If we should update the cache, then there will be a cache write
+				cacheWrite = true
+			}
+		}
+		const isCacheUsed = !!cachedContent
+
 		// Configure thinking budget if supported
 		const thinkingBudget = this.options.thinkingBudgetTokens ?? 0
 		const maxBudget = info.thinkingConfig?.maxBudget ?? 0
@@ -86,7 +153,10 @@ export class GeminiHandler implements ApiHandler {
 		const requestConfig: GenerateContentConfig = {
 			// Add base URL if configured
 			httpOptions: this.options.geminiBaseUrl ? { baseUrl: this.options.geminiBaseUrl } : undefined,
-			...{ systemInstruction: systemPrompt },
+
+			// Only include systemInstruction if NOT using the cache
+			...(isCacheUsed ? {} : { systemInstruction: systemPrompt }),
+
 			// Set temperature (default to 0)
 			temperature: 0,
 		}
@@ -99,114 +169,260 @@ export class GeminiHandler implements ApiHandler {
 		}

 		// Generate content using the configured parameters
-		const sdkCallStartTime = Date.now()
-		let sdkFirstChunkTime: number | undefined
-		let ttftSdkMs: number | undefined
-		let apiSuccess = false
-		let apiError: string | undefined
-		let promptTokens = 0
-		let outputTokens = 0
-		let cacheReadTokens = 0
+		const result = await this.client.models.generateContentStream({
+			model,
+			contents: uncachedContent ?? contents,
+			config: {
+				...requestConfig,
+				...(isCacheUsed ? { cachedContent } : {}),
+			},
+		})
+
+		// Update the cache after the LLM request is already sent to avoid blocking
+		// We only update the cache if we have a taskId and the cache write flag is set
+		// This is a non-blocking operation and will not affect the response time
+		if (cacheWrite && taskId) {
+			this.updateCacheContent(taskId, model, contents, systemPrompt)
+		}
+		// Track usage metadata
 		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined

+		// Process the stream
+		for await (const chunk of result) {
+			if (chunk.text) {
+				yield {
+					type: "text",
+					text: chunk.text,
+				}
+			}
+
+			if (chunk.usageMetadata) {
+				lastUsageMetadata = chunk.usageMetadata
+			}
+		}
+
+		// Yield usage information at the end
+		if (lastUsageMetadata) {
+			const inputTokens = lastUsageMetadata.promptTokenCount ?? 0
+			const outputTokens = lastUsageMetadata.candidatesTokenCount ?? 0
+			const cacheReadTokens = lastUsageMetadata.cachedContentTokenCount
+
+			// Calculate immediate costs only (excluding cache write/storage costs)
+			const totalCost = this.calculateCost({
+				info,
+				inputTokens,
+				outputTokens,
+				cacheReadTokens,
+			})
+
+			// Store the token count for task-level ongoing cost tracking
+			// This is not included in the immediate costs returned to the user
+			const cacheWriteTokens = cacheWrite ? inputTokens : undefined
+
+			// If this is a cache write operation, update the task's ongoing costs
+			if (cacheWrite && this.options.taskId && inputTokens > 0) {
+				// Log the ongoing costs for debugging
+				const ongoingCosts = this.getTaskOngoingCosts(this.options.taskId)
+				console.log(
+					`[GeminiHandler] Task ${this.options.taskId} ongoing costs: $${ongoingCosts?.toFixed(6) ?? "unknown"}`,
+				)
+			}
+
+			yield {
+				type: "usage",
+				inputTokens,
+				outputTokens,
+				cacheReadTokens,
+				cacheWriteTokens,
+				totalCost,
+			}
+		}
+	}
+
+	/**
+	 * Lists all caches for the current API key.
+	 *
+	 * According to the Gemini API documentation, you can retrieve metadata for all uploaded caches
+	 * using the caches.list() method. This is useful for monitoring cache usage and cleanup.
+	 *
+	 * @param pageSize Optional number of caches to return per page (default: 10)
+	 * @returns A promise that resolves to an array of cache metadata objects
+	 */
+	public async listCaches(pageSize: number = 10): Promise<any[]> {
 		try {
-			const result = await this.client.models.generateContentStream({
-				model: modelId,
-				contents: contents,
+			const caches: any[] = []
+			const pager = await this.client.caches.list({ config: { pageSize } })
+
+			let page = pager.page
+			while (true) {
+				for (const cache of page) {
+					caches.push(cache)
+				}
+
+				if (!pager.hasNextPage()) {
+					break
+				}
+				page = await pager.nextPage()
+			}
+
+			return caches
+		} catch (error) {
+			console.error(`[GeminiHandler] Failed to list caches:`, error)
+			return []
+		}
+	}
+
+	/**
+	 * Updates the content of a cache for a specific task.
+	 *
+	 * Since the Gemini API doesn't support incremental updates to cache content,
+	 * this method:
+	 * 1. Creates a new cache with the full content (old + new)
+	 * 2. Deletes the old cache if it exists
+	 * 3. Updates our local tracking to point to the new cache
+	 *
+	 * @param taskId The ID of the task whose cache should be updated
+	 * @param model The model to use for the cache
+	 * @param contents The full content to cache (including both old and new messages)
+	 * @param systemInstruction The system instruction to include in the cache
+	 */
+	private async updateCacheContent(
+		taskId: string,
+		model: string,
+		contents: Content[],
+		systemInstruction: string,
+	): Promise<void> {
+		if (this.isCacheBusy) {
+			console.log(`[GeminiHandler] Cache is busy, skipping update for task ${taskId}`)
+			return
+		}
+
+		this.isCacheBusy = true
+		const timestamp = Date.now()
+		const existingCacheName = this.taskCacheNames.get(taskId)
+
+		try {
+			// 1. Create a new cache with the full content
+			const result = await this.client.caches.create({
+				model,
 				config: {
-					...requestConfig,
+					contents,
+					systemInstruction,
+					ttl: `${DEFAULT_CACHE_TTL_SECONDS}s`,
+					httpOptions: { timeout: 120_000 },
 				},
 			})

-			let isFirstSdkChunk = true
-			for await (const chunk of result) {
-				if (isFirstSdkChunk) {
-					sdkFirstChunkTime = Date.now()
-					ttftSdkMs = sdkFirstChunkTime - sdkCallStartTime
-					isFirstSdkChunk = false
+			const { name, usageMetadata } = result
+
+			if (name) {
+				// 2. Delete the old cache if it exists (non-blocking)
+				// We don't await this operation to avoid blocking the main flow if deletion fails
+				if (existingCacheName) {
+					// Schedule cache deletion in the background
+					setTimeout(() => {
+						this.client.caches
+							.delete({ name: existingCacheName })
+							.then(() => {
+								console.log(`[GeminiHandler] Deleted old cache ${existingCacheName} for task ${taskId}`)
+							})
+							.catch((error) => {
+								console.error(`[GeminiHandler] Failed to delete old cache ${existingCacheName}:`, error)
+								console.log(`[GeminiHandler] Continuing without deleting old cache. It will expire after TTL.`)
+							})
+					}, 1000)
 				}

-				if (chunk.text) {
-					yield {
-						type: "text",
-						text: chunk.text,
-					}
-				}
-
-				if (chunk.usageMetadata) {
-					lastUsageMetadata = chunk.usageMetadata
-					promptTokens = lastUsageMetadata.promptTokenCount ?? promptTokens
-					outputTokens = lastUsageMetadata.candidatesTokenCount ?? outputTokens
-					cacheReadTokens = lastUsageMetadata.cachedContentTokenCount ?? cacheReadTokens
-				}
-			}
-			apiSuccess = true
-
-			if (lastUsageMetadata) {
-				const totalCost = this.calculateCost({
-					info,
-					inputTokens: promptTokens,
-					outputTokens,
-					cacheReadTokens,
+				// 3. Update our local tracking
+				this.contentCaches.set<{ key: string; count: number }>(taskId, {
+					key: name,
+					count: contents.length,
 				})
-				yield {
-					type: "usage",
-					inputTokens: promptTokens,
-					outputTokens,
-					cacheReadTokens,
-					cacheWriteTokens: 0,
-					totalCost,
-				}
-			}
-		} catch (error) {
-			apiSuccess = false
-			// Let the error propagate to be handled by withRetry or Task.ts
-			// Telemetry will be sent in the finally block.
-			if (error instanceof Error) {
-				apiError = error.message
+				this.taskCacheNames.set(taskId, name)

-				// Gemini doesn't include status codes in their errors
-				// https://github.com/googleapis/js-genai/blob/61f7f27b866c74333ca6331883882489bcb708b9/src/_api_client.ts#L569
-				if (error.name === "ClientError" && error.message.includes("got status: 429 Too Many Requests.")) {
-					;(error as any).status = 429
-				}
-			} else {
-				apiError = String(error)
-			}
+				// Track total tokens in cache for ongoing cost calculation
+				const totalTokens = usageMetadata?.totalTokenCount ?? 0
+				this.taskCacheTokens.set(taskId, totalTokens)

-			throw error
-		} finally {
-			const sdkCallEndTime = Date.now()
-			const totalDurationSdkMs = sdkCallEndTime - sdkCallStartTime
-			const cacheHit = cacheReadTokens > 0
-			const cacheHitPercentage = promptTokens > 0 ? (cacheReadTokens / promptTokens) * 100 : undefined
-			const throughputTokensPerSecSdk =
-				totalDurationSdkMs > 0 && outputTokens > 0 ? outputTokens / (totalDurationSdkMs / 1000) : undefined
-
-			if (this.options.taskId) {
-				telemetryService.captureGeminiApiPerformance(
-					this.options.taskId,
-					modelId,
-					{
-						ttftSec: ttftSdkMs !== undefined ? ttftSdkMs / 1000 : undefined,
-						totalDurationSec: totalDurationSdkMs / 1000,
-						promptTokens,
-						outputTokens,
-						cacheReadTokens,
-						cacheHit,
-						cacheHitPercentage,
-						apiSuccess,
-						apiError,
-						throughputTokensPerSec: throughputTokensPerSecSdk,
-					},
-					true,
+				const operation = existingCacheName ? "Updated" : "Created new"
+				console.log(
+					`[GeminiHandler] ${operation} cache for task ${taskId}: ${contents.length} messages (${totalTokens} tokens) in ${Date.now() - timestamp}ms`,
 				)
-			} else {
-				console.warn("GeminiHandler: taskId not available for telemetry in createMessage.")
+
+				return // Indicate that a cache write occurred
 			}
+
+			return
+		} catch (error) {
+			console.error(`[GeminiHandler] Failed to update cache for task ${taskId}:`, error)
+			return
+		} finally {
+			this.isCacheBusy = false
 		}
 	}

+	/**
+	 * Updates the TTL of an existing cache.
+	 *
+	 * According to the Gemini API documentation, you can update the TTL of a cache
+	 * using the caches.update() method. This is useful for extending the lifetime
+	 * of a cache that's still being used.
+	 *
+	 * @param taskId The ID of the task whose cache TTL should be updated
+	 * @param ttlSeconds The new TTL in seconds
+	 * @returns A promise that resolves to the updated cache, or undefined if the update fails
+	 */
+	public async updateCacheTTL(taskId: string, ttlSeconds: number = DEFAULT_CACHE_TTL_SECONDS): Promise<any> {
+		const cacheName = this.taskCacheNames.get(taskId)
+		if (!cacheName) {
+			console.warn(`[GeminiHandler] No cache found for task ${taskId}, cannot update TTL`)
+			return
+		}
+
+		try {
+			const updatedCache = await this.client.caches.update({
+				name: cacheName,
+				config: { ttl: `${ttlSeconds}s` },
+			})
+
+			console.log(`[GeminiHandler] Updated TTL for cache ${cacheName} to ${ttlSeconds}s`)
+			return updatedCache
+		} catch (error) {
+			console.error(`[GeminiHandler] Failed to update TTL for cache ${cacheName}:`, error)
+		}
+	}
+
+	/**
+	 * Calculate the ongoing costs for a task based on cache storage.
+	 *
+	 * This method calculates the cost of holding tokens in cache for the TTL period.
+	 * These costs are separate from the immediate costs of API calls and should be
+	 * tracked at the task level rather than the message level.
+	 *
+	 * TODO: Surface these ongoing costs to the user in the UI, possibly in:
+	 * - The task header/summary
+	 * - A dedicated "costs" panel or tooltip
+	 * - As part of the total cost calculation for the task
+	 *
+	 * @param taskId The ID of the task to calculate ongoing costs for
+	 * @returns The ongoing cost in dollars, or undefined if no cache exists for the task
+	 */
+	public getTaskOngoingCosts(taskId: string): number | undefined {
+		const tokens = this.taskCacheTokens.get(taskId)
+		if (!tokens) {
+			return undefined
+		}
+
+		const { info } = this.getModel()
+		if (!info.cacheWritesPrice) {
+			return undefined
+		}
+
+		// Calculate the cost of holding tokens in cache for the TTL period
+		// (tokens / 1M) * (price per 1M tokens) * (cache TTL in hours)
+		return info.cacheWritesPrice * (tokens / 1_000_000) * (DEFAULT_CACHE_TTL_SECONDS / 3600)
+	}
+
 	/**
 	 * Calculate the immediate dollar cost of the API call based on token usage and model pricing.
 	 *
@@ -214,18 +430,21 @@ export class GeminiHandler implements ApiHandler {
 	 * - Input token costs (for uncached tokens)
 	 * - Output token costs
 	 * - Cache read costs
-	 * - Gemini implicit caching has no write costs
 	 *
+	 * It does NOT include ongoing costs like cache storage, which are tracked separately
+	 * at the task level through getTaskOngoingCosts().
 	 */
 	public calculateCost({
 		info,
 		inputTokens,
 		outputTokens,
+		cacheWriteTokens = 0,
 		cacheReadTokens = 0,
 	}: {
 		info: ModelInfo
 		inputTokens: number
 		outputTokens: number
+		cacheWriteTokens?: number
 		cacheReadTokens?: number
 	}) {
 		// Exit early if any required pricing information is missing
@@ -235,7 +454,9 @@ export class GeminiHandler implements ApiHandler {

 		let inputPrice = info.inputPrice
 		let outputPrice = info.outputPrice
+		let cacheWritesPrice = info.cacheWritesPrice ?? 0
 		// Right now, we only show the immediate costs of caching and not the ongoing costs of storing the cache
+		cacheWritesPrice = 0
 		let cacheReadsPrice = info.cacheReadsPrice ?? 0

 		// If there's tiered pricing then adjust prices based on the input tokens used
@@ -244,6 +465,7 @@ export class GeminiHandler implements ApiHandler {
 			if (tier) {
 				inputPrice = tier.inputPrice ?? inputPrice
 				outputPrice = tier.outputPrice ?? outputPrice
+				cacheWritesPrice = tier.cacheWritesPrice ?? cacheWritesPrice
 				cacheReadsPrice = tier.cacheReadsPrice ?? cacheReadsPrice
 			}
 		}
@@ -280,6 +502,27 @@ export class GeminiHandler implements ApiHandler {
 		return totalCost
 	}

+	/**
+	 * Calculate the total length of all messages for cache eligibility check
+	 */
+	private getMessagesLength(contents: Content[]): number {
+		return contents.reduce((total, content) => {
+			if (!content.parts) {
+				return total
+			}
+
+			return (
+				total +
+				content.parts.reduce((partTotal, part) => {
+					if (typeof part.text === "string") {
+						return partTotal + part.text.length
+					}
+					return partTotal
+				}, 0)
+			)
+		}, 0)
+	}
+
 	/**
 	 * Get the model ID and info for the current configuration
 	 */
@@ -65,7 +65,7 @@ export class LiteLlmHandler implements ApiHandler {
 		const reasoningOn = budgetTokens !== 0 ? true : false
 		const thinkingConfig = reasoningOn ? { type: "enabled", budget_tokens: budgetTokens } : undefined

-		let temperature: number | undefined = this.options.liteLlmModelInfo?.temperature ?? 0
+		let temperature: number | undefined = 0

 		if (isOminiModel && reasoningOn) {
 			temperature = undefined // Thinking mode doesn't support temperature
@@ -169,7 +169,7 @@ export class LiteLlmHandler implements ApiHandler {
 	getModel() {
 		return {
 			id: this.options.liteLlmModelId || liteLlmDefaultModelId,
-			info: this.options.liteLlmModelInfo || liteLlmModelInfoSaneDefaults,
+			info: liteLlmModelInfoSaneDefaults,
 		}
 	}
 }
@@ -66,9 +66,8 @@ export class OpenAiNativeHandler implements ApiHandler {
 					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 					stream: true,
 					stream_options: { include_usage: true },
-					reasoning_effort: (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium",
+					reasoning_effort: (this.options.o3MiniReasoningEffort as ChatCompletionReasoningEffort) || "medium",
 				})
-
 				for await (const chunk of stream) {
 					const delta = chunk.choices[0]?.delta
 					if (delta?.content) {
@@ -18,8 +18,7 @@ export class OpenAiHandler implements ApiHandler {
 		// Use azureApiVersion to determine if this is an Azure endpoint, since the URL may not always contain 'azure.com'
 		if (
 			this.options.azureApiVersion ||
-			((this.options.openAiBaseUrl?.toLowerCase().includes("azure.com") ||
-				this.options.openAiBaseUrl?.toLowerCase().includes("azure.us")) &&
+			(this.options.openAiBaseUrl?.toLowerCase().includes("azure.com") &&
 				!this.options.openAiModelId?.toLowerCase().includes("deepseek"))
 		) {
 			this.client = new AzureOpenAI({
@@ -65,7 +64,7 @@ export class OpenAiHandler implements ApiHandler {
 		if (isReasoningModelFamily) {
 			openAiMessages = [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)]
 			temperature = undefined // does not support temperature
-			reasoningEffort = (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium"
+			reasoningEffort = (this.options.o3MiniReasoningEffort as ChatCompletionReasoningEffort) || "medium"
 		}

 		const stream = await this.client.chat.completions.create({
@@ -35,7 +35,7 @@ export class OpenRouterHandler implements ApiHandler {
 			systemPrompt,
 			messages,
 			this.getModel(),
-			this.options.reasoningEffort,
+			this.options.o3MiniReasoningEffort,
 			this.options.thinkingBudgetTokens,
 			this.options.openRouterProviderSorting,
 		)
@@ -105,8 +105,9 @@ export class OpenRouterHandler implements ApiHandler {
 				// console.log("OpenRouter generation details:", generation)
 				return {
 					type: "usage",
+					// at this time there's no support for gatting cached_tokens from generation endpoint
 					cacheWriteTokens: 0,
-					cacheReadTokens: generation?.native_tokens_cached || 0,
+					cacheReadTokens: 0,
 					// openrouter generation endpoint fails often
 					inputTokens: generation?.native_tokens_prompt || 0,
 					outputTokens: generation?.native_tokens_completion || 0,
@@ -32,7 +32,7 @@ export class RequestyHandler implements ApiHandler {
 			...convertToOpenAiMessages(messages),
 		]

-		const reasoningEffort = this.options.reasoningEffort || "medium"
+		const reasoningEffort = this.options.o3MiniReasoningEffort || "medium"
 		const reasoning = { reasoning_effort: reasoningEffort }
 		const reasoningArgs = model.id.startsWith("openai/o") ? reasoning : {}

@@ -9,7 +9,7 @@ export async function createOpenRouterStream(
 	systemPrompt: string,
 	messages: Anthropic.Messages.MessageParam[],
 	model: { id: string; info: ModelInfo },
-	reasoningEffort?: string,
+	o3MiniReasoningEffort?: string,
 	thinkingBudgetTokens?: number,
 	openRouterProviderSorting?: string,
 ) {
@@ -21,7 +21,7 @@ export async function createOpenRouterStream(

 	// prompt caching: https://openrouter.ai/docs/prompt-caching
 	// this was initially specifically for claude models (some models may 'support prompt caching' automatically without this)
-	// handles direct model.id match logic
+	// includes custom support for gemini which does not have iterative caching
 	switch (model.id) {
 		case "anthropic/claude-3.7-sonnet":
 		case "anthropic/claude-3.7-sonnet:beta":
@@ -71,6 +71,75 @@ export async function createOpenRouterStream(
 				}
 			})
 			break
+		case "google/gemini-2.5-pro-preview-03-25":
+		case "google/gemini-2.0-flash-001":
+		case "google/gemini-flash-1.5":
+		case "google/gemini-pro-1.5":
+			// gemini only uses the last breakpoint for caching, so the others will be ignored
+			openAiMessages[0] = {
+				role: "system",
+				content: [
+					{
+						type: "text",
+						text: systemPrompt,
+						// @ts-ignore-next-line
+						cache_control: { type: "ephemeral" },
+					},
+				],
+			}
+
+			// for safety, but this should always be the case
+			if (openAiMessages.length >= 2) {
+				const msg = openAiMessages[1]
+
+				if (msg) {
+					if (typeof msg.content === "string") {
+						msg.content = [{ type: "text", text: msg.content }]
+					}
+					if (Array.isArray(msg.content)) {
+						// NOTE: this is fine since env details will always be added at the end. but if it weren't there, and the user added a image_url type message, it would pop a text part before it and then move it after to the end.
+						let lastTextPart = msg.content.filter((part) => part.type === "text").pop()
+
+						if (!lastTextPart) {
+							lastTextPart = { type: "text", text: "..." }
+							msg.content.push(lastTextPart)
+						}
+						// @ts-ignore-next-line
+						lastTextPart["cache_control"] = { type: "ephemeral" }
+					}
+				}
+			}
+
+			// it doesn't make sense to alter breakpoints at all with the gemini cache implementation at this time
+			/*const GEMINI_CACHE_USER_MESSAGE_INTERVAL = 4 // add new breakpoint every 4 turns
+			const userMessages = openAiMessages.filter((msg) => msg.role === "user")
+
+			const userMessageCount = userMessages.length
+			const targetUserMessageNumber =
+				Math.floor(userMessageCount / GEMINI_CACHE_USER_MESSAGE_INTERVAL) * GEMINI_CACHE_USER_MESSAGE_INTERVAL
+
+			if (targetUserMessageNumber > 0) {
+				// otherwise dont need to add a breakpoint
+				const msg = userMessages[targetUserMessageNumber - 1]
+
+				if (msg) {
+					if (typeof msg.content === "string") {
+						msg.content = [{ type: "text", text: msg.content }]
+					}
+					if (Array.isArray(msg.content)) {
+						// NOTE: this is fine since env details will always be added at the end. but if it weren't there, and the user added a image_url type message, it would pop a text part before it and then move it after to the end.
+						let lastTextPart = msg.content.filter((part) => part.type === "text").pop()
+
+						if (!lastTextPart) {
+							lastTextPart = { type: "text", text: "..." }
+							msg.content.push(lastTextPart)
+						}
+						// @ts-ignore-next-line
+						lastTextPart["cache_control"] = { type: "ephemeral" }
+					}
+				}
+			}*/
+			break
 		default:
 			break
 	}
@@ -144,7 +213,7 @@ export async function createOpenRouterStream(
 		stream_options: { include_usage: true },
 		transforms: shouldApplyMiddleOutTransform ? ["middle-out"] : undefined,
 		include_reasoning: true,
-		...(model.id.startsWith("openai/o") ? { reasoning_effort: reasoningEffort || "medium" } : {}),
+		...(model.id.startsWith("openai/o") ? { reasoning_effort: o3MiniReasoningEffort || "medium" } : {}),
 		...(reasoning ? { reasoning } : {}),
 		...(openRouterProviderSorting ? { provider: { sort: openRouterProviderSorting } } : {}),
 	})
@@ -1,6 +1,6 @@
 export type AssistantMessageContent = TextContent | ToolUse

-export { parseAssistantMessageV1, parseAssistantMessageV2 } from "./parse-assistant-message"
+export { parseAssistantMessage } from "./parse-assistant-message"

 export interface TextContent {
 	type: "text"
@@ -25,7 +25,6 @@ export const toolUseNames = [
 	"attempt_completion",
 	"new_task",
 	"condense",
-	"report_bug",
 	"new_rule",
 ] as const

@@ -54,11 +53,6 @@ export const toolParamNames = [
 	"response",
 	"result",
 	"context",
-	"title",
-	"what_happened",
-	"steps_to_reproduce",
-	"api_request_output",
-	"additional_context",
 ] as const

 export type ToolParamName = (typeof toolParamNames)[number]
@@ -1,24 +1,6 @@
-import { AssistantMessageContent, TextContent, ToolUse, ToolParamName, toolParamNames, toolUseNames, ToolUseName } from "." // Assuming types are defined in index.ts or a similar file
+import { AssistantMessageContent, TextContent, ToolUse, ToolParamName, toolParamNames, toolUseNames, ToolUseName } from "."

-/**
- * @description **Version 1**
- * Parses an assistant message string potentially containing mixed text and tool usage blocks
- * marked with XML-like tags into an array of structured content objects.
- *
- * This version iterates through the message character by character, building an accumulator string.
- * It maintains state to track whether it's currently parsing text, a tool use block, or a specific tool parameter.
- * It detects the start and end of tool uses and parameters by checking if the accumulator ends with
- * the corresponding opening or closing tags.
- * Special handling is included for `write_to_file` and `new_rule` tool uses to correctly parse
- * the `content` parameter, which might contain the closing tag itself, by looking for the *last*
- * occurrence of the closing tag.
- * If the input string ends mid-tag or mid-content, the last block (text or tool use) is marked as partial.
- *
- * @param assistantMessage The raw string output from the assistant.
- * @returns An array of `AssistantMessageContent` objects, which can be `TextContent` or `ToolUse`.
- *          Blocks that were not fully closed by the end of the input string will have their `partial` flag set to `true`.
- */
-export function parseAssistantMessageV1(assistantMessage: string): AssistantMessageContent[] {
+export function parseAssistantMessage(assistantMessage: string) {
 	const contentBlocks: AssistantMessageContent[] = []
 	let currentTextContent: TextContent | undefined = undefined
 	let currentTextContentStartIndex = 0
@@ -32,56 +14,46 @@ export function parseAssistantMessageV1(assistantMessage: string): AssistantMess
 		const char = assistantMessage[i]
 		accumulator += char

-		// --- State: Parsing a Tool Parameter ---
 		// there should not be a param without a tool use
 		if (currentToolUse && currentParamName) {
 			const currentParamValue = accumulator.slice(currentParamValueStartIndex)
 			const paramClosingTag = `</${currentParamName}>`
 			if (currentParamValue.endsWith(paramClosingTag)) {
-				// End of param value found
+				// end of param value
 				currentToolUse.params[currentParamName] = currentParamValue.slice(0, -paramClosingTag.length).trim()
-				currentParamName = undefined // Go back to parsing tool content or looking for next param
-				continue // Move to next character
+				currentParamName = undefined
+				continue
 			} else {
-				// Partial param value is accumulating
-				continue // Move to next character
+				// partial param value is accumulating
+				continue
 			}
 		}

-		// --- State: Parsing a Tool Use (but not a specific parameter) ---
 		// no currentParamName
+
 		if (currentToolUse) {
 			const currentToolValue = accumulator.slice(currentToolUseStartIndex)
 			const toolUseClosingTag = `</${currentToolUse.name}>`
-
 			if (currentToolValue.endsWith(toolUseClosingTag)) {
-				// End of a tool use found
+				// end of a tool use
 				currentToolUse.partial = false
 				contentBlocks.push(currentToolUse)
-				currentToolUse = undefined // Go back to parsing text or looking for next tool
-				// Reset text start index in case text follows immediately
-				currentTextContentStartIndex = i + 1
-				continue // Move to next character
+				currentToolUse = undefined
+				continue
 			} else {
-				// Check if starting a new parameter within the current tool use
 				const possibleParamOpeningTags = toolParamNames.map((name) => `<${name}>`)
-				let foundParamStart = false
 				for (const paramOpeningTag of possibleParamOpeningTags) {
 					if (accumulator.endsWith(paramOpeningTag)) {
-						// Start of a new parameter found
+						// start of a new parameter
 						currentParamName = paramOpeningTag.slice(1, -1) as ToolParamName
 						currentParamValueStartIndex = accumulator.length
-						foundParamStart = true
 						break
 					}
 				}
-				if (foundParamStart) {
-					continue // Move to next character
-				}

-				// Special case for write_to_file/new_rule content param allowing nested tags
-				// Check if a </content> tag appears, potentially indicating the end of the content param
-				// even if the main tool closing tag hasn't been seen yet.
+				// there's no current param, and not starting a new param
+
+				// special case for write_to_file where file contents could contain the closing tag, in which case the param would have closed and we end up with the rest of the file contents here. To work around this, we get the string between the starting content tag and the LAST content tag.
 				const contentParamName: ToolParamName = "content"
 				if (
 					(currentToolUse.name === "write_to_file" || currentToolUse.name === "new_rule") &&
@@ -91,384 +63,73 @@ export function parseAssistantMessageV1(assistantMessage: string): AssistantMess
 					const contentStartTag = `<${contentParamName}>`
 					const contentEndTag = `</${contentParamName}>`
 					const contentStartIndex = toolContent.indexOf(contentStartTag) + contentStartTag.length
-					// Use lastIndexOf to handle cases where </content> might appear within the content itself
 					const contentEndIndex = toolContent.lastIndexOf(contentEndTag)
-
-					// Ensure we found valid start/end tags and end is after start
-					if (
-						contentStartIndex !== -1 &&
-						contentEndIndex !== -1 &&
-						contentEndIndex > contentStartIndex - contentStartTag.length // Ensure end tag is after start tag begins
-					) {
-						// Check if this content param was already being parsed. If so, update it.
-						// If not, and we just found the closing tag, assign it.
-						// This handles cases where the </content> detection might fire before
-						// the <content> tag detection logic, or if the content is very short.
-						if (currentParamName === contentParamName) {
-							// Already parsing content, now we found the end tag
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							currentParamName = undefined // Finished with this param
-						} else if (currentParamName === undefined) {
-							// Not parsing a param, but found </content>. Assume it closes the content block.
-							currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
-							// We stay in the "parsing tool use" state, looking for more params or the tool end tag.
-						}
+					if (contentStartIndex !== -1 && contentEndIndex !== -1 && contentEndIndex > contentStartIndex) {
+						currentToolUse.params[contentParamName] = toolContent.slice(contentStartIndex, contentEndIndex).trim()
 					}
 				}

-				// If none of the above, partial tool value is accumulating
-				continue // Move to next character
+				// partial tool value is accumulating
+				continue
 			}
 		}

-		// --- State: Parsing Text (or looking for start of a tool use) ---
 		// no currentToolUse
+
 		let didStartToolUse = false
 		const possibleToolUseOpeningTags = toolUseNames.map((name) => `<${name}>`)
 		for (const toolUseOpeningTag of possibleToolUseOpeningTags) {
 			if (accumulator.endsWith(toolUseOpeningTag)) {
-				// Start of a new tool use found
-				const toolName = toolUseOpeningTag.slice(1, -1) as ToolUseName
+				// start of a new tool use
 				currentToolUse = {
 					type: "tool_use",
-					name: toolName,
+					name: toolUseOpeningTag.slice(1, -1) as ToolUseName,
 					params: {},
 					partial: true,
 				}
 				currentToolUseStartIndex = accumulator.length
-
-				// This also indicates the end of the current text content block (if any)
+				// this also indicates the end of the current text content
 				if (currentTextContent) {
 					currentTextContent.partial = false
-					// Extract text content, removing the part that formed the tool opening tag
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					currentTextContent.content = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					// Only add if there's actual content
-					if (currentTextContent.content.length > 0) {
-						contentBlocks.push(currentTextContent)
-					}
+					// remove the partially accumulated tool use tag from the end of text (<tool)
+					currentTextContent.content = currentTextContent.content
+						.slice(0, -toolUseOpeningTag.slice(0, -1).length)
+						.trim()
+					contentBlocks.push(currentTextContent)
 					currentTextContent = undefined
-				} else {
-					// Check if there was text before this tool use started
-					const textEndIndex = accumulator.length - toolUseOpeningTag.length
-					const potentialText = accumulator.slice(currentTextContentStartIndex, textEndIndex).trim()
-					if (potentialText.length > 0) {
-						contentBlocks.push({
-							type: "text",
-							content: potentialText,
-							partial: false, // Ended because tool use started
-						})
-					}
 				}

 				didStartToolUse = true
-				break // Found tool start, stop checking for others
+				break
 			}
 		}

 		if (!didStartToolUse) {
-			// No tool use started, so it must be text content accumulating
-			// (or continuing after a closed tool use)
+			// no tool use, so it must be text either at the beginning or between tools
 			if (currentTextContent === undefined) {
-				// Start of a new text block
-				currentTextContentStartIndex = i - (accumulator.length - currentTextContentStartIndex - 1) // Adjust start index based on how much we've accumulated since the last block ended or the beginning
-				// If accumulator starts from 0, start index is i
-				if (contentBlocks.length === 0 && currentToolUse === undefined) {
-					currentTextContentStartIndex = accumulator.length - 1 // i
-				} else {
-					// Re-calculate based on the actual start of the current text segment
-					// Find the end of the last block
-					let lastBlockEndIndex = 0
-					if (contentBlocks.length > 0) {
-						const lastBlock = contentBlocks[contentBlocks.length - 1]
-						// Approximation: find where the accumulator matches the end of the message string representation of the last block. This is complex.
-						// Simpler: Assume text starts right after the last block ended implicitly at index i.
-						lastBlockEndIndex = i // Where the loop *was* when the last block finished processing
-						// Need a more robust way to track the end index of the *raw string* corresponding to the last block.
-						// Let's stick to the accumulator slice approach for simplicity in this version.
-						// The start index should be where the current *unmatched* text began.
-						let lastProcessedIndex = -1
-						if (contentBlocks.length > 0) {
-							// This requires knowing the raw string length of the previous block, which V1 doesn't explicitly track easily.
-							// We'll approximate based on the current accumulator and start index logic.
-							// The issue arises if a tool tag was just closed. accumulator contains everything up to i.
-							// lastBlockEndIndex should point to the character *after* the closing tag of the last block.
-						}
-						// Reset start index to the beginning of the *current* potential text block
-						currentTextContentStartIndex = accumulator.length - 1 // Start accumulating from the current character `i`
-					}
-
-					// If we just closed a tool, text starts *after* its closing tag
-					// The logic needs refinement here for accurate start index after a tool closure.
-					// Let's assume for now the start index logic inside the loop handles it via slicing.
-				}
-
-				currentTextContent = {
-					type: "text",
-					content: "", // Content will be filled by slicing accumulator
-					partial: true,
-				}
+				currentTextContentStartIndex = i
+			}
+			currentTextContent = {
+				type: "text",
+				content: accumulator.slice(currentTextContentStartIndex).trim(),
+				partial: true,
 			}
-			// Update text content based on the accumulator from its start index
-			currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trimStart() // Trim start to avoid leading space if text follows tool
 		}
-	} // End of loop
+	}

-	// --- Finalization after loop ---
-
-	// If a tool use was open at the end
 	if (currentToolUse) {
-		// If a parameter was open within that tool use
+		// stream did not complete tool call, add it as partial
 		if (currentParamName) {
-			// The remaining accumulator content belongs to this partial parameter
+			// tool call has a parameter that was not completed
 			currentToolUse.params[currentParamName] = accumulator.slice(currentParamValueStartIndex).trim()
 		}
-		// Add the potentially partial tool use block
 		contentBlocks.push(currentToolUse)
 	}
-	// If text content was being accumulated at the end
-	// Note: Only one of currentToolUse or currentTextContent can be defined here,
-	// as starting a tool use finalizes the preceding text block.
-	else if (currentTextContent) {
-		// Update content one last time
-		currentTextContent.content = accumulator.slice(currentTextContentStartIndex).trim()
-		// Add the potentially partial text block only if it contains content
-		if (currentTextContent.content.length > 0) {
-			contentBlocks.push(currentTextContent)
-		}
-	}

-	return contentBlocks
-}
-
-/**
- * @description **Version 2**
- * Parses an assistant message string potentially containing mixed text and tool usage blocks
- * marked with XML-like tags into an array of structured content objects.
- *
- * This version aims for efficiency by avoiding the character-by-character accumulator of V1.
- * It iterates through the string using an index `i`. At each position, it checks if the substring
- * *ending* at `i` matches any known opening or closing tags for tools or parameters using `startsWith`
- * with an offset.
- * It uses pre-computed Maps (`toolUseOpenTags`, `toolParamOpenTags`) for quick tag lookups.
- * State is managed using indices (`currentTextContentStart`, `currentToolUseStart`, `currentParamValueStart`)
- * pointing to the start of the current block within the original `assistantMessage` string.
- * Slicing is used to extract content only when a block (text, parameter, or tool use) is completed.
- * Special handling for `write_to_file` and `new_rule` content parameters is included, using `indexOf`
- * and `lastIndexOf` on the relevant slice to handle potentially nested closing tags.
- * If the input string ends mid-block, the last open block is added and marked as partial.
- *
- * @param assistantMessage The raw string output from the assistant.
- * @returns An array of `AssistantMessageContent` objects, which can be `TextContent` or `ToolUse`.
- *          Blocks that were not fully closed by the end of the input string will have their `partial` flag set to `true`.
- */
-export function parseAssistantMessageV2(assistantMessage: string): AssistantMessageContent[] {
-	const contentBlocks: AssistantMessageContent[] = []
-	let currentTextContentStart = 0 // Index where the current text block started
-	let currentTextContent: TextContent | undefined = undefined
-	let currentToolUseStart = 0 // Index *after* the opening tag of the current tool use
-	let currentToolUse: ToolUse | undefined = undefined
-	let currentParamValueStart = 0 // Index *after* the opening tag of the current param
-	let currentParamName: ToolParamName | undefined = undefined
-
-	// Precompute tags for faster lookups
-	const toolUseOpenTags = new Map<string, ToolUseName>()
-	const toolParamOpenTags = new Map<string, ToolParamName>()
-	for (const name of toolUseNames) {
-		toolUseOpenTags.set(`<${name}>`, name)
-	}
-	for (const name of toolParamNames) {
-		toolParamOpenTags.set(`<${name}>`, name)
-	}
-
-	const len = assistantMessage.length
-	for (let i = 0; i < len; i++) {
-		const currentCharIndex = i
-
-		// --- State: Parsing a Tool Parameter ---
-		if (currentToolUse && currentParamName) {
-			const closeTag = `</${currentParamName}>`
-			// Check if the string *ending* at index `i` matches the closing tag
-			if (
-				currentCharIndex >= closeTag.length - 1 &&
-				assistantMessage.startsWith(
-					closeTag,
-					currentCharIndex - closeTag.length + 1, // Start checking from potential start of tag
-				)
-			) {
-				// Found the closing tag for the parameter
-				const value = assistantMessage
-					.slice(
-						currentParamValueStart, // Start after the opening tag
-						currentCharIndex - closeTag.length + 1, // End before the closing tag
-					)
-					.trim()
-				currentToolUse.params[currentParamName] = value
-				currentParamName = undefined // Go back to parsing tool content
-				// We don't continue loop here, need to check for tool close or other params at index i
-			} else {
-				continue // Still inside param value, move to next char
-			}
-		}
-
-		// --- State: Parsing a Tool Use (but not a specific parameter) ---
-		if (currentToolUse && !currentParamName) {
-			// Ensure we are not inside a parameter already
-			// Check if starting a new parameter
-			let startedNewParam = false
-			for (const [tag, paramName] of toolParamOpenTags.entries()) {
-				if (currentCharIndex >= tag.length - 1 && assistantMessage.startsWith(tag, currentCharIndex - tag.length + 1)) {
-					currentParamName = paramName
-					currentParamValueStart = currentCharIndex + 1 // Value starts after the tag
-					startedNewParam = true
-					break
-				}
-			}
-			if (startedNewParam) {
-				continue // Handled start of param, move to next char
-			}
-
-			// Check if closing the current tool use
-			const toolCloseTag = `</${currentToolUse.name}>`
-			if (
-				currentCharIndex >= toolCloseTag.length - 1 &&
-				assistantMessage.startsWith(toolCloseTag, currentCharIndex - toolCloseTag.length + 1)
-			) {
-				// End of the tool use found
-				// Special handling for content params *before* finalizing the tool
-				const toolContentSlice = assistantMessage.slice(
-					currentToolUseStart, // From after the tool opening tag
-					currentCharIndex - toolCloseTag.length + 1, // To before the tool closing tag
-				)
-
-				// Check if content parameter needs special handling (write_to_file/new_rule)
-				// This check is important if the closing </content> tag was missed by the parameter parsing logic
-				// (e.g., if content is empty or parsing logic prioritizes tool close)
-				const contentParamName: ToolParamName = "content"
-				if (
-					currentToolUse.name === "write_to_file" /* || currentToolUse.name === "new_rule" */ &&
-					toolContentSlice.includes(`<${contentParamName}>`)
-				) {
-					const contentStartTag = `<${contentParamName}>`
-					const contentEndTag = `</${contentParamName}>`
-					const contentStart = toolContentSlice.indexOf(contentStartTag)
-					// Use lastIndexOf for robustness against nested tags
-					const contentEnd = toolContentSlice.lastIndexOf(contentEndTag)
-
-					if (contentStart !== -1 && contentEnd !== -1 && contentEnd > contentStart) {
-						const contentValue = toolContentSlice.slice(contentStart + contentStartTag.length, contentEnd).trim()
-						currentToolUse.params[contentParamName] = contentValue
-					}
-				}
-
-				currentToolUse.partial = false // Mark as complete
-				contentBlocks.push(currentToolUse)
-				currentToolUse = undefined // Reset state
-				currentTextContentStart = currentCharIndex + 1 // Potential text starts after this tag
-				continue // Move to next char
-			}
-			// If not starting a param and not closing the tool, continue accumulating tool content implicitly
-			continue
-		}
-
-		// --- State: Parsing Text / Looking for Tool Start ---
-		if (!currentToolUse) {
-			// Check if starting a new tool use
-			let startedNewTool = false
-			for (const [tag, toolName] of toolUseOpenTags.entries()) {
-				if (currentCharIndex >= tag.length - 1 && assistantMessage.startsWith(tag, currentCharIndex - tag.length + 1)) {
-					// End current text block if one was active
-					if (currentTextContent) {
-						currentTextContent.content = assistantMessage
-							.slice(
-								currentTextContentStart, // From where text started
-								currentCharIndex - tag.length + 1, // To before the tool tag starts
-							)
-							.trim()
-						currentTextContent.partial = false // Ended because tool started
-						if (currentTextContent.content.length > 0) {
-							contentBlocks.push(currentTextContent)
-						}
-						currentTextContent = undefined
-					} else {
-						// Check for any text between the last block and this tag
-						const potentialText = assistantMessage
-							.slice(
-								currentTextContentStart, // From where text *might* have started
-								currentCharIndex - tag.length + 1, // To before the tool tag starts
-							)
-							.trim()
-						if (potentialText.length > 0) {
-							contentBlocks.push({
-								type: "text",
-								content: potentialText,
-								partial: false,
-							})
-						}
-					}
-
-					// Start the new tool use
-					currentToolUse = {
-						type: "tool_use",
-						name: toolName,
-						params: {},
-						partial: true, // Assume partial until closing tag is found
-					}
-					currentToolUseStart = currentCharIndex + 1 // Tool content starts after the opening tag
-					startedNewTool = true
-					break
-				}
-			}
-
-			if (startedNewTool) {
-				continue // Handled start of tool, move to next char
-			}
-
-			// If not starting a tool, it must be text content
-			if (!currentTextContent) {
-				// Start a new text block if we aren't already in one
-				currentTextContentStart = currentCharIndex // Text starts at the current character
-				// Check if the current char is the start of potential text *immediately* after a tag
-				// This needs the previous state - simpler to let slicing handle it later.
-				// Resetting start index accurately is key.
-				// It should be the index *after* the last processed tag.
-				// The logic managing currentTextContentStart after closing tags handles this.
-
-				currentTextContent = {
-					type: "text",
-					content: "", // Will be determined by slicing at the end or when a tool starts
-					partial: true,
-				}
-			}
-			// Continue accumulating text implicitly; content is extracted later.
-		}
-	} // End of loop
-
-	// --- Finalization after loop ---
-
-	// Finalize any open parameter within an open tool use
-	if (currentToolUse && currentParamName) {
-		currentToolUse.params[currentParamName] = assistantMessage
-			.slice(currentParamValueStart) // From param start to end of string
-			.trim()
-		// Tool use remains partial
-	}
-
-	// Finalize any open tool use (which might contain the finalized partial param)
-	if (currentToolUse) {
-		// Tool use is partial because the loop finished before its closing tag
-		contentBlocks.push(currentToolUse)
-	}
-	// Finalize any trailing text content
-	// Only possible if a tool use wasn't open at the very end
-	else if (currentTextContent) {
-		currentTextContent.content = assistantMessage
-			.slice(currentTextContentStart) // From text start to end of string
-			.trim()
-		// Text is partial because the loop finished
-		if (currentTextContent.content.length > 0) {
-			contentBlocks.push(currentTextContent)
-		}
+	// Note: it doesn't matter if check for currentToolUse or currentTextContent, only one of them will be defined since only one can be partial at a time
+	if (currentTextContent) {
+		// stream did not complete text content, add it as partial
+		contentBlocks.push(currentTextContent)
 	}

 	return contentBlocks
@@ -8,6 +8,45 @@ import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceSt
 import * as vscode from "vscode"
 import { synchronizeRuleToggles, getRuleFilesTotalContent } from "@core/context/instructions/user-instructions/rule-helpers"

+/**
+ * Converts .clinerules file to directory and places old .clinerule file inside directory, renaming it
+ * Doesn't do anything if .clinerules dir already exists or doesn't exist
+ * Returns whether there are any uncaught errors
+ */
+export async function ensureLocalClinerulesDirExists(cwd: string): Promise<boolean> {
+	const clinerulePath = path.resolve(cwd, GlobalFileNames.clineRules)
+	const defaultRuleFilename = "default-rules.md"
+
+	try {
+		const exists = await fileExistsAtPath(clinerulePath)
+
+		if (exists && !(await isDirectory(clinerulePath))) {
+			// logic to convert .clinerules file into directory, and rename the rules file to {defaultRuleFilename}
+			const content = await fs.readFile(clinerulePath, "utf8")
+			const tempPath = clinerulePath + ".bak"
+			await fs.rename(clinerulePath, tempPath) // create backup
+			try {
+				await fs.mkdir(clinerulePath, { recursive: true })
+				await fs.writeFile(path.join(clinerulePath, defaultRuleFilename), content, "utf8")
+				await fs.unlink(tempPath).catch(() => {}) // delete backup
+
+				return false // conversion successful with no errors
+			} catch (conversionError) {
+				// attempt to restore backup on conversion failure
+				try {
+					await fs.rm(clinerulePath, { recursive: true, force: true }).catch(() => {})
+					await fs.rename(tempPath, clinerulePath) // restore backup
+				} catch (restoreError) {}
+				return true // in either case here we consider this an error
+			}
+		}
+		// exists and is a dir or doesn't exist, either of these cases we dont need to handle here
+		return false
+	} catch (error) {
+		return true
+	}
+}
+
 export const getGlobalClineRules = async (globalClineRulesFilePath: string, toggles: ClineRulesToggles) => {
 	if (await fileExistsAtPath(globalClineRulesFilePath)) {
 		if (await isDirectory(globalClineRulesFilePath)) {
@@ -41,8 +80,7 @@ export const getLocalClineRules = async (cwd: string, toggles: ClineRulesToggles
 	if (await fileExistsAtPath(clineRulesFilePath)) {
 		if (await isDirectory(clineRulesFilePath)) {
 			try {
-				const rulesFilePaths = await readDirectory(clineRulesFilePath, [[".clinerules", "workflows"]])
-
+				const rulesFilePaths = await readDirectory(clineRulesFilePath)
 				const rulesFilesTotalContent = await getRuleFilesTotalContent(rulesFilePaths, cwd, toggles)
 				if (rulesFilesTotalContent) {
 					clineRulesFileInstructions = formatResponse.clineRulesLocalDirectoryInstructions(cwd, rulesFilesTotalContent)
@@ -83,9 +121,7 @@ export async function refreshClineRulesToggles(
 	// Local toggles
 	const localClineRulesToggles = ((await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles) || {}
 	const localClineRulesFilePath = path.resolve(workingDirectory, GlobalFileNames.clineRules)
-	const updatedLocalToggles = await synchronizeRuleToggles(localClineRulesFilePath, localClineRulesToggles, "", [
-		[".clinerules", "workflows"],
-	])
+	const updatedLocalToggles = await synchronizeRuleToggles(localClineRulesFilePath, localClineRulesToggles)
 	await updateWorkspaceState(context, "localClineRulesToggles", updatedLocalToggles)

 	return {
@@ -93,3 +129,82 @@ export async function refreshClineRulesToggles(
 		localToggles: updatedLocalToggles,
 	}
 }
+
+export const createRuleFile = async (isGlobal: boolean, filename: string, cwd: string) => {
+	try {
+		let filePath: string
+		if (isGlobal) {
+			const globalClineRulesFilePath = await ensureRulesDirectoryExists()
+			filePath = path.join(globalClineRulesFilePath, filename)
+		} else {
+			const localClineRulesFilePath = path.resolve(cwd, GlobalFileNames.clineRules)
+
+			const hasError = await ensureLocalClinerulesDirExists(cwd)
+			if (hasError === true) {
+				return { filePath: null, fileExists: false }
+			}
+
+			await fs.mkdir(localClineRulesFilePath, { recursive: true })
+
+			filePath = path.join(localClineRulesFilePath, filename)
+		}
+
+		const fileExists = await fileExistsAtPath(filePath)
+
+		if (fileExists) {
+			return { filePath, fileExists }
+		}
+
+		await fs.writeFile(filePath, "", "utf8")
+
+		return { filePath, fileExists: false }
+	} catch (error) {
+		return { filePath: null, fileExists: false }
+	}
+}
+
+export async function deleteRuleFile(
+	context: vscode.ExtensionContext,
+	rulePath: string,
+	isGlobal: boolean,
+): Promise<{ success: boolean; message: string }> {
+	try {
+		// Check if file exists
+		const fileExists = await fileExistsAtPath(rulePath)
+		if (!fileExists) {
+			return {
+				success: false,
+				message: `Rule file does not exist: ${rulePath}`,
+			}
+		}
+
+		// Delete the file from disk
+		await fs.unlink(rulePath)
+
+		// Get the filename for messages
+		const fileName = path.basename(rulePath)
+
+		// Update the appropriate toggles
+		if (isGlobal) {
+			const toggles = ((await getGlobalState(context, "globalClineRulesToggles")) as ClineRulesToggles) || {}
+			delete toggles[rulePath]
+			await updateGlobalState(context, "globalClineRulesToggles", toggles)
+		} else {
+			const toggles = ((await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles) || {}
+			delete toggles[rulePath]
+			await updateWorkspaceState(context, "localClineRulesToggles", toggles)
+		}
+
+		return {
+			success: true,
+			message: `Rule file "${fileName}" deleted successfully`,
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		console.error(`Error deleting rule file: ${errorMessage}`, error)
+		return {
+			success: false,
+			message: `Failed to delete rule file.`,
+		}
+	}
+}
@@ -1,21 +1,14 @@
 import { fileExistsAtPath, isDirectory, readDirectory } from "@utils/fs"
-import { ensureRulesDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceState } from "@core/storage/state"
 import * as path from "path"
 import fs from "fs/promises"
 import { ClineRulesToggles } from "@shared/cline-rules"
-import * as vscode from "vscode"

 /**
 * Recursively traverses directory and finds all files, including checking for optional whitelisted file extension
 */
-export async function readDirectoryRecursive(
-	directoryPath: string,
-	allowedFileExtension: string,
-	excludedPaths: string[][] = [],
-): Promise<string[]> {
+export async function readDirectoryRecursive(directoryPath: string, allowedFileExtension: string): Promise<string[]> {
 	try {
-		const entries = await readDirectory(directoryPath, excludedPaths)
+		const entries = await readDirectory(directoryPath)
 		let results: string[] = []
 		for (const entry of entries) {
 			if (allowedFileExtension !== "") {
@@ -40,7 +33,6 @@ export async function synchronizeRuleToggles(
 	rulesDirectoryPath: string,
 	currentToggles: ClineRulesToggles,
 	allowedFileExtension: string = "",
-	excludedPaths: string[][] = [],
 ): Promise<ClineRulesToggles> {
 	// Create a copy of toggles to modify
 	const updatedToggles = { ...currentToggles }
@@ -53,7 +45,7 @@ export async function synchronizeRuleToggles(

 			if (isDir) {
 				// DIRECTORY CASE
-				const filePaths = await readDirectoryRecursive(rulesDirectoryPath, allowedFileExtension, excludedPaths)
+				const filePaths = await readDirectoryRecursive(rulesDirectoryPath, allowedFileExtension)
 				const existingRulePaths = new Set<string>()

 				for (const filePath of filePaths) {
@@ -127,155 +119,3 @@ export const getRuleFilesTotalContent = async (rulesFilePaths: string[], basePat
 	).then((contents) => contents.filter(Boolean).join("\n\n"))
 	return ruleFilesTotalContent
 }
-
-/**
- * Handles converting any directory into a file (specifically used for .clinerules and .clinerules/workflows)
- * The old .clinerules file or .clinerules/workflows file will be renamed to a default filename
- * Doesn't do anything if the dir already exists or doesn't exist
- * Returns whether there are any uncaught errors
- */
-export async function ensureLocalClineDirExists(clinerulePath: string, defaultRuleFilename: string): Promise<boolean> {
-	try {
-		const exists = await fileExistsAtPath(clinerulePath)
-
-		if (exists && !(await isDirectory(clinerulePath))) {
-			// logic to convert .clinerules file into directory, and rename the rules file to {defaultRuleFilename}
-			const content = await fs.readFile(clinerulePath, "utf8")
-			const tempPath = clinerulePath + ".bak"
-			await fs.rename(clinerulePath, tempPath) // create backup
-			try {
-				await fs.mkdir(clinerulePath, { recursive: true })
-				await fs.writeFile(path.join(clinerulePath, defaultRuleFilename), content, "utf8")
-				await fs.unlink(tempPath).catch(() => {}) // delete backup
-
-				return false // conversion successful with no errors
-			} catch (conversionError) {
-				// attempt to restore backup on conversion failure
-				try {
-					await fs.rm(clinerulePath, { recursive: true, force: true }).catch(() => {})
-					await fs.rename(tempPath, clinerulePath) // restore backup
-				} catch (restoreError) {}
-				return true // in either case here we consider this an error
-			}
-		}
-		// exists and is a dir or doesn't exist, either of these cases we dont need to handle here
-		return false
-	} catch (error) {
-		return true
-	}
-}
-
-/**
- * Create a rule file or workflow file
- */
-export const createRuleFile = async (isGlobal: boolean, filename: string, cwd: string, type: string) => {
-	try {
-		let filePath: string
-		if (isGlobal) {
-			// global means its implicitly clinerules
-			const globalClineRulesFilePath = await ensureRulesDirectoryExists()
-			filePath = path.join(globalClineRulesFilePath, filename)
-		} else {
-			const localClineRulesFilePath = path.resolve(cwd, GlobalFileNames.clineRules)
-
-			const hasError = await ensureLocalClineDirExists(localClineRulesFilePath, "default-rules.md")
-			if (hasError === true) {
-				return { filePath: null, fileExists: false }
-			}
-
-			await fs.mkdir(localClineRulesFilePath, { recursive: true })
-
-			if (type === "workflow") {
-				const localWorkflowsFilePath = path.resolve(cwd, GlobalFileNames.workflows)
-
-				const hasError = await ensureLocalClineDirExists(localWorkflowsFilePath, "default-workflows.md")
-				if (hasError === true) {
-					return { filePath: null, fileExists: false }
-				}
-
-				await fs.mkdir(localWorkflowsFilePath, { recursive: true })
-
-				filePath = path.join(localWorkflowsFilePath, filename)
-			} else {
-				// clinerules file creation
-				filePath = path.join(localClineRulesFilePath, filename)
-			}
-		}
-
-		const fileExists = await fileExistsAtPath(filePath)
-
-		if (fileExists) {
-			return { filePath, fileExists }
-		}
-
-		await fs.writeFile(filePath, "", "utf8")
-
-		return { filePath, fileExists: false }
-	} catch (error) {
-		return { filePath: null, fileExists: false }
-	}
-}
-
-/**
- * Delete a rule file or workflow file
- */
-export async function deleteRuleFile(
-	context: vscode.ExtensionContext,
-	rulePath: string,
-	isGlobal: boolean,
-	type: string,
-): Promise<{ success: boolean; message: string }> {
-	try {
-		// Check if file exists
-		const fileExists = await fileExistsAtPath(rulePath)
-		if (!fileExists) {
-			return {
-				success: false,
-				message: `File does not exist: ${rulePath}`,
-			}
-		}
-
-		// Delete the file from disk
-		await fs.unlink(rulePath)
-
-		// Get the filename for messages
-		const fileName = path.basename(rulePath)
-
-		// Update the appropriate toggles
-		if (isGlobal) {
-			const toggles = ((await getGlobalState(context, "globalClineRulesToggles")) as ClineRulesToggles) || {}
-			delete toggles[rulePath]
-			await updateGlobalState(context, "globalClineRulesToggles", toggles)
-		} else {
-			if (type === "workflow") {
-				const toggles = ((await getWorkspaceState(context, "workflowToggles")) as ClineRulesToggles) || {}
-				delete toggles[rulePath]
-				await updateWorkspaceState(context, "workflowToggles", toggles)
-			} else if (type === "cursor") {
-				const toggles = ((await getWorkspaceState(context, "localCursorRulesToggles")) as ClineRulesToggles) || {}
-				delete toggles[rulePath]
-				await updateWorkspaceState(context, "localCursorRulesToggles", toggles)
-			} else if (type === "windsurf") {
-				const toggles = ((await getWorkspaceState(context, "localWindsurfRulesToggles")) as ClineRulesToggles) || {}
-				delete toggles[rulePath]
-				await updateWorkspaceState(context, "localWindsurfRulesToggles", toggles)
-			} else {
-				const toggles = ((await getWorkspaceState(context, "localClineRulesToggles")) as ClineRulesToggles) || {}
-				delete toggles[rulePath]
-				await updateWorkspaceState(context, "localClineRulesToggles", toggles)
-			}
-		}
-
-		return {
-			success: true,
-			message: `File "${fileName}" deleted successfully`,
-		}
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error)
-		console.error(`Error deleting file: ${errorMessage}`, error)
-		return {
-			success: false,
-			message: `Failed to delete file.`,
-		}
-	}
-}
@@ -1,20 +0,0 @@
-import path from "path"
-import { GlobalFileNames } from "@core/storage/disk"
-import { ClineRulesToggles } from "@shared/cline-rules"
-import { getWorkspaceState, updateWorkspaceState } from "@core/storage/state"
-import * as vscode from "vscode"
-import { synchronizeRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
-
-/**
- * Refresh the workflow toggles
- */
-export async function refreshWorkflowToggles(
-	context: vscode.ExtensionContext,
-	workingDirectory: string,
-): Promise<ClineRulesToggles> {
-	const workflowRulesToggles = ((await getWorkspaceState(context, "workflowToggles")) as ClineRulesToggles) || {}
-	const workflowsDirPath = path.resolve(workingDirectory, GlobalFileNames.workflows)
-	const updatedWorkflowToggles = await synchronizeRuleToggles(workflowsDirPath, workflowRulesToggles)
-	await updateWorkspaceState(context, "workflowToggles", updatedWorkflowToggles)
-	return updatedWorkflowToggles
-}
@@ -2,7 +2,6 @@ import * as vscode from "vscode"
 import crypto from "crypto"
 import { Controller } from "../index"
 import { storeSecret } from "../../storage/state"
-import { EmptyRequest, String } from "../../../shared/proto/common"

 /**
 * Handles the user clicking the login link in the UI.
@@ -12,7 +11,7 @@ import { EmptyRequest, String } from "../../../shared/proto/common"
 * @param controller The controller instance.
 * @returns The login URL as a string.
 */
-export async function accountLoginClicked(controller: Controller, unused: EmptyRequest): Promise<String> {
+export async function accountLoginClicked(controller: Controller): Promise<String> {
 	// Generate nonce for state validation
 	const nonce = crypto.randomBytes(32).toString("hex")
 	await storeSecret(controller.context, "authNonce", nonce)
@@ -26,8 +25,6 @@ export async function accountLoginClicked(controller: Controller, unused: EmptyR
 	const authUrl = vscode.Uri.parse(
 		`https://app.cline.bot/auth?state=${encodeURIComponent(nonce)}&callback_url=${encodeURIComponent(`${uriScheme || "vscode"}://saoudrizwan.claude-dev/auth`)}`,
 	)
-	await vscode.env.openExternal(authUrl)
-	return {
-		value: authUrl.toString(),
-	}
+	vscode.env.openExternal(authUrl)
+	return authUrl.toString()
 }
@@ -1,22 +1,14 @@
-// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
+import { createServiceRegistry, ServiceMethodHandler } from "../grpc-service"
 import { registerAllMethods } from "./methods"

-// Create account service registry
 const accountService = createServiceRegistry("account")

-// Export the method handler types and registration function
+// Export the method handler type and registration function
 export type AccountMethodHandler = ServiceMethodHandler
-export type AccountStreamingMethodHandler = StreamingMethodHandler
 export const registerMethod = accountService.registerMethod

-// Export the request handlers
+// Export the request handler
 export const handleAccountServiceRequest = accountService.handleRequest
-export const handleAccountServiceStreamingRequest = accountService.handleStreamingRequest
-export const isStreamingMethod = accountService.isStreamingMethod

 // Register all account methods
 registerAllMethods()
@@ -1,22 +1,15 @@
-// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
+import { createServiceRegistry, ServiceMethodHandler } from "../grpc-service"
 import { registerAllMethods } from "./methods"

 // Create browser service registry
 const browserService = createServiceRegistry("browser")

-// Export the method handler types and registration function
+// Export the method handler type and registration function
 export type BrowserMethodHandler = ServiceMethodHandler
-export type BrowserStreamingMethodHandler = StreamingMethodHandler
 export const registerMethod = browserService.registerMethod

-// Export the request handlers
+// Export the request handler
 export const handleBrowserServiceRequest = browserService.handleRequest
-export const handleBrowserServiceStreamingRequest = browserService.handleStreamingRequest
-export const isStreamingMethod = browserService.isStreamingMethod

 // Register all browser methods
 registerAllMethods()
@@ -1,8 +1,8 @@
 import { UpdateBrowserSettingsRequest } from "../../../shared/proto/browser"
 import { Boolean } from "../../../shared/proto/common"
 import { Controller } from "../index"
-import { updateGlobalState, getGlobalState } from "../../storage/state"
-import { BrowserSettings as SharedBrowserSettings, DEFAULT_BROWSER_SETTINGS } from "../../../shared/BrowserSettings"
+import { updateGlobalState } from "../../storage/state"
+import { BrowserSettings as SharedBrowserSettings } from "../../../shared/BrowserSettings"

 /**
 * Update browser settings
@@ -12,39 +12,23 @@ import { BrowserSettings as SharedBrowserSettings, DEFAULT_BROWSER_SETTINGS } fr
 */
 export async function updateBrowserSettings(controller: Controller, request: UpdateBrowserSettingsRequest): Promise<Boolean> {
 	try {
-		// Get current browser settings to preserve fields not in the request
-		const currentSettings = (await getGlobalState(controller.context, "browserSettings")) as SharedBrowserSettings | undefined
-		const mergedWithDefaults = { ...DEFAULT_BROWSER_SETTINGS, ...currentSettings }
-
-		// Convert from protobuf format to shared format, merging with existing settings
-		const newBrowserSettings: SharedBrowserSettings = {
-			...mergedWithDefaults, // Start with existing settings (and defaults)
+		// Convert from protobuf format to shared format
+		const browserSettings: SharedBrowserSettings = {
 			viewport: {
-				// Apply updates from request
-				width: request.viewport?.width || mergedWithDefaults.viewport.width,
-				height: request.viewport?.height || mergedWithDefaults.viewport.height,
+				width: request.viewport?.width || 900,
+				height: request.viewport?.height || 600,
 			},
-			// Explicitly handle optional boolean and string fields from the request
-			remoteBrowserEnabled:
-				request.remoteBrowserEnabled === undefined
-					? mergedWithDefaults.remoteBrowserEnabled
-					: request.remoteBrowserEnabled,
-			remoteBrowserHost:
-				request.remoteBrowserHost === undefined ? mergedWithDefaults.remoteBrowserHost : request.remoteBrowserHost,
-			chromeExecutablePath:
-				// If chromeExecutablePath is explicitly in the request (even as ""), use it.
-				// Otherwise, fall back to mergedWithDefaults.
-				"chromeExecutablePath" in request ? request.chromeExecutablePath : mergedWithDefaults.chromeExecutablePath,
-			disableToolUse: request.disableToolUse === undefined ? mergedWithDefaults.disableToolUse : request.disableToolUse,
+			remoteBrowserEnabled: request.remoteBrowserEnabled || false,
+			remoteBrowserHost: request.remoteBrowserHost || undefined,
 		}

 		// Update global state with new settings
-		await updateGlobalState(controller.context, "browserSettings", newBrowserSettings)
+		await updateGlobalState(controller.context, "browserSettings", browserSettings)

 		// Update task browser settings if task exists
 		if (controller.task) {
-			controller.task.browserSettings = newBrowserSettings
-			controller.task.browserSession.browserSettings = newBrowserSettings
+			controller.task.browserSettings = browserSettings
+			controller.task.browserSession.browserSettings = browserSettings
 		}

 		// Post updated state to webview
@@ -1,22 +1,15 @@
-// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
-
-import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
-import { StreamingResponseHandler } from "../grpc-handler"
+import { createServiceRegistry, ServiceMethodHandler } from "../grpc-service"
 import { registerAllMethods } from "./methods"

 // Create checkpoints service registry
 const checkpointsService = createServiceRegistry("checkpoints")

-// Export the method handler types and registration function
+// Export the method handler type and registration function
 export type CheckpointsMethodHandler = ServiceMethodHandler
-export type CheckpointsStreamingMethodHandler = StreamingMethodHandler
 export const registerMethod = checkpointsService.registerMethod

-// Export the request handlers
+// Export the request handler
 export const handleCheckpointsServiceRequest = checkpointsService.handleRequest
-export const handleCheckpointsServiceStreamingRequest = checkpointsService.handleStreamingRequest
-export const isStreamingMethod = checkpointsService.isStreamingMethod

 // Register all checkpoints methods
 registerAllMethods()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Elephant Lumps	d9b804fb13	docs.json	2025-05-06 13:04:58 -05:00
Elephant Lumps	79b6a2aceb	changeset	2025-05-05 11:38:32 -05:00
Elephant Lumps	41c44362b9	migrate custom model config section	2025-05-05 11:38:03 -05:00