update env location

Co-authored-by: Bee <68532117+abeatrix@users.noreply.github.com>

.changeset/sweet-dingos-serve.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Improve the Claude Code error messages

.clinerules/protobuf-development.md

@@ -0,0 +1,89 @@
+# Cline Protobuf Development Guide
+
+This guide outlines how to add new gRPC endpoints for communication between the webview (frontend) and the extension host (backend).
+
+## Overview
+
+Cline uses [Protobuf](https://protobuf.dev/) to define a strongly-typed API, ensuring efficient and type-safe communication. All definitions are in the `/proto` directory. The compiler and plugins are included as project dependencies, so no manual installation is needed.
+
+## Key Concepts & Best Practices
+
+-   **File Structure**: Each feature domain should have its own `.proto` file (e.g., `account.proto`, `task.proto`).
+-   **Message Design**:
+    -   For simple, single-value data, use the shared types in `proto/common.proto` (e.g., `StringRequest`, `Empty`, `Int64Request`). This promotes consistency.
+    -   For complex data structures, define custom messages within the feature's `.proto` file (see `task.proto` for examples like `NewTaskRequest`).
+-   **Naming Conventions**:
+    -   Services: `PascalCaseService` (e.g., `AccountService`).
+    -   RPCs: `camelCase` (e.g., `accountEmailIdentified`).
+    -   Messages: `PascalCase` (e.g., `StringRequest`).
+-   **Streaming**: For server-to-client streaming, use the `stream` keyword on the response type. See `subscribeToAuthCallback` in `account.proto` for an example.
+
+---
+
+## 4-Step Development Workflow
+
+Here’s how to add a new RPC, using `scrollToSettings` as an example.
+
+### 1. Define the RPC in a `.proto` File
+
+Add your service method to the appropriate file in the `proto/` directory.
+
+**File: `proto/ui.proto`**
+```proto
+service UiService {
+  // ... other RPCs
+  // Scrolls to a specific settings section in the settings view
+  rpc scrollToSettings(StringRequest) returns (KeyValuePair);
+}
+```
+Here, we use the common `StringRequest` and `KeyValuePair` types.
+
+### 2. Compile Definitions
+
+After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
+```bash
+npm run protos
+```
+This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
+
+### 3. Implement the Backend Handler
+
+Create the RPC implementation in the backend. Handlers are located in `src/core/controller/[service-name]/`.
+
+**File: `src/core/controller/ui/scrollToSettings.ts`**
+```typescript
+import { Controller } from ".."
+import { StringRequest, KeyValuePair } from "../../../shared/proto/common"
+
+/**
+ * Executes a scroll to settings action
+ * @param controller The controller instance
+ * @param request The request containing the ID of the settings section to scroll to
+ * @returns KeyValuePair with action and value fields for the UI to process
+ */
+export async function scrollToSettings(controller: Controller, request: StringRequest): Promise<KeyValuePair> {
+	return KeyValuePair.create({
+		key: "scrollToSettings",
+		value: request.value || "",
+	})
+}
+```
+
+### 4. Call the RPC from the Webview
+
+Call the new RPC from a React component in `webview-ui/`. The generated client makes this simple.
+
+**File: `webview-ui/src/components/browser/BrowserSettingsMenu.tsx`** (Example)
+```tsx
+import { UiServiceClient } from "../../../services/grpc"
+import { StringRequest } from "../../../../shared/proto/common"
+
+// ... inside a React component
+const handleMenuClick = async () => {
+    try {
+        await UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))
+    } catch (error) {
+        console.error("Error scrolling to browser settings:", error)
+    }
+}
+```

.clinerules/workflows/git-branch-analysis.md

@@ -0,0 +1,75 @@
+# Git Diff Analysis Workflow
+
+## Objective
+Analyze the current branch's changes against main to provide informed insights and context for development decisions.
+
+## Step 1: Gather Git Information
+<important>Do not return any text or conversation other than what is necessary to run these commands</important>
+
+**First, check the expected output size:**
+   ```shell
+   (git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat) | wc -l
+   ```
+
+**If the expected line count is greater than 500 lines, use the file-based approach:**
+   ```shell
+   git branch --show-current > cline-git-analysis.temp && echo "=== STATUS ===" >> cline-git-analysis.temp && git status --porcelain >> cline-git-analysis.temp && echo "=== COMMIT MESSAGES ===" >> cline-git-analysis.temp && git log main..HEAD --oneline >> cline-git-analysis.temp && echo "=== CHANGED FILES ===" >> cline-git-analysis.temp && git diff main --name-only >> cline-git-analysis.temp && echo "=== FULL DIFF ===" >> cline-git-analysis.temp && git diff main >> cline-git-analysis.temp
+   ```
+
+   Then, read the file using the read_file tool. After you have read the file but before you proceed with subsequent steps, delete it:
+   ```shell
+   rm cline-git-analysis.temp
+   ```
+
+**If the expected line count is 500 lines or fewer, use the direct approach:**
+   ```shell
+   git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat
+   ```
+
+<important>If using the direct approach, pipe outputs through `cat` to avoid interactive terminals. If the user's shell is not bash/zsh, adjust the command and chaining
+ syntax accordingly.</important>
+
+## Step 2: Silent, Structured Analysis Phase
+- Analyze all git output without providing commentary or narration
+- Read the full diff to understand the scope and nature of changes
+- Identify patterns, architectural modifications, or potential impacts
+- Use `read_file` to examine any related files providing additional context on the changes you have observed
+
+## Step 3: Context Gathering
+- Analyze related code without providing commentary or narration
+- Read relevant related source files if needed for complete understanding
+- Check dependencies, imports, or cross-references spanning the changes
+- Understand the broader codebase context around modifications
+- This additional context gathering should include related backend code, as well as related ui/frontend code
+- You will typically need to analyze at least several files, potentially many, in order to fully complete this step
+- You should not continue reading additional context if you have exhausted more than 60% of your available context window
+- If you have exhausted less than 40% of your context window, you should continue reviewing additional context
+
+## Step 4: Ready for User Interaction
+**Only after completing the full analysis:**
+- Engage with the user based on comprehensive understanding
+- Provide insights about specific modifications and their impacts
+- If you are certain they exist, note potential breaking changes or compatibility issues
+- Answer questions with informed context from the complete change set and context gathering
+- If the user has not provided a question, or the question is insufficient to provide a quality response, ask brief (one sentence) clarifying questions.
+- Only offer recommendations if they are applicable to the user's request and relevant to the changes that you have observed 
+
+## Key Rules
+- **No prose or conversation during git research phase**
+- **No prose or conversation during context gathering phase**
+- **Complete all analysis before any user interaction**
+- **Use gathered information for all subsequent questions and insights**
+- **Focus on understanding the complete picture before discussing**
+
+## Optional: Additional Analysis Commands
+For deeper investigation when needed:
+
+```shell
+# Detailed commit history with author info
+git log main..HEAD --format="%h %s (%an)" | cat
+
+# Change statistics
+git diff main --stat | cat
+
+# Specific file type changes
+git diff main --name-only | grep -E '\.(ts|js|tsx|jsx|py|md)$' | cat

.clinerules/workflows/writing-documentation.md

@@ -0,0 +1,392 @@
+# General writing guide
+
+# How I want you to write 
+
+I'm gonna write something technical.
+
+It's often less about the nitty-gritty details of the tech stuff and more about learning something new or getting a solution handed to me on a silver platter.
+
+Look, when I read, I want something out of it. So when I write, I gotta remember that my readers want something too. This whole piece? It's about cluing in anyone who writes for me, or wants me to write for them, on how I see this whole writing product thing.
+
+I'm gonna lay out a checklist of stuff I'd like to have. It'll make the whole writing gig a bit smoother, you know?
+
+## Crafting Compelling Titles
+
+I often come across titles like "How to do X with Y,Z technology." These don't excite me because X or Y are usually unfamiliar unless they're already well-known. Its rarely the dream to use X unless X is the dream. 
+
+My dream isn’t to use instructor, its to do something valueble with the data it extracts
+
+An effective title should:
+
+- Evoke an emotional response
+- Highlight someone's goal
+- Offer a dream or aspiration
+- Challenge or comment on a belief
+- Address someone's problems
+
+I believe it's more impactful to write about specific problems. If this approach works, you can replicate it across various scenarios rather than staying too general.
+
+- Time management for everyone can be a 15$ ebook
+- Time management for executives is a 2000$ workshop
+
+Aim for titles that answer questions you think everyone is asking, or address thoughts people have but can't quite articulate.
+
+Instead of "How I do something" or "How to do something," frame it from the reader's perspective with "How you can do something." This makes the title more engaging. Just make sure the difference is advisory if the content is subjective. “How I made a million dollars” might be more reasonable than “How to make a million dollars” since you are the subject and the goal might be to share your story in hopes of helping others.
+
+This approach ultimately trains the reader to have a stronger emotional connection to your content.
+
+- "How I do X"
+- "How You Can do X"
+
+Between these two titles, it's obvious which one resonates more emotionally.
+
+You can take it further by adding specific conditions. For instance, you could target a particular audience or set a timeframe:
+
+- How to set up Braintrust
+- How to set up Braintrust in 5 minutes
+
+## NO adjectiives
+
+I want you to almost always avoid adjectives and try to use evidence instead. Instead of saying "production ready," you can write something like "scaling this to 100 servers or 1 million documents per second." Numbers like that will tell you exactly what the specificity of your product is. If you have to use adjectives rather than evidence, you are probably making something up. 
+
+There's no reason to say something like "blazingly fast" unless those things are already known phrases.
+
+Instead, say "200 times faster" or "30% faster." A 30% improvement in recommendation system speed is insane.
+
+There's a 200 times performance improvement because we went from one programming language to another. It's just something that's a little bit more expected and understandable.
+
+Another test that I really like using recently is tracking whether or not the statements you make can be:
+
+- Visualized
+- Proven false
+- Said only by you
+
+If you can nail all three, the claim you make will be more likely to resonate with an audience because only you can say it.
+
+Earlier this year, I had an example where I embedded all of Wikipedia in 17 minutes with 20 bucks, and it got half a million views. All we posted was a video of me kicking off the job, and then you can see all the log lines go through. You see the number of containers go from 1 out of 50 to 50 out of 50.
+
+It was easy to visualize and could have been proven false by being unreproducible. Lastly, Modal is the only company that could do that in such an effortless way, which made it unique.
+
+## Keep It Digestible 
+    - Aim for 5-minute reads
+    - Write at a Grade 10 reading level
+    - Break up long paragraphs
+    - Use headers and bullet points
+
+## Make It Scannable
+    - Bold key points
+    - Use subheadings every 3-4 paragraphs
+    - Include plenty of white space
+    - Add relevant examples
+
+This structure works whether you're writing a tweet thread or a full blog post. The key is making complex ideas accessible.
+
+# Guide to Writing Cline Documentation
+
+## Some general principles for explaining features
+
+If you're talking about a feature, it's helpful to start with a human-readable explanations that cover what the feature is in simple terms. Skip jargon and explain it like you're talking to someone who's never seen it before. This sets the foundation for everything that follows.
+
+Combine location and usage into one flowing section. Tell users exactly where to find the feature and how to use it, but weave the instructions into natural prose with a good balance of bullet points, numbered lists, code examples (if applicable), mintlify components, and headers/subheaders. Users shouldn't have to jump between separate "where is it" and "how do I use it" sections.
+
+Show the feature in action with real examples like actual files, workflows, or code. Users need to see concrete implementations, not just abstract descriptions. This is where understanding turns into practical knowledge.
+
+When talking about a feature, include an inspiration section that sparks imagination. This section pushes people from understanding to action by showing them what becomes possible when they use this feature creatively. It's what separates good documentation from great documentation.
+
+## Writing Principles That Actually Work
+
+### Write for Action, Not Just Understanding
+
+Documentation should motivate users to try things. Instead of just explaining how something works, focus on what users can accomplish with it. The inspiration section is crucial - it's what transforms passive readers into active users.
+
+### Create a Natural Story Flow
+
+It should feel like a conversation that naturally progresses from "what is this?" to "how do I use it?" to "here's a real example" to "imagine what you could do with this." 
+
+### Show Real Examples, Not Toy Demos
+
+Provide actual workflow files, real code snippets, and concrete implementations that users can copy and adapt. Abstract examples don't help anyone - users want to see exactly what they'll be working with.
+
+### Keep It Scannable But Not Fragmented
+
+Write in prose that flows naturally when read completely, but structure it so users can quickly find specific information when they're troubleshooting. Avoid dense walls of text, but also avoid over-formatting with excessive bullet points and bold headers. There should be a nice visual heirarchy of balance between all elements, so you can quickly scan the page and find what you're looking for.
+
+## Language and Tone Guidelines
+
+Write clearly without dumbing things down. Use simple language when possible, but don't avoid technical terms that users need to know. Explain concepts in terms of what users can achieve rather than how the software works internally.
+
+Make your writing conversational and encouraging. Phrases like "you can also try" or "when that works" feel more natural than rigid instructional language. Help users feel confident about trying new things.
+
+Keep content concise and purposeful. Every sentence should either help users understand something or help them do something. If it doesn't serve one of those purposes, cut it.
+
+Build in context and reasoning. Users want to understand why they're doing something, not just what to do. This builds confidence and helps them troubleshoot when things don't work exactly as expected.
+
+## Practical Implementation
+
+Structure each feature page consistently with the four-section approach, but let the content flow naturally within that structure. Use visual assets like videos and screenshots to complement the written content - they often communicate more effectively than paragraphs of description.
+
+Link generously to related resources, examples, and deeper documentation. Users should never feel stuck or wonder where to go next. Maintain a repository of real examples that users can reference and adapt to their own needs.
+
+The goal is documentation that feels more like helpful guidance from an experienced colleague than a technical manual. Users should finish reading feeling excited about what they can accomplish, not just informed about what the feature does.
+
+## Balance Structure with Flexibility
+
+While they discuss having consistent documentation structure, there's also mention of making content feel less rigid and more natural. The writing should follow guidelines while still feeling conversational and engaging. 
+
+## Bad examples
+
+I personally hate this pattern of bullet point **Bold Text** colon and then more text:
+<bad_example_of_writing>
+#### macOS
+
+1. **Switch to bash**: Go to Cline Settings → Terminal → Default Terminal Profile → Select "bash"
+2. **Disable Oh-My-Zsh temporarily**: If using zsh, try `mv ~/.zshrc ~/.zshrc.backup` and restart VSCode
+3. **Set environment**: Add to your shell config: `export TERM=xterm-256color`
+
+#### Windows
+
+1. **Use PowerShell 7**: Install from Microsoft Store, then select it in Cline settings
+2. **Disable Windows ConPTY**: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → Uncheck
+3. **Try Command Prompt**: Sometimes simpler is better - switch to cmd.exe
+
+#### Linux
+
+1. **Use bash**: Most reliable option - select in Cline settings
+2. **Check permissions**: Ensure VSCode has terminal access permissions
+3. **Disable custom prompts**: Comment out prompt customizations in `.bashrc`
+
+</bad_example_of_writing>
+
+We should instead strive to write beautiful docs that read well. We can use bullet points and numbered lists but it should read naturally and be delightful to look at hierachally when scanning through the doc. There should be a good balance between blocks of text, code snippets, paragraphs, numbered lists, and bullet points. When scanning the documentation visually, you should feel like you're adminiring a tasteful art piece.
+
+<good_example_of_writing>
+#### macOS
+
+The most common fix is switching to bash. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown.
+
+If you're still having issues, Oh-My-Zsh might be interfering with terminal integration. Try temporarily disabling it:
+- Run `mv ~/.zshrc ~/.zshrc.backup` 
+- Restart VSCode
+
+You can also add `export TERM=xterm-256color` to your shell configuration file to improve compatibility.
+
+#### Windows
+
+PowerShell 7 provides the most reliable experience. Install it from the Microsoft Store, then select it in your Cline settings.
+
+Still seeing problems? Try these solutions:
+- Disable Windows ConPTY: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → uncheck
+- Switch to Command Prompt (cmd.exe) - sometimes simpler shells work better
+
+#### Linux
+
+Bash is your most dependable option. Select it in Cline settings if you haven't already.
+
+Check these common issues:
+- Ensure VSCode has terminal access permissions
+- Temporarily comment out custom prompt configurations in your `.bashrc`
+</good_example_of_writing>
+
+This is much more natural to read. Writing this way creates a conversational flow, and bullet points are used idiomatically.
+
+# Using Mintlify Components Idiomatically
+
+Mintlify's custom components can transform basic documentation into engaging, scannable content that users actually want to read. Here's how to use them effectively.
+
+## Visual Content with Frames
+
+Videos and images should be wrapped in `<Frame>` components rather than using raw HTML or markdown. This creates consistent styling and proper responsive behavior.
+
+For videos, embed them directly rather than linking externally. Users are much more likely to watch a 30-second demonstration than click through to another platform:
+
+```jsx
+<Frame>
+	<iframe
+		style={{ width: "100%", aspectRatio: "16/9" }}
+		src="https://www.youtube.com/embed/your-video-id"
+		title="Feature demonstration"
+		frameBorder="0"
+		allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+		allowFullScreen
+	/>
+</Frame>
+```
+
+Screenshots work similarly - the frame provides visual polish and consistency:
+
+```jsx
+<Frame>
+	<img src="/path/to/screenshot.png" alt="Descriptive alt text" />
+</Frame>
+```
+
+## Cards for Navigation and Overview
+
+Cards excel at creating scannable overviews that link to detailed documentation. They're perfect for feature listings, getting started guides, or any section where users need to choose their path.
+
+Use the two-column layout for related features:
+
+```jsx
+<Columns cols={2}>
+  <Card title="Feature Name" icon="relevant-icon" href="/link/to/docs">
+    Brief description that explains what this feature does and why someone would use it.
+  </Card>
+  
+  <Card title="Related Feature" icon="another-icon" href="/another/link">
+    Another concise explanation that helps users understand the value proposition.
+  </Card>
+</Columns>
+```
+
+The key is writing card descriptions that are informative enough to help users decide whether to click through, but concise enough to scan quickly. Each card should answer "what does this do?" and "why would I need this?"
+
+## Tips and Notes for Context
+
+Use `<Tip>` components for helpful information that enhances the main content without cluttering it:
+
+```jsx
+<Tip>
+	Pro tip: You can combine multiple @ mentions in a single message to give Cline 
+	comprehensive context about your issue.
+</Tip>
+```
+
+`<Note>` components work well for important caveats or technical limitations:
+
+```jsx
+<Note>
+	Due to VS Code limitations, some features require specific settings to work properly.
+</Note>
+```
+
+`<Info>` is also cool:
+
+<Info>
+	**Quick Fix**: If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings.
+	This resolves 90% of terminal integration problems.
+</Info>
+
+**Never** fall into that awful **Bold Text** - description pattern that we specifically identified as bad writing. The content should flow naturally as connected thoughts rather than feeling like a templated AI response with forced formatting.
+
+
+## When to Use Bullet Points and Numbered Lists Strategically
+
+Bullet points serve functional purposes - use them for:
+
+**Sequential actions or troubleshooting steps** where users need to follow a specific order:
+1. Install the extension
+2. Restart VSCode  
+3. Check the settings panel
+
+**Lists of related options** where users need to choose one approach:
+- Try PowerShell 7 for the most reliable experience
+- Switch to Command Prompt if you're still having issues
+- Use WSL Bash for Linux compatibility
+
+**Quick reference items** that users might need to scan quickly when problem-solving.
+
+**Improving Visual Hierarchy** when there's a wall of text - that's a good time to introduce bullet points or numbered lists.
+
+Each bulleted item or numbered list should be a discrete action or piece of information that benefits from being visually separated. This is a key weapon you can employ when going for that artwork experience I mentioned earlier. 
+
+<good_example_of_bullet_points>
+## Finding and Configuring Terminal Settings
+
+You can access Cline's terminal settings by clicking the settings icon in the Cline sidebar, then navigating to the Terminal section. These settings control how Cline interacts with your system's terminal.
+
+- The **Default Terminal Profile** setting determines which shell Cline uses for executing commands. If you're experiencing issues, this is usually the first thing to change. I personally keep this set to `bash` on all my systems because it's the most reliable option, even though I use `zsh` for my regular terminal work.
+
+- **Shell Integration Timeout** controls how long Cline waits for the terminal to become ready. The default is 4 seconds, but if you have a heavy shell configuration (lots of plugins, slow startup scripts), you might need to increase this to 10 or even 15 seconds. I've found that WSL environments and SSH connections often need longer timeouts.
+
+- The **Enable Aggressive Terminal Reuse** setting determines whether Cline tries to reuse existing terminals even when they're not in the correct directory. When this causes problems (commands running in the wrong directory, virtual environment issues), disabling it creates more terminal instances but ensures each command runs in a clean state.
+
+- **Terminal Output Line Limit** sets how many lines of output Cline will read from commands. The default of 500 lines works for most cases, but you might need to adjust it. For verbose build outputs, increase it. For commands with progress bars that spam thousands of lines, decrease it to around 100 to avoid consuming too many tokens.
+</good_example_of_bullet_points>
+
+## Write Like a Human, Not an AI
+
+Keep it short and direct. If you can say something in fewer words, do it. Long explanations often confuse more than they help.
+
+Use normal sentence lengths. Mix short and long sentences naturally, like you would when talking to someone. Avoid those meandering compound sentences that go on forever.
+
+Cut the corporate speak. Instead of "utilize," say "use." Instead of "in order to," just say "to." Write like you're explaining something to a colleague, not drafting a press release.
+
+Don't over-explain obvious things. If users are reading documentation, they probably understand basic concepts. Respect their intelligence.
+
+## Never use em dashes or emojis
+
+That's pretty much it. Never use them. Only AI writes with em dashes or emojis.
+
+# Anthropomorphizing Cline
+
+When referring to Cline, always call him a "him" not an "it". 
+
+Bad example:
+- When Cline can’t execute commands or read their output, you lose access to one of its most powerful capabilities.
+
+Good Example:
+
+- When Cline can’t execute commands or read their output, you lose access to one of his most powerful capabilities.
+
+# Using "I" when sharing your workflow
+
+Adding a personal touch goes a long way. There are great examples in the docs currently where I use "I" to share how I personally use cline, from dev to dev. It's a great technique.
+
+# Crosslinking relevant documentation pages
+
+Make sure you crosslink when you're done writing the docs. If there are relevant docs, just link to them.
+
+# Brevity is the soul of wit
+
+Don't ramble if you don't need to. Use bullet points and numbered lists. Keep things easy to read.
+
+<bad_example>
+
+When Cline can't execute commands or read their output, you lose access to one of his most powerful capabilities. Terminal integration problems are frustrating, but they're usually fixable with a few simple changes.
+
+## The Most Common Problem: Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline isn't getting command output, the issue is almost always your shell configuration. Complex shell setups with custom prompts, plugins, and fancy configurations can interfere with VSCode's terminal integration.
+
+**Switch to bash first.** This fixes the problem 90% of the time. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown. Restart VSCode after making this change.
+
+Still having issues? Try increasing the shell integration timeout. Go to Cline Settings → Terminal → Shell Integration Timeout and change it from 4 seconds to 10 seconds. Heavy shell configurations need more time to initialize properly.
+
+If commands are running in the wrong directories or you're seeing weird behavior, disable aggressive terminal reuse. In Cline Settings → Terminal, uncheck "Enable aggressive terminal reuse." This creates more terminal instances but ensures each command runs in a clean environment.
+
+
+</bad_exaxmple>
+
+The first part is total filler, useless to any serious developer. You can tell it's written by a non technical person that doesn't value clean, straightforward information. 
+
+<good_example>
+## Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline can't read command output, your shell configuration is interfering with VSCode's terminal integration.
+
+**Switch to bash first.** Go to Cline Settings → Terminal → Default Terminal Profile and select "bash." This fixes 90% of problems.
+
+Still broken? Try these:
+- Increase shell integration timeout to 10 seconds in Cline Settings → Terminal
+- Disable "aggressive terminal reuse" if commands run in wrong directories
+- Restart VSCode after making changes
+</good_example>
+
+The good version cuts straight to the problem and solution. No hand-holding, no emotional language about frustration, just the facts: what's wrong, how to fix it, what to try next. Respects that developers want information, not sympathy.RetryClaude can make mistakes. Please double-check responses.
+
+ALWAYS consider your audience. And your audience is devs who don't want their time wasted. Give them the info. I cannot stress this enough. Use bullet points and numbered lists. Prose is good, but every word should actually mean something to the dev reading it.
+
+# Lastly, before you start writing docs
+
+1. Internalize these guidelines. I mean it. 
+
+2. Read `docs/docs.json` and get an understanding of the structure of the docs. This will come in handly at the end when you're doing a final pass so you can cross link to docs where relevant.
+
+3. Read some good examples that I personally wrote and am proud of:
+
+- docs/features/slash-commands/workflows.mdx
+- docs/features/slash-commands/new-task.mdx
+- docs/features/at-mentions/overview.mdx
+- docs/features/drag-and-drop.mdx
+
+4. If the user specifies any other instructions make sure you follow them.

.eslintrc.json

@@ -22,6 +22,7 @@
 		"react-hooks/exhaustive-deps": "off",
 		"eslint-rules/no-protobuf-object-literals": "error",
 		"eslint-rules/no-grpc-client-object-literals": "error",
+		"eslint-rules/no-direct-vscode-api": "warn",
 		"no-restricted-syntax": [
 			"error",
 			{

.github/ISSUE_TEMPLATE/feature_contribution.yml

@@ -0,0 +1,116 @@
+name: 💡 Feature Proposal & Contribution
+description: Propose a new feature or improvement, and optionally offer to implement feature as a contributor
+labels: ["proposal"]
+body:
+    - type: markdown
+      attributes:
+          value: |
+              **Feature Proposal & Contribution for Cline**
+
+              Thank you for proposing a feature or improvement for Cline! This template helps us understand the problem, evaluate the solution, and coordinate implementation.
+
+              **For detailed proposals:** Please provide comprehensive information to enable fast prioritization and discussion.
+              **For contribution offers:** You can indicate your willingness to implement the feature yourself.
+
+              Before submitting:
+              - Search existing [Issues](https://github.com/cline/cline/issues) and [Discussions](https://github.com/cline/cline/discussions) to avoid duplicates
+              - Read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md) if you plan to contribute
+              - Don't start implementation until the proposal is reviewed and approved
+
+    - type: textarea
+      id: problem-description
+      attributes:
+          label: What problem does this solve?
+          description: |
+              Describe the problem clearly from a user's point of view. Focus on why this matters, who it affects, and when it occurs.
+
+              ✅ Good examples:
+              - "LLM provider returns 400 error when nearing the context window instead of truncating"
+              - "Submit button is invisible in dark mode"
+              - "Users can't easily share their Cline configurations with team members"
+
+              ❌ Avoid vague descriptions:
+              - "Performance is bad"
+              - "UI needs work"
+
+              Your description should include:
+              - Who is affected?
+              - When does it happen?
+              - What's the current vs expected behavior?
+              - What is the impact?
+          placeholder: Be specific about the problem, who it affects, and the impact.
+      validations:
+          required: true
+
+    - type: textarea
+      id: proposed-solution
+      attributes:
+          label: What's the proposed solution?
+          description: |
+              Describe how the problem should be solved. Be specific about UX, system behavior, and any flows that would change.
+
+              ✅ Good examples:
+              - "Add error handling immediately after attempting to create the llm stream and retry after manually truncating"
+              - "Update button styling to ensure contrast in all themes"
+              - "Add export/import functionality in settings with JSON format"
+
+              ❌ Avoid vague solutions:
+              - "Improve performance"
+              - "Fix the bug"
+
+              Your solution should include:
+              - What exactly will change?
+              - How will users interact with it?
+              - What's the expected outcome?
+          placeholder: Describe the proposed changes and how they solve the problem.
+      validations:
+          required: false
+
+    - type: dropdown
+      id: contribution-intent
+      attributes:
+          label: Are you interested in implementing this?
+          description: Let us know if you'd like to contribute to this feature
+          options:
+              - "No, just proposing the idea"
+              - "Yes, I'd like to implement this myself"
+              - "Yes, I'd like to collaborate with others"
+              - "Maybe, depending on complexity and guidance"
+      validations:
+          required: false
+
+    - type: textarea
+      id: implementation-approach
+      attributes:
+          label: Implementation approach (if contributing)
+          description: |
+              **Only fill this out if you selected "Yes" above.**
+
+              How do you plan to implement this? Include:
+              - High-level technical approach
+              - Files/components that would be affected
+              - Any new dependencies required
+              - Potential challenges or considerations you've identified
+
+              This helps us provide better guidance and ensures alignment before you start coding.
+          placeholder: "My implementation approach would be..."
+
+    - type: checkboxes
+      id: checklist
+      attributes:
+          label: Proposal checklist
+          options:
+              - label: I've checked for existing issues or related proposals
+                required: true
+              - label: I understand this needs review before implementation can start
+                required: true
+
+    - type: checkboxes
+      id: contribution-checklist
+      attributes:
+          label: Contribution checklist (if contributing)
+          description: Only check these if you plan to contribute
+          options:
+              - label: I've read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
+              - label: I'm willing to make changes based on feedback
+              - label: I understand the code review process and requirements

.github/ISSUE_TEMPLATE/feature_proposal.yml

@@ -1,130 +0,0 @@
-name: 📝 Detailed Feature Proposal
-description: Propose a new feature or improvement
-labels: ["proposal"]
-body:
-    - type: markdown
-      attributes:
-          value: |
-              **Feature Proposal for Cline**
-
-              Thank you for creating a feature proposal for Cline! This template is for clear, actionable proposals that define a specific problem and a high-confidence solution. Please provide enough detail to enable fast prioritization, discussion, and execution.
-
-              Detailed proposals will be prioritized, while vague proposals may be closed or require extensive back and forth communication.
-
-              Before submitting:
-              - Search existing [Issues](https://github.com/cline/cline/issues) and [Discussions](https://github.com/cline/cline/discussions) to avoid duplicates
-              - Don’t start implementation until the proposal is reviewed and approved
-
-    - type: textarea
-      id: problem-description
-      attributes:
-          label: What problem does this solve?
-          description: |
-              Describe the problem clearly from a user's point of view. Focus on why this matters, who it affects, and when it occurs.
-
-              ✅ Solid:
-              - "LLM provider returns 400 error when nearing the context window instead of truncating"
-              - "Submit button is invisible in dark mode"
-
-              ❌ Avoid:
-              - "Performance is bad"
-              - "UI needs work"
-
-              Your description should include:
-              - Who is affected?
-              - When does it happen?
-              - What's the current vs expected behavior?
-              - What is the impact?
-          placeholder: Be specific about the problem, who it affects, and the impact.
-      validations:
-          required: true
-
-    - type: textarea
-      id: proposed-solution
-      attributes:
-          label: What’s the proposed solution?
-          description: |
-              Describe how the problem should be solved. Be specific about UX, system behavior, and any flows that would change.
-
-              ✅ Solid:
-              - "Add error handling immediately after attempting to create the llm stream and retry after manually truncating"
-              - "Update button styling to ensure contrast in all themes"
-
-              ❌ Avoid:
-              - "Improve performance"
-              - "Fix the bug"
-
-              Your solution should include:
-              - What exactly will change?
-              - How will users interact with it?
-              - What’s the expected outcome?
-          placeholder: Describe the proposed changes and how they solve the problem.
-      validations:
-          required: true
-
-    - type: textarea
-      id: acceptance-criteria
-      attributes:
-          label: How will we know it works? (Acceptance Criteria)
-          description: Define clear, testable success criteria.
-          placeholder: Provide specific and testable conditions for success.
-      validations:
-          required: true
-
-    - type: textarea
-      id: estimated-effort
-      attributes:
-          label: Estimated effort and complexity
-          description: |
-              Help us understand scope and risks. Include:
-
-              - Size estimate (XS/S/M/L/XL or hours/days)
-              - Why this size? What’s technically involved?
-              - Any tricky parts, refactors, or risks?
-              - Performance or compatibility concerns?
-              - Any dependencies on systems, teams, or libraries?
-          placeholder: Size, reasoning, risks, and dependencies.
-      validations:
-          required: true
-
-    - type: textarea
-      id: technical-considerations
-      attributes:
-          label: Technical considerations, tradeoffs, and/or risks (optional)
-          description: |
-              Include any technical context that helps us evaluate or implement the proposal more effectively.
-
-              You may include:
-              - Architectural changes or required refactors
-              - Performance implications or system-level impacts
-              - Known limitations, risks, or tricky edge cases
-              - Compatibility concerns or migration steps
-              - Alternative approaches you considered and why they were not chosen
-              - Dependencies on other systems, teams, or libraries
-              - Were other approaches considered? Why is this one preferred?
-          placeholder: Technical considerations, tradeoffs, and/or risks.
-
-    - type: textarea
-      id: additional-context
-      attributes:
-          label: Additional context (optional)
-          description: Diagrams, mockups, logs, links, or anything else that helps explain or justify the proposal.
-          placeholder: Diagrams, mockups, logs, links, or anything else that helps explain or justify the proposal.
-
-    - type: checkboxes
-      id: checklist
-      attributes:
-          label: Proposal checklist
-          options:
-              - label: I’ve checked for existing issues or related proposals
-                required: true
-              - label: I understand this needs review before implementation can start
-                required: true
-
-    - type: checkboxes
-      id: willingness-to-contribute
-      attributes:
-          label: Interested in implementing this?
-          description: Optional
-          options:
-              - label: Yes, I’d like to help implement this feature

.github/workflows/e2e.yml

@@ -0,0 +1,88 @@
+name: E2E Tests
+
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        types: [opened, reopened, synchronize, ready_for_review]
+    workflow_dispatch:
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+    cancel-in-progress: true
+
+jobs:
+    matrix_prep:
+        runs-on: ubuntu-latest
+        outputs:
+            matrix: ${{ steps.set-matrix.outputs.matrix }}
+        steps:
+            - id: set-matrix
+              run: |
+                  echo 'matrix=[{"runner":"ubuntu"},{"runner":"windows"},{"runner":"macos"}]' >> $GITHUB_OUTPUT
+
+    e2e:
+        needs: matrix_prep
+        strategy:
+            fail-fast: false
+            matrix:
+                include: ${{ fromJson(needs.matrix_prep.outputs.matrix) }}
+        runs-on: ${{ matrix.runner }}-latest
+        timeout-minutes: 20
+        permissions:
+            id-token: write
+            contents: read
+        steps:
+            - uses: actions/checkout@v4
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache root dependencies
+              uses: actions/cache@v4
+              id: root-cache
+              with:
+                  path: node_modules
+                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
+
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache webview-ui dependencies
+              uses: actions/cache@v4
+              id: webview-cache
+              with:
+                  path: webview-ui/node_modules
+                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+
+            - name: Install root dependencies
+              if: steps.root-cache.outputs.cache-hit != 'true'
+              run: npm ci
+
+            - name: Install webview-ui dependencies
+              if: steps.webview-cache.outputs.cache-hit != 'true'
+              run: cd webview-ui && npm ci
+
+            - name: Install xvfb on Linux
+              if: matrix.runner == 'ubuntu'
+              run: sudo apt-get update && sudo apt-get install -y xvfb
+
+            # Build the extension before running tests
+            - name: Build Tests and Extension
+              run: npm run pretest
+
+            - name: Run E2E tests - Linux
+              if: matrix.runner == 'ubuntu'
+              run: xvfb-run -a npm run test:e2e
+
+            - name: Run E2E tests - Non-Linux
+              if: matrix.runner != 'ubuntu'
+              run: npm run test:e2e
+
+            - uses: actions/upload-artifact@v4
+              if: ${{ failure() }}
+              with:
+                  name: playwright-recordings-${{ matrix.runner }}
+                  path: |
+                      test-results/playwright/

.github/workflows/publish.yml

@@ -94,6 +94,7 @@ jobs:
               env:
                   VSCE_PAT: ${{ secrets.VSCE_PAT }}
                   OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  CLINE_ENVIRONMENT: production
               run: |
                   # Required to generate the .vsix
                   vsce package --out "cline-${{ steps.get_version.outputs.version }}.vsix"

.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
             issues: write
             pull-requests: write
         steps:
-            - uses: actions/stale@28ca103
+            - uses: actions/stale@v9
               with:
                   days-before-issue-stale: 60
                   days-before-issue-close: 14

.github/workflows/test.yml

@@ -68,6 +68,10 @@ jobs:
               if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
+            - name: Install xvfb on Linux
+              if: runner.os == 'Linux'
+              run: sudo apt-get update && sudo apt-get install -y xvfb
+
             - name: Install local modules on windows
               if: runner.os == 'Windows' && steps.root-cache.outputs.cache-hit == 'true'
               run: |

.gitignore

@@ -7,6 +7,7 @@ tmp
 *.vsix
 
 .DS_Store
+.idea
 
 pnpm-lock.yaml
 
@@ -33,8 +34,8 @@ src/shared/proto/host/*.ts
 # Webview
 webview-ui/src/services/grpc-client.ts
 # Host bridge
-src/hosts/vscode/*/methods.ts
-src/hosts/vscode/*/index.ts
 src/hosts/vscode/client/host-grpc-client.ts
-src/hosts/vscode/host-grpc-service-config.ts
-src/standalone/server-setup.ts
+src/standalone/server-setup.ts
+
+# E2E Tests
+test-results

.vscode-test.mjs

@@ -2,7 +2,7 @@ import { defineConfig } from "@vscode/test-cli"
 import path from "path"
 
 export default defineConfig({
-	files: "{out/**/*.test.js,src/**/*.test.js}",
+	files: "{out/**/*.test.js,src/**/*.test.js,!src/test/e2e/**/*.test.js,!out/src/test/e2e/**/*.test.js}",
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing

.vscode/launch.json

@@ -14,7 +14,8 @@
 			"preLaunchTask": "${defaultBuildTask}",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
 			}
 		},
 		{
@@ -23,20 +24,22 @@
 			"request": "launch",
 			"runtimeExecutable": "${execPath}",
 			"args": [
+				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
-				"--sync",
-				"off",
+				"--sync=off",
 				"--disable-extensions",
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],
 			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
-			"preLaunchTask": "clean-sandbox",
+			"preLaunchTask": "clean-tmp-user",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"TEMP_PROFILE": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
 			}
 		},
 		{

.vscode/tasks.json

@@ -233,10 +233,10 @@
 			"type": "shell"
 		},
 		{
-			"label": "clean-sandbox",
+			"label": "clean-tmp-user",
 			"type": "shell",
 			"dependsOn": ["watch"],
-			"command": "rm -rf .vscode-dev"
+			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -1,24 +1,40 @@
 # Default
 .vscode/**
 .vscode-test/**
-out/**
-node_modules/**
+out/
+dist-standalone/
+node_modules/
 src/**
+standalone/**
 .gitignore
 .yarnrc
 esbuild.js
 vsc-extension-quickstart.md
-**/tsconfig.json
+tsconfig*.json
 **/.eslintrc.json
 **/*.map
 **/*.ts
 **/.vscode-test.*
+eslint-rules/**
+.github/**
+.husky/**
 
 # Custom
-demo.gif
+**/demo.gif
 .nvmrc
 .gitattributes
 .prettierignore
+.husky/
+.github/
+eslint-rules/
+old_docs/
+evals/
+.changie.yaml
+.codespellrc
+.mocharc.json
+buf.yaml
+.changeset/
+.clinerules/
 
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)
 webview-ui/src/**
@@ -32,17 +48,19 @@ webview-ui/node_modules/**
 
 # Ignore docs
 docs/**
+old_docs/**
 
 # Fix issue where codicons don't get packaged (https://github.com/microsoft/vscode-extension-samples/issues/692)
 !node_modules/@vscode/codicons/dist/codicon.css
 !node_modules/@vscode/codicons/dist/codicon.ttf
 
-# Include KaTeX CSS and fonts for LaTeX rendering
-!webview-ui/node_modules/katex/dist/katex.min.css
-!webview-ui/node_modules/katex/dist/fonts/**
-
 # Include default themes JSON files used in getTheme
 !src/integrations/theme/default-themes/**
 
 # Include icons
 !assets/icons/**
+
+# Ignore E2E build files
+e2e-build.js
+e2e.vsix
+test-results/

CHANGELOG.md

@@ -1,5 +1,127 @@
 # Changelog
 
+## [3.19.6]
+
+-   Improve Kimi K2 model provider routing with additional provider options for better availability and performance
+-   Fixed terminal bug where Cline failed to capture output of certain fast-running commands
+-   Fixed bug with increasing auto approved number of requests not resetting the counter mid-task
+
+## [3.19.5]
+
+-   Add Groq as a new API provider with support for all Groq models including Kimi-K2
+-   Add user role display in organization UI for Cline account users
+-   Fix message dialogs not showing option buttons properly
+-   Fix authentication issues when using multiple VSCode windows
+
+## [3.19.4]
+
+-   Add ability to choose Chinese endpoint for Moonshot provider
+
+## [3.19.3]
+
+-   Add Moonshot AI provider
+
+## [3.19.2]
+
+-   Show request ID in error messages returned by Cline Accounts API to help debug user reported issues
+
+## [3.19.1]
+
+-   Fix documentation
+
+## [3.19.0]
+
+-   Add Kimi-K2 as a recommended model in the Cline Provider, and route to Together/Groq for 131k context window and high throughput
+-   Added API Key support for Bedrock integration
+
+## [3.18.14]
+
+-   Fix bug where Cline account users logged in with invalid token would not be shown as logged out in webview presentation layer
+
+## [3.18.13]
+
+-   Fix authentication issue where Cline accounts users would keep getting logged out or seeing 'Unexpected API response' errors
+
+## [3.18.12]
+
+-   Fix flaky organization switching behavior in Cline provider that caused UI inconsistencies and double loading
+-   Fix insufficient credits error display to properly show error messages when account balance is too low
+-   Improve credit balance validation and error handling for Cline provider requests
+
+## [3.18.11]
+
+-   Fix authentication issues with Cline provider by ensuring the client always uses the latest auth token
+
+## [3.18.10]
+
+-   Update recommended fast & cheap model to Grok 4 in OpenRouter model picker
+-   Fix Gemini 2.5 Pro thinking budget slider and add support for Gemini 2.5 Flash Lite Preview model (Thanks @arafatkatze!)
+
+## [3.18.9]
+
+-   Fix streaming reliability issues with Cline provider that could cause connection problems during long conversations
+-   Fix authentication error handling for Cline provider to show clearer error messages when not signed in and prevent recursive failed requests
+-   Remove incorrect pricing display for SAP AI Core provider since it uses non-USD "Capacity Units" that cannot be directly converted (Thanks @ncryptedV1!)
+
+## [3.18.8]
+
+-   Update pricing for Grok 3 model because the promotion ended
+
+## [3.18.7]
+
+-   Remove promotional "free" messaging for Grok 3 model in UI
+
+## [3.18.6]
+
+-   Update request header to include `"ai-client-type": "Cline"` to SAP Api Provider
+-   Add organization accounts
+
+## [3.18.5]
+
+-   Fix Plan/Act mode persistence across sessions and multi-workspace conflicts
+-   Improve provider switching performance by 18x (from 550ms to 30ms) with batched storage operations
+-   Improve SAP AI Core provider model organization and fix exception handling (Thanks @schardosin!)
+
+## [3.18.4]
+
+-   Add support for Gemini 2.5 Pro and Flash to SAP AI Core Provider
+-   Fix logging in with Cline account not getting past welcome screen
+
+## [3.18.3]
+
+-   Improve Cerebras Qwen model performance by removing thinking tokens from model input (Thanks @kevint-cerebras!)
+-   Improve Claude Code provider with better error handling and performance optimizations (Thanks @BarreiroT!)
+
+## [3.18.2]
+
+-   Fix issue where terminal output would not be captured if shell integration fails by falling back to capturing the terminal content.
+-   Add confirmation popup when deleting tasks
+-   Add support for Claude Sonnet 4 and Opus 4 model in SAP AI Core provider (Thanks @lizzzcai!)
+-   Add support for `litellm_session_id` to group requests in a single session (Thanks @jorgegarciarey!)
+-   Add "Thinking Budget" customization for Claude Code (Thanks @BarreiroT!)
+-   Fix issue where the extension would use the user's environment variables for authentication when using Claude Code (Thanks @BarreiroT!)
+
+## [3.18.1]
+
+-   Add support for Claude 4 Sonnet in SAP AI Core provider (Thanks @GTxx!)
+-   Fix ENAMETOOLONG error when using Claude Code provider with long conversation histories (Thanks @BarreiroT!)
+-   Remove Gemini CLI provider because Google asked us to
+-   Fix bug with "Delete All Tasks" functionality
+
+## [3.18.0]
+
+-   Optimized Cline to work with the Claude 4 family of models, resulting in improved performance, reliability, and new capabilities
+-   Added a new Gemini CLI provider that allows you to use your local Gemini CLI authentication to access Gemini models for free (Thanks @google-gemini!)
+-   Optimized Cline to work with the Gemini 2.5 family of models
+-   Updated the default and recommended model to Claude 4 Sonnet for the best performance
+-   Fix race condition in Plan/Act mode switching
+-   Improve robustness of search and replace parsing
+
+## [3.17.16]
+
+-   Fix Claude Code provider error handling for incomplete messages during long-running tasks (Thanks @BarreiroT!)
+-   Add taskId as metadata to LiteLLM API requests for better request tracing (Thanks @jorgegarciarey!)
+
 ## [3.17.15]
 
 -   Fix LiteLLM provider to properly respect selected model IDs when switching between Plan and Act modes (Thanks @sammcj!)

CONTRIBUTING.md

@@ -10,13 +10,6 @@ Bug reports help make Cline better for everyone! Before creating a new issue, pl
      🔐 <b>Important:</b> If you discover a security vulnerability, please use the <a href="https://github.com/cline/cline/security/advisories/new">Github security tool to report it privately</a>.
 </blockquote>
 
-## Deciding What to Work On
-
-Looking for a good first contribution? Check out issues labeled ["good first issue"](https://github.com/cline/cline/labels/good%20first%20issue) or ["help wanted"](https://github.com/cline/cline/labels/help%20wanted). These are specifically curated for new contributors and areas where we'd love some help!
-
-We also welcome contributions to our [documentation](https://github.com/cline/cline/tree/main/docs)! Whether it's fixing typos, improving existing guides, or creating new educational content - we'd love to build a community-driven repository of resources that helps everyone get the most out of Cline. You can start by diving into `/docs` and looking for areas that need improvement.
-
-If you're planning to work on a bigger feature, please create a [feature request](https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop) first so we can discuss whether it aligns with Cline's vision.
 
 ## Before Contributing
 
@@ -24,14 +17,70 @@ All contributions must begin with a GitHub Issue, unless the change is for small
 
 - **Check existing issues**: Search [GitHub Issues](https://github.com/cline/cline/issues).
 - **Create an issue**: Use appropriate templates:
-    - **Bugs:** "Bug Report" template.
-    - **Features:** "Detailed Feature Proposal" template. Approval from a core Cline contributor required before starting.
-- **Claim issues**: Comment your interest.
+    - **Contributions:** Use the "Contribution Request" template to propose what you'd like to work on.
+    - **Bugs:** "Bug Report" template for reporting issues.
+    - **Features:** "Detailed Feature Proposal" template for suggesting new features.
+- **Wait for approval**: A core Cline contributor must approve your contribution request before you start implementation.
+- **Claim issues**: Once approved, the issue will be assigned to you.
 
 **PRs without approved issues may be closed.**
 
+
+## Deciding What to Work On
+
+Looking for a good first contribution? Check out issues labeled ["good first issue"](https://github.com/cline/cline/labels/good%20first%20issue) or ["help wanted"](https://github.com/cline/cline/labels/help%20wanted). These are specifically curated for new contributors and areas where we'd love some help!
+
+We also welcome contributions to our [documentation](https://github.com/cline/cline/tree/main/docs)! Whether it's fixing typos, improving existing guides, or creating new educational content - we'd love to build a community-driven repository of resources that helps everyone get the most out of Cline. You can start by diving into `/docs` and looking for areas that need improvement.
+
 ## Development Setup
 
+
+### Local Development Instructions
+
+1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
+    ```bash
+    git clone https://github.com/cline/cline.git
+    ```
+2. Open the project in VSCode:
+    ```bash
+    code cline
+    ```
+3. Install the necessary dependencies for the extension and webview-gui:
+    ```bash
+    npm run install:all
+    ```
+4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+
+
+
+
+### Creating a Pull Request
+
+1. Before creating a PR, generate a changeset entry:
+    ```bash
+    npm run changeset
+    ```
+   This will prompt you for:
+   - Type of change (major, minor, patch)
+     - `major` → breaking changes (1.0.0 → 2.0.0)
+     - `minor` → new features (1.0.0 → 1.1.0)
+     - `patch` → bug fixes (1.0.0 → 1.0.1)
+   - Description of your changes
+
+2. Commit your changes and the generated `.changeset` file
+
+3. Push your branch and create a PR on GitHub. Our CI will:
+   - Run tests and checks
+   - Changesetbot will create a comment showing the version impact
+   - When merged to main, changesetbot will create a Version Packages PR
+   - When the Version Packages PR is merged, a new release will be published
+4. Testing
+    - Run `npm run test` to run tests locally. 
+    - Before submitting PR, run `npm run format:fix` to format your code
+    - Run `npm run test:ci` to run tests locally
+
+### Extension
+
 1. **VS Code Extensions**
 
     - When opening the project, VS Code will prompt you to install recommended extensions
@@ -86,8 +135,6 @@ All contributions must begin with a GitHub Issue, unless the change is for small
       xvfb
     ```
 
-    - Run `npm run test:ci` to run tests locally
-
 ## Writing and Submitting Code
 
 Anyone can contribute code to Cline, but we ask that you follow these guidelines to ensure your contributions can be smoothly integrated:

README.md

@@ -30,7 +30,7 @@ English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md
 </table>
 </div>
 
-Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
+Meet Cline (pronounced /klaɪn/, like "Klein"), an AI assistant that can use your **CLI** a**N**d **E**ditor.
 
 Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
 
@@ -51,7 +51,7 @@ Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthrop
 
 ### Use any API and Model
 
-Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, and Cerebras. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
+Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras and Groq. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
 
 The extension also keeps track of total tokens and API usage cost for the entire task loop and individual requests, keeping you informed of spend every step of the way.
 
@@ -141,50 +141,6 @@ For example, when working with a local web server, you can use 'Restore Workspac
 
 To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
 
-<details>
-<summary>Local Development Instructions</summary>
-
-1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
-    ```bash
-    git clone https://github.com/cline/cline.git
-    ```
-2. Open the project in VSCode:
-    ```bash
-    code cline
-    ```
-3. Install the necessary dependencies for the extension and webview-gui:
-    ```bash
-    npm run install:all
-    ```
-4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
-
-</details>
-
-<details>
-<summary>Creating a Pull Request</summary>
-
-1. Before creating a PR, generate a changeset entry:
-    ```bash
-    npm run changeset
-    ```
-   This will prompt you for:
-   - Type of change (major, minor, patch)
-     - `major` → breaking changes (1.0.0 → 2.0.0)
-     - `minor` → new features (1.0.0 → 1.1.0)
-     - `patch` → bug fixes (1.0.0 → 1.0.1)
-   - Description of your changes
-
-2. Commit your changes and the generated `.changeset` file
-
-3. Push your branch and create a PR on GitHub. Our CI will:
-   - Run tests and checks
-   - Changesetbot will create a comment showing the version impact
-   - When merged to main, changesetbot will create a Version Packages PR
-   - When the Version Packages PR is merged, a new release will be published
-
-</details>
-
-
 ## License
 
 [Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)

docs/docs.json

@@ -61,7 +61,6 @@
 					"getting-started/installing-cline",
 					"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"
@@ -146,6 +145,8 @@
 				"group": "Provider Configuration",
 				"pages": [
 					"provider-config/anthropic",
+					"provider-config/claude-code",
+					"provider-config/aws-bedrock-with-apikey-authentication",
 					"provider-config/aws-bedrock-with-credentials-authentication",
 					"provider-config/aws-bedrock-with-profile-authentication",
 					"provider-config/gcp-vertex-ai",
@@ -169,6 +170,10 @@
 					"running-models-locally/ollama"
 				]
 			},
+			{
+				"group": "Troubleshooting",
+				"pages": ["troubleshooting/terminal-quick-fixes", "troubleshooting/terminal-integration-guide"]
+			},
 			{
 				"group": "More Info",
 				"pages": ["more-info/telemetry"]

docs/enterprise-solutions/cloud-provider-integration.mdx

@@ -14,6 +14,8 @@ Certain scenarios may warrant using local models, including handling highly sens
 
 #### [IAM Security Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (For administrators)
 
+#### [AWS Bedrock setup for API Keys](/provider-config/aws-bedrock-with-apikey-authentication)
+
 #### [AWS Bedrock setup for Legacy IAM (AWS Credentials)](/provider-config/aws-bedrock-with-credentials-authentication)
 
 #### [AWS Bedrock setup for SSO token (AWS Profile)](/provider-config/aws-bedrock-with-profile-authentication)

docs/exploring-clines-tools/new-task-tool.mdx

@@ -120,7 +120,7 @@ Example of context window usage over 50% with a 200K context window:
 # Context Window Usage
 
 105,000 / 200,000 tokens (53%)
-Model: anthropic/claude-3.7-sonnet (200K context window)
+Model: anthropic/claude-sonnet-4 (200K context window)
 \`\`\`
 
 **IMPORTANT**: When you see context window usage at or above 50%, you MUST:

docs/features/at-mentions/terminal-mentions.mdx

@@ -58,3 +58,16 @@ When you use the terminal mention in your message, here's what happens behind th
 6. The AI can now "see" the complete terminal output with all formatting preserved
 
 This process happens automatically whenever you use the terminal mention, giving the AI access to your command results, error messages, and other terminal output without you having to copy it manually.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal mentions or terminal integration in general (such as "Shell Integration Unavailable" or commands not showing output), please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+Common issues include:
+
+-   Terminal mentions not capturing output
+-   "Shell Integration Unavailable" messages in Cline chat
+-   Commands executing but output not visible to Cline
+-   Terminal integration working inconsistently
+
+The troubleshooting guide provides platform-specific solutions and detailed configuration steps to resolve these issues.

docs/features/commands-and-shortcuts/terminal-integration.mdx

@@ -74,8 +74,25 @@ This approach ensures that all terminal output, including colors and formatting,
 
 -   **Select specific output when needed**: By default, the integration captures all terminal content, but you can also select specific lines before right-clicking to focus on just the relevant output.
 
--   **Combine with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
+-   **Combine terminal outputs with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
 
--   **Use for build and test output**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
+-   **Contextualize build & test outputs with the terminal**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
 
 Next time you're staring at a cryptic error message in your terminal, try using Cline's terminal integration instead of copying and pasting. You'll get more accurate help because Cline can see the complete terminal context with proper formatting.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal integration, such as "Shell Integration Unavailable" or commands not showing output, please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+The troubleshooting guide covers:
+
+-   Common terminal integration issues and quick fixes
+-   Platform-specific solutions for Windows, macOS, and Linux
+-   Shell-specific configurations for zsh, bash, PowerShell, and more
+-   Advanced debugging techniques
+-   Terminal settings optimization
+
+<Tip>
+	**Quick Fix**: Most terminal issues can be resolved by switching to bash in the Cline settings and increasing the shell
+	integration timeout to 10 seconds.
+</Tip>

docs/getting-started/our-favorite-tech-stack.mdx

@@ -1,238 +0,0 @@
----
-title: "Our Favorite Tech Stack"
-description: "A curated list of our recommended technologies and tools for building modern web applications with Cline."
----
-
-## Recommended Stack for New Cline Users (2025)
-
-### Your Complete Development Environment
-
-#### Development Tools
-
--   **VS Code** - Your code editor, [download here](https://code.visualstudio.com/)
--   **GitHub** - Where your code lives, [sign up here](https://github.com)
-
-#### Frontend
-
--   **Next.js 14+** - React framework with App Router
--   **Tailwind CSS** - Beautiful styling without writing CSS
--   **TypeScript** - JavaScript, but safer and smarter
-
-#### Backend
-
--   **Supabase** - Your complete backend solution, [sign up with GitHub](https://supabase.com)
-    -   PostgreSQL database
-    -   Authentication
-    -   File storage
-    -   Real-time updates
-
-#### Deployment
-
--   **Vercel** - Where your app runs, [sign up with GitHub](https://vercel.com)
-    -   Automatic deployments from GitHub
-    -   Preview deployments for testing
-    -   Production-ready CDN
-
-#### AI Development
-
-Choose your AI assistant based on your needs:
-
-| Model             | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) | Best For                       |
-| ----------------- | -------------------------- | --------------------------- | ------------------------------ |
-| Claude 3.5 Sonnet | $3.00                      | $15.00                      | Production apps, complex tasks |
-| DeepSeek R1       | $1.00                      | $3.00                       | Budget-conscious production    |
-| DeepSeek V3       | $0.14                      | $2.20                       | Budget-conscious development   |
-
-#### Free Tier Benefits
-
-**Vercel (Hobby)**
-
--   100 GB data transfer/month
--   100k serverless function invocations
--   100 MB deployment size
--   Automatic HTTPS & CI/CD
-
-**Supabase (Free)**
-
--   500 MB database storage
--   1 GB file storage
--   50k monthly active users
--   2M real-time messages/month
-
-**GitHub (Free)**
-
--   Unlimited public repositories
--   GitHub Actions CI/CD
--   Project management tools
--   Collaboration features
-
-### Getting Started
-
-1. Install the development essentials:
-    - Follow our [Development Essentials Installation Guide](https://docs.cline.bot/getting-started/installing-dev-essentials)
-2. Set up Cline's Memory Bank:
-    - Follow the [Memory Bank setup instructions](https://docs.cline.bot/prompting/cline-memory-bank)
-    - Create an empty `cline_docs` folder in your project root
-    - Create `projectBrief.md` in the `cline_docs` folder (see example below)
-    - Tell Cline to "initialize memory bank"
-3. Add our recommended stack configuration:
-    - Create `.clinerules` file (see template below)
-    - Let Cline handle the rest!
-
-#### Example Project Brief
-
-```markdown
-# Project Brief
-
-## Overview
-
-Building a [type of application] that will [main purpose].
-
-## Core Features
-
--   Feature 1
--   Feature 2
--   Feature 3
-
-## Target Users
-
-[Describe who will use your application]
-
-## Technical Preferences (optional)
-
--   Any specific technologies you want to use
--   Any specific requirements or constraints
-```
-
-### .clinerules Template
-
-```markdown
-# Project Configuration
-
-## Tech Stack
-
--   Next.js 14+ with App Router
--   Tailwind CSS for styling
--   Supabase for backend
--   Vercel for deployment
--   GitHub for version control
-
-## Project Structure
-
-/src
-/app # Next.js App Router pages
-/components # React components
-/lib # Utility functions
-/types # TypeScript types
-/supabase
-/migrations # SQL migration files
-/seed # Seed data files
-/public # Static assets
-
-## Database Migrations
-
-SQL files in /supabase/migrations should:
-
--   Use sequential numbering: 001, 002, etc.
--   Include descriptive names
--   Be reviewed by Cline before execution
-    Example: 001_create_users_table.sql
-
-## Development Workflow
-
--   Cline helps write and review code changes
--   Vercel automatically deploys from main branch
--   Database migrations reviewed by Cline before execution
-
-## Security
-
-DO NOT read or modify:
-
--   .env files
--   \*_/config/secrets._
--   Any file containing API keys or credentials
-```
-
-### Learning Resources (2025)
-
-Want to learn more about the technologies we're using? Here are some great resources:
-
-#### Next.js and React
-
--   [Official Learn Next.js Course](https://nextjs.org/learn) - Interactive tutorial
--   [NextJS App Router: Modern Web Dev in 1 Hour](https://www.youtube.com/nextjs-modern) - Quick overview
--   [Building Real-World Apps with Next.js](https://www.youtube.com/nextjs-real-world) - Practical examples
-
-#### Supabase
-
--   [Supabase From Scratch](https://www.udemy.com/supabase-scratch) - Comprehensive course
--   [Official Quickstart Guides](https://supabase.com/docs/guides/getting-started)
--   [Real-Time Apps with Next.js and Supabase](https://www.newline.co/courses/supabase-nextjs)
-
-#### Tailwind CSS
-
--   [Tailwind CSS Tutorial for Beginners](https://www.youtube.com/tailwind-2025)
--   [Official Tailwind Documentation](https://tailwindcss.com/docs)
--   Interactive course at [Scrimba Tailwind CSS Course](https://scrimba.com/learn/tailwind)
-
-### Other Things to Know
-
-#### Working with Git & GitHub
-
-Git helps you track changes in your code and collaborate with others. Here are the essential commands you'll use:
-
-**Daily Development**
-
-```bash
-# Save your changes (do this often!)
-git add .                                    # Stage all changed files
-git commit -m "Add login page"              # Save changes with a clear message
-
-# Share your changes
-git push origin main                        # Upload to GitHub
-```
-
-**Common Workflow**
-
-1.  **Start of day**: Get latest changes
-
-    ```bash
-    git pull origin main                     # Download latest code
-    ```
-
-2.  **During development**: Save work regularly
-
-    ```bash
-    git add .
-    git commit -m "Clear message about changes"
-    ```
-
-3.  **End of day**: Share your progress
-
-    ```bash
-    git push origin main                     # Upload to GitHub
-    ```
-
-**Best Practices**
-
--   Commit often with clear messages
--   Pull before starting new work
--   Push completed work to share with others
--   Use `.gitignore` to avoid committing sensitive files
-
-> **Tip**: Vercel automatically deploys when you push to main!
-
-#### Environment Variables
-
--   Store secrets in `.env.local` for development
--   Add them to Vercel project settings for production
--   Never commit `.env` files to Git
-
-#### Getting Help
-
-1. Use `/help` in Cline chat for immediate assistance
-2. Check [Cline Documentation](https://docs.cline.bot)
-3. Join our [Discord Community](https://discord.gg/cline)
-4. Search GitHub issues for common problems
-
-Remember: Cline is here to help at every step. Just ask for guidance or clarification when needed!

docs/more-info/telemetry.mdx

@@ -6,7 +6,7 @@ title: "Telemetry"
 
 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.
+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/posthog/telemetry/TelemetryService.ts) to see exactly what we track.
 
 ### Tracking Policy
 
@@ -22,7 +22,7 @@ We collect basic anonymous usage data including:
 **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.
+For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see the exact events we track.
 
 ### How to Opt Out
 

docs/provider-config/aws-bedrock-with-apikey-authentication.mdx

@@ -0,0 +1,135 @@
+---
+title: "AWS Bedrock"
+description: "Learn how to set up AWS Bedrock with Cline using credentials authentication. This guide covers AWS environment setup, regional access verification, and secure integration with the Cline VS Code extension."
+---
+
+### Overview
+
+-   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
+    [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
+-   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models—empowering developers to generate code, debug, and analyze data.
+-   **Developer Focus:** This guide is tailored for individual developers that want to enable access to frontier models via AWS Bedrock with a simplified setup using API Keys.
+
+---
+
+### Step 1: Prepare Your AWS Environment
+
+#### 1.1 Individual user setup - Create a Bedrock API Key
+
+For more detailed instructions check the [documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html).
+
+1. **Sign in to the AWS Management Console:**\
+   [AWS Console](https://aws.amazon.com/console/)
+2. **Access Bedrock Console:**
+    - [Bedrock Console](https://console.aws.amazon.com/bedrock)
+    - Create a new Long Lived API Key. This API Key will have by default the `AmazonBedrockLimitedAccess` IAM policy
+      [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
+
+#### 1.2 Create or Modify the Policy
+
+To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
+
+-   `bedrock:InvokeModel`
+-   `bedrock:InvokeModelWithResponseStream`
+-   `bedrock:CallWithBearerToken`
+
+You can create a custom IAM policy with these permissions and attach it to your IAM user or role.
+
+1.  In the AWS IAM console, create a new policy.
+2.  Use the JSON editor to add the following policy document:
+    ```json
+    {
+    	"Version": "2012-10-17",
+    	"Statement": [
+    		{
+    			"Effect": "Allow",
+    			"Action": ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream", "bedrock:CallWithBearerToken"],
+    			"Resource": "*" // For enhanced security, scope this to specific model ARNs if possible.
+    		}
+    	]
+    }
+    ```
+3.  Name the policy (e.g., `ClineBedrockInvokeAccess`) and attach it to the IAM user associated with the key you created. The IAM user and the API key have the same prefix.
+
+**Important Considerations:**
+
+-   **Model Listing in Cline:** The minimal permissions (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`) are sufficient for Cline to _use_ a model if you specify the model ID directly in Cline's settings. If you rely on Cline to dynamically list available Bedrock models, you might need additional permissions like `bedrock:ListFoundationModels`.
+-   **AWS Marketplace Subscriptions:** For third-party models (e.g., Anthropic Claude), the **`AmazonBedrockLimitedAccess`** policy grants you the necessary permissions to subscribe via the AWS Marketplace. There is no explicit access to be enabled. For Anthropic models you are still required to submit a First Time Use (FTU) form via the Console. If you get the following message in the Cline chat `[ERROR] Failed to process response: Model use case details have not been submitted for this account. Fill out the Anthropic use case details form before using the model.` then open the [Playground in the AWS Bedrock Console](https://console.aws.amazon.com/bedrock/home?#/text-generation-playground), select any Anthropic model and fill in the form (you might need to send a prompt first)
+
+---
+
+### Step 2: Verify Regional and Model Access
+
+#### 2.1 Choose and Confirm a Region
+
+1. **Select a Region:**\
+   AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
+   [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
+2. **Verify Model Access:**
+    - **Note:** Some models are only accessible via an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). In such case check the box "Cross Region Inference".
+
+---
+
+### Step 3: Configure the Cline VS Code Extension
+
+#### 3.1 Install and Open Cline
+
+1. **Install VS Code:**\
+   Download from the [VS Code website](https://code.visualstudio.com/).
+2. **Install the Cline Extension:**
+    - Open VS Code.
+    - Go to the Extensions Marketplace (`Ctrl+Shift+X` or `Cmd+Shift+X`).
+    - Search for **Cline** and install it.
+
+#### 3.2 Configure Cline Settings
+
+1. **Open Cline Settings:**
+    - Click on the settings ⚙️ to select your API Provider.
+2. **Select AWS Bedrock as the API Provider:**
+    - From the API Provider dropdown, choose **AWS Bedrock**.
+3. **Enter Your AWS API Key:**
+    - Input your **API Key**
+    - Specify the correct **AWS Region** (e.g., `us-east-1` or your enterprise-approved region).
+4. **Select a Model:**
+    - Choose an on-demand model (e.g., **anthropic.claude-3-5-sonnet-20241022-v2:0**).
+5. **Save and Test:**
+    - Click **Done/Save** to apply your settings.
+    - Test the integration by sending a simple prompt (e.g., "Generate a Python function to check if a number is prime.").
+
+---
+
+### Step 4: Security, Monitoring, and Best Practices
+
+1. **Secure Access:**
+    - Prefer AWS SSO/federated roles over long-lived API Key when possible.
+    - [AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html)
+2. **Enhance Network Security:**
+    - Consider setting up [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) to securely connect to Bedrock.
+3. **Monitor and Log Activity:**
+    - Enable AWS CloudTrail to log Bedrock API calls.
+    - Use CloudWatch to monitor metrics like invocation count, latency, and token usage.
+    - Set up alerts for abnormal activity.
+4. **Handle Errors and Manage Costs:**
+    - Implement exponential backoff for throttling errors.
+    - Use AWS Cost Explorer and set billing alerts to track usage.\
+      [AWS Cost Management](https://docs.aws.amazon.com/cost-management/latest/userguide/what-is-aws-cost-management.html)
+5. **Regular Audits and Compliance:**
+    - Periodically review IAM roles and CloudTrail logs.
+    - Follow internal data privacy and governance policies.
+
+---
+
+### Conclusion
+
+By following these steps, your enterprise team can securely integrate AWS Bedrock with the Cline VS Code extension to accelerate development:
+
+1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockLimitedAccess` policy, and ensure necessary permissions.
+2. **Verify Region and Model Access:** Confirm that your selected region supports your required models.
+3. **Configure Cline in VS Code:** Install and set up Cline with your AWS credentials and choose an appropriate model.
+4. **Implement Security and Monitoring:** Use best practices for IAM, network security, monitoring, and cost management.
+
+For further details, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your internal cloud team. Happy coding!
+
+---
+
+_This guide will be updated as AWS Bedrock and Cline evolve. Always refer to the latest documentation and internal policies for up-to-date practices._

docs/provider-config/aws-bedrock-with-credentials-authentication.mdx

@@ -5,7 +5,7 @@ description: "Learn how to set up AWS Bedrock with Cline using credentials authe
 
 ### Overview
 
--   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Titan) through AWS.\
+-   **AWS Bedrock:** A fully managed service that offers access to leading generative AI models (e.g., Anthropic Claude, Amazon Nova) through AWS.\
     [Learn more about AWS Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
 -   **Cline:** A VS Code extension that acts as a coding assistant by integrating with AI models—empowering developers to generate code, debug, and analyze data.
 -   **Enterprise Focus:** This guide is tailored for organizations with established AWS environments (using IAM roles, AWS SSO, AWS Organizations, etc.) to ensure secure and compliant usage.
@@ -25,7 +25,7 @@ description: "Learn how to set up AWS Bedrock with Cline using credentials authe
 
 #### 1.2 Attach the Required Policies
 
-To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockFullAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
+To ensure Cline can interact with AWS Bedrock, your IAM user or role needs specific permissions. While the `AmazonBedrockLimitedAccess` managed policy provides comprehensive access, for a more restricted and secure setup adhering to the principle of least privilege, the following minimal permissions are sufficient for Cline's core model invocation functionality:
 
 -   `bedrock:InvokeModel`
 -   `bedrock:InvokeModelWithResponseStream`
@@ -52,8 +52,8 @@ You can create a custom IAM policy with these permissions and attach it to your
 
 **Option 2: Using a Managed Policy (Simpler Initial Setup)**
 
--   Alternatively, you can attach the AWS managed policy **`AmazonBedrockFullAccess`**. This grants broader permissions, including the ability to list models, manage provisioning, and other Bedrock features. This might be simpler for initial setup or if you require these wider capabilities.
-    [View AmazonBedrockFullAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
+-   Alternatively, you can attach the AWS managed policy **`AmazonBedrockLimitedAccess`**. This grants broader permissions, including the ability to list models, manage provisioning, and other Bedrock features. This might be simpler for initial setup or if you require these wider capabilities.
+    [View AmazonBedrockLimitedAccess Policy Details](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html)
 
 **Important Considerations:**
 
@@ -71,8 +71,8 @@ You can create a custom IAM policy with these permissions and attach it to your
    AWS Bedrock is available in multiple regions (e.g., US East, Europe, Asia Pacific). Choose the region that meets your latency and compliance needs.\
    [AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
 2. **Verify Model Access:**
-    - In the AWS Bedrock console, confirm that the models your team requires (e.g., Anthropic Claude, Amazon Titan) are marked as "Access granted."
-    - **Note:** Some advanced models might require an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html) if not available on-demand.
+    - In the AWS Bedrock console, confirm that the models your team requires (e.g., Anthropic Claude, Amazon Nova) are marked as "Access granted."
+    - **Note:** Some advanced models might require an [Inference Profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) if not available on-demand.
 
 #### 2.2 Set Up AWS Marketplace Subscriptions (if needed)
 
@@ -138,7 +138,7 @@ You can create a custom IAM policy with these permissions and attach it to your
 
 By following these steps, your enterprise team can securely integrate AWS Bedrock with the Cline VS Code extension to accelerate development:
 
-1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockFullAccess` policy, and ensure necessary permissions.
+1. **Prepare Your AWS Environment:** Create or use a secure IAM role/user, attach the `AmazonBedrockLimitedAccess` policy, and ensure necessary permissions.
 2. **Verify Region and Model Access:** Confirm that your selected region supports your required models and subscribe via AWS Marketplace if needed.
 3. **Configure Cline in VS Code:** Install and set up Cline with your AWS credentials and choose an appropriate model.
 4. **Implement Security and Monitoring:** Use best practices for IAM, network security, monitoring, and cost management.

docs/provider-config/claude-code.mdx

@@ -0,0 +1,111 @@
+---
+title: "Claude Code"
+description: "Use your Claude Max or Pro subscription with Cline instead of paying per token. Learn how to set up and configure the Claude Code provider."
+---
+
+**Website:** [https://docs.anthropic.com/en/docs/claude-code/setup](https://docs.anthropic.com/en/docs/claude-code/setup)
+
+The Claude Code provider lets you use your existing Claude subscription with Cline. If you have Claude Max or Pro, this means you can use Claude in Cline without paying extra API costs.
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/claude-code-use-opus.gif"
+		alt="Using the Claude Code provider in Cline with Opus model"
+	/>
+</Frame>
+
+## Setup
+
+First, you'll need to install and authenticate Claude Code on your system:
+
+1. **Install Claude Code**: Follow Anthropic's [official setup guide](https://docs.anthropic.com/en/docs/claude-code/setup) to install and authenticate the Claude CLI.
+
+2. **Configure in Cline**:
+    - Open Cline settings (⚙️ icon)
+    - Select **Claude Code** from the **API Provider** dropdown
+    - Set the path to your Claude CLI executable (usually just `claude` if it's in your PATH)
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/claude-code-setup.gif"
+		alt="Setting up the Claude Code provider in Cline"
+	/>
+</Frame>
+
+<br />
+
+<Accordion title="Windows Setup">
+On Windows, Cline supports integrating with Claude Code through WSL.
+Windows doesn't support long commands, and Claude Code only accepts the system prompt through a flag, which means we can't properly prompt Claude through Claude Code. Anthropic is [working on a workaround to streamline this](https://github.com/anthropics/claude-code/issues/3411).
+
+1. **Make sure you have WSL set-up**. You can follow [this](https://code.visualstudio.com/docs/remote/wsl#_installation) guide to do it.
+
+2. **Open VSCode from WSL** and verify it's properly set-up. You should see an indicator in the bottom left that says "WSL". You can find an image of the indicator [here](https://code.visualstudio.com/docs/remote/wsl#_from-the-wsl-terminal).
+
+3. Install Cline within WSL and make sure it shows the following:
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline_wsl_installed_extension.webp"
+		alt="Indicator that an extension is installed on WSL"
+	/>
+</Frame>
+
+4. Clone or [move](https://stackoverflow.com/a/42586455) your project over to WSL
+
+5. Follow the [instructions on how to set up Claude Code normally](#setup), but from the WSL terminal.
+
+</Accordion>
+
+### Finding your Claude Code path
+
+If you're not sure where Claude Code is installed:
+
+-   **macOS / Linux**: Run `which claude` in your terminal
+-   **Windows (Command Prompt)**: Run `where claude`
+-   **Windows (PowerShell)**: Run `Get-Command claude`
+
+## Supported Models
+
+The Claude Code provider supports these models:
+
+-   `claude-sonnet-4-20250514` (Recommended)
+-   `claude-opus-4-20250514`
+-   `claude-3-7-sonnet-20250219`
+-   `claude-3-5-sonnet-20241022`
+-   `claude-3-5-haiku-20241022`
+
+## How it works
+
+When you use Claude Code with Cline, here's what happens behind the scenes:
+
+Cline wraps the Claude Code CLI to handle your requests. Each time you send a message, Cline starts a new `claude` process, sends your conversation, and streams the response back. The AI reasoning comes from Claude Code, but all the actual file editing, terminal commands, and other tools are handled by Cline.
+
+The main difference you'll notice is that responses don't stream character-by-character like other providers. Instead, Claude Code processes your full request before sending back the complete response.
+
+## Limitations
+
+There are a few things to keep in mind with Claude Code:
+
+-   Images in your messages get converted to text placeholders since Claude Code doesn't support image uploads through the CLI
+-   Prompt caching isn't available with this provider
+-   Responses don't stream in real-time like other providers
+
+## Troubleshooting
+
+If you run into issues:
+
+**Authentication problems**: Make sure you're logged into Claude Code with your subscription account. Run `claude auth status` to check.
+
+**Path issues**: Double-check that the Claude CLI path in Cline's settings is correct. Try running `claude --version` in your terminal to verify it's working.
+
+**Still having trouble?** We're actively improving this integration. Report issues on our [GitHub](https://github.com/cline/cline/issues) or ask for help in our [Discord](https://discord.gg/cline).
+
+## Usage with subscriptions
+
+If you have a Claude Max subscription, your usage in Cline shows up as $0.00 in the billing interface since you're not paying additional API costs. Your usage still counts against your subscription limits, but you won't see per-token charges.
+
+For more details about using Claude Code with your subscription, check out Anthropic's documentation:
+
+-   [Claude Code Setup Guide](https://docs.anthropic.com/en/docs/claude-code/setup)
+-   [Using Claude Code with Pro/Max Plans](https://support.anthropic.com/en/articles/11145838-using-claude-code-with-your-pro-or-max-plan)

docs/troubleshooting/terminal-integration-guide.mdx

@@ -0,0 +1,399 @@
+---
+title: "Terminal Integration Troubleshooting Guide"
+sidebarTitle: "Terminal Troubleshooting"
+description: "Complete guide to resolving terminal integration issues in Cline"
+---
+
+This guide helps you resolve terminal integration issues in Cline. Terminal integration is crucial for Cline to execute commands and read their output, enabling it to understand errors, test results, and command responses.
+
+<Tip>
+	If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings, under "Terminal Settings"
+
+    This resolves most terminal integration problems.
+
+</Tip>
+
+## Quick Diagnosis Flowchart
+
+Follow this flowchart to quickly identify your issue:
+
+```mermaid
+graph TD
+    A[Terminal Issue] --> B{Can Cline execute commands?}
+    B -->|No| C[Shell Integration Unavailable]
+    B -->|Yes| D{Can Cline see the output?}
+    D -->|No| E[Output Capture Failed]
+    D -->|Yes| F{Is the output corrupted?}
+    F -->|Yes| G[Character Filtering Issue]
+    F -->|No| H{Does the command hang?}
+    H -->|Yes| I[Long-Running Command Issue]
+    H -->|No| J[Check Terminal Settings]
+
+    C --> K[Try Solution 1]
+    E --> L[Try Solution 2]
+    G --> M[Try Solution 3]
+    I --> N[Try Solution 4]
+
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style K fill:#9f9,stroke:#333,stroke-width:2px
+    style L fill:#9f9,stroke:#333,stroke-width:2px
+    style M fill:#9f9,stroke:#333,stroke-width:2px
+    style N fill:#9f9,stroke:#333,stroke-width:2px
+```
+
+## Common Issues & Quick Solutions
+
+### 1. Shell Integration Unavailable
+
+**Symptoms:**
+
+-   Message: "Shell Integration Unavailable"
+-   Commands execute but Cline can't read output
+-   Terminal works fine manually but not with Cline
+
+**Quick Solutions:**
+
+#### macOS
+
+-   **Switch to bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Disable Oh-My-Zsh temporarily**:
+
+    1. If using zsh, enter `mv ~/.zshrc ~/.zshrc.backup` into the terminal
+    2. Restart VSCode
+
+-   **Set environment**:
+    1.a For Zsh users, use one of the following Zsh commands to edit your shell profile:
+
+          - `nano ~/.zshrc`
+          - `vim ~/.zshrc`
+          - `code ~/.zshrc`
+
+    1.b For Bash users
+
+          - nano ~/.bash_profile
+
+    2. Add the following to your shell config: `export TERM=xterm-256color`
+    3. Save your configuration
+
+#### Windows
+
+-   **Use PowerShell 7**
+
+    1. Install from Microsoft Store
+    2. Go to Cline Settings
+    3. Left-Click the **"Terminal Settings"** tab
+    4. Navigate to **"Default Terminal Profile"** and select **"PowerShell 7"** from the drop-down menu
+
+-   **Disable Windows ConPTY**
+
+    1. Navigate to your VSCode Settings
+    2. Enter "Integrated: Windows Enable Conpty" into the Settings searchbar
+    3. Uncheck the option
+
+-   **Try Command Prompt**
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"Command Prompt"** from the drop-down menu
+
+#### Linux
+
+-   **Use bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Check permissions**
+
+    1. Ensure VSCode has terminal access permissions
+
+-   **Disable custom prompts**
+    1. Comment out prompt customizations in `.bashrc`
+
+### 2. Command Output Not Visible
+
+**Symptoms:**
+
+-   Cline states in chat: "[Command is running but producing no output]"
+-   Commands complete but Cline doesn't see results
+-   Commands work sometimes but not consistently
+
+**Solutions:**
+
+-   **Increase Shell Integration Timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable Terminal Reuse**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+-   **Check for interfering extensions**
+    1. Disable other terminal-related VSCode extensions
+
+### 3. Character Filtering Issues
+
+**Symptoms:**
+
+-   Commas missing from output (JSON appears corrupted)
+-   Special characters stripped from terminal output
+-   Syntax errors that don't appear when running manually
+
+**Solution:**
+This is a known bug in output processing. Workarounds:
+
+-   Recommend AI to use file output instead
+    1. Tell Cline in chat or Cline rules, to use `command > output.txt` before reading the file/s
+
+<Tip>
+	This family of issues is only partially solved in the latest Cline versions, so if you still face this, create a GitHub issue
+	if it is a persistent problem.
+</Tip>
+
+### 4. Long-Running Commands & Progress Bars
+
+**Symptoms:**
+
+-   Docker builds never complete in Cline
+-   Progress bars consume thousands of tokens
+-   The Cline button "Proceed while running" doesn't work properly in chat
+
+<Tip>
+	This family of issues has been solved in latest Cline versions but if you still face any issues, then create a GitHub issue
+	for this.
+</Tip>
+
+## Terminal Settings Explained
+
+Access these in Cline by clicking the settings icon, and navigating to the "Terminal Settings" section:
+
+### Default Terminal Profile
+
+-   **What it does**: Selects which shell Cline uses for commands
+-   **When to change**: If experiencing shell integration issues with your default shell
+-   **Recommended**: - macOS: bash (if zsh has issues) - Windows: PowerShell 7 - Linux: bash
+
+### Shell Integration Timeout
+
+-   **What it does**: How long Cline waits for the terminal to be ready
+-   **Default**: 4 seconds
+-   **When to increase**:
+    -   Slow shell startup (heavy .zshrc/.bashrc)
+    -   WSL environments
+    -   SSH connections
+-   **Recommended**: - Start with 10 seconds if having issues
+
+### Enable Aggressive Terminal Reuse
+
+-   **What it does**: Reuses existing terminals even if not in the correct directory
+-   **When to disable**:
+    -   Commands execute in wrong directory
+    -   Virtual environment issues
+    -   Terminal state corruption
+-   **Trade-off**: - Disabling creates more terminals but ensures clean state
+
+### Terminal Output Line Limit
+
+-   **What it does**: Limits how many lines Cline reads from terminal output
+-   **Default**: 500 lines
+-   **When to adjust**:
+    -   Increase for verbose build outputs
+    -   Decrease if hitting token limits
+    -   Set to 100 for commands with progress bars
+
+## Platform-Specific Solutions
+
+### macOS Issues
+
+#### Oh-My-Zsh Conflicts
+
+Oh-My-Zsh often interferes with shell integration. Solutions:
+
+1. Create a minimal `.zshrc` for VSCode:
+    ```bash
+    # ~/.zshrc-vscode
+    export TERM=xterm-256color
+    export PAGER=cat
+    # Minimal PATH and environment setup
+    ```
+2. Configure VSCode to use it:
+    ```json
+    {
+    	"terminal.integrated.env.osx": {
+    		"ZDOTDIR": "~/.zshrc-vscode"
+    	}
+    }
+    ```
+
+#### macOS 15+ Issues
+
+Recent macOS versions have stricter terminal permissions:
+
+1. System Preferences → Privacy & Security → Developer Tools
+2. Add Visual Studio Code
+3. Restart VSCode completely
+
+### Windows Issues
+
+#### PowerShell Execution Policy
+
+If commands fail silently:
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+#### WSL Integration
+
+For WSL issues:
+
+1. Use WSL extension for VSCode
+2. Open folder in WSL: `code .` from WSL terminal
+3. Select "WSL Bash" as terminal profile in Cline
+
+#### Path Issues
+
+Windows path problems:
+
+1. Use forward slashes in Cline: `C:/Users/...`
+2. Quote paths with spaces: `"C:/Program Files/..."`
+3. Avoid `~` - use full paths
+
+### Linux/SSH/Container Issues
+
+#### SSH Connections
+
+For remote development:
+
+1. Install Cline on the remote machine, not locally
+2. Use SSH extension's integrated terminal
+3. Increase timeout to 15+ seconds
+
+#### Docker Containers
+
+When developing in containers:
+
+1. Install Cline in the container
+2. Use Dev Containers extension
+3. Ensure shell integration scripts are available
+
+## Shell-Specific Fixes
+
+### Zsh
+
+```bash
+# Add to ~/.zshrc
+export TERM=xterm-256color
+export PAGER=cat
+# Disable fancy prompts for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1="%n@%m %1~ %# "
+fi
+```
+
+### Bash
+
+```bash
+# Add to ~/.bashrc
+export TERM=xterm-256color
+export PAGER=cat
+# Simple prompt for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1='\u@\h:\w\$ '
+fi
+```
+
+### Fish
+
+```fish
+# Add to ~/.config/fish/config.fish
+set -x TERM xterm-256color
+set -x PAGER cat
+# Disable fancy features in VSCode
+if test "$TERM_PROGRAM" = "vscode"
+    function fish_prompt
+        echo (whoami)'@'(hostname)':'(pwd)'> '
+    end
+end
+```
+
+### PowerShell
+
+```powershell
+# Add to $PROFILE
+$env:PAGER = "cat"
+# Disable progress bars
+$ProgressPreference = 'SilentlyContinue'
+```
+
+## Advanced Troubleshooting
+
+### Debug Mode
+
+Enable terminal debugging to see what's happening:
+
+1. Open VSCode Command Palette (Cmd/Ctrl+Shift+P)
+2. Run: "Developer: Set Log Level..."
+3. Choose "Trace"
+4. Check Output panel → "Cline" for terminal logs
+
+### Manual Shell Integration Test
+
+Test if shell integration works at all:
+
+```bash
+# In VSCode terminal
+echo $TERM_PROGRAM  # Should show "vscode"
+echo $VSCODE_SHELL_INTEGRATION  # Should be "1"
+```
+
+## FAQ
+
+### Why does Cline create so many terminals?
+
+When shell integration fails, Cline can't reuse terminals safely (they might be running long processes). Enable shell integration or adjust the terminal reuse setting.
+
+### Can I use my custom shell (nushell, xonsh, etc.)?
+
+Cline officially supports bash, zsh, fish, and PowerShell. Custom shells may work but aren't guaranteed. Use bash as a fallback.
+
+### Why do some commands work but others don't?
+
+Commands that use interactive features (pagers, progress bars, curses) often fail. Set `PAGER=cat` and use non-interactive flags.
+
+### How do I know if shell integration is working?
+
+Working integration shows command output in Cline's chat. Failed integration shows "Shell Integration Unavailable" or "[Command is running but producing no output]".
+
+## Still Having Issues?
+
+If you've tried everything:
+
+1. **Collect Debug Info**:
+
+    ```bash
+    echo "Shell: $SHELL"
+    echo "Term: $TERM"
+    echo "VSCode: $TERM_PROGRAM"
+    which bash
+    bash --version
+    ```
+
+2. **Report the Issue**:
+    - Use `/reportbug` in Cline github issues
+    - Include your debug info
+    - Mention which solutions you tried
+
+<Tip>
+	Remember: Most terminal issues are resolved by switching to bash and increasing the timeout. Start there before trying complex
+	solutions.
+</Tip>

docs/troubleshooting/terminal-quick-fixes.mdx

@@ -0,0 +1,51 @@
+---
+title: "Terminal Quick Fixes"
+sidebarTitle: "Terminal Quick Fixes"
+description: "Quick solutions for common terminal issues"
+---
+
+**Here is a list of common fixes, starting with the most applicable:**
+
+-   **Switch to bash** (solves most instances)
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down
+
+-   **Increase timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable terminal reuse**
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+## Platform-Specific Fixes
+
+### macOS + Oh-My-Zsh
+
+```bash
+# Create minimal config for VSCode
+echo 'export TERM=xterm-256color' > ~/.zshrc-vscode
+echo 'export PAGER=cat' >> ~/.zshrc-vscode
+```
+
+### Windows PowerShell
+
+```powershell
+# Run as Administrator
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+### WSL
+
+-   Open folder from WSL: `code .`
+-   Select **"WSL Bash"** in Cline settings, under **"Terminal Settings"**
+-   Increase **"Shell integration timeout (seconds)"** to **15**
+
+## Full Guide
+
+For detailed troubleshooting, see the [Complete Terminal Troubleshooting Guide](/troubleshooting/terminal-integration-guide).

esbuild.js

@@ -5,6 +5,7 @@ const path = require("path")
 const production = process.argv.includes("--production")
 const watch = process.argv.includes("--watch")
 const standalone = process.argv.includes("--standalone")
+const e2eBuild = process.argv.includes("--e2e-build")
 const destDir = standalone ? "dist-standalone" : "dist"
 
 /**
@@ -153,15 +154,25 @@ const extensionConfig = {
 // Standalone-specific configuration
 const standaloneConfig = {
 	...baseConfig,
-	entryPoints: ["src/standalone/standalone.ts"],
-	outfile: `${destDir}/standalone.js`,
+	entryPoints: ["src/standalone/cline-core.ts"],
+	outfile: `${destDir}/cline-core.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"],
 }
 
+// E2E build script configuration
+const e2eBuildConfig = {
+	...baseConfig,
+	entryPoints: ["src/test/e2e/utils/build.ts"],
+	outfile: `${destDir}/e2e-build.js`,
+	external: ["@vscode/test-electron", "execa"],
+	sourcemap: false,
+	plugins: [aliasResolverPlugin, esbuildProblemMatcherPlugin],
+}
+
 async function main() {
-	const config = standalone ? standaloneConfig : extensionConfig
+	const config = standalone ? standaloneConfig : e2eBuild ? e2eBuildConfig : extensionConfig
 	const extensionCtx = await esbuild.context(config)
 	if (watch) {
 		await extensionCtx.watch()

eslint-rules/__tests__/no-direct-vscode-api.test.ts

@@ -0,0 +1,123 @@
+const { RuleTester: DirectApiRuleTester } = require("eslint")
+const noDirectVscodeApiRule = require("../no-direct-vscode-api")
+
+const directApiRuleTester = new DirectApiRuleTester({
+	parser: require.resolve("@typescript-eslint/parser"),
+	parserOptions: {
+		ecmaVersion: 2020,
+		sourceType: "module",
+		ecmaFeatures: {
+			jsx: true,
+		},
+	},
+})
+
+directApiRuleTester.run("no-direct-vscode-api", noDirectVscodeApiRule, {
+	valid: [
+		// Should allow vscode.postMessage in grpc-client-base.ts
+		{
+			code: `vscode.postMessage({ type: "grpc_request", data: {} })`,
+			filename: "grpc-client-base.ts",
+		},
+		{
+			code: `vscode.postMessage({ type: "grpc_request_cancel" })`,
+			filename: "/path/to/grpc-client-base.ts",
+		},
+		// Should allow in exception directories
+		{
+			code: `vscode.workspace.workspaceFolders`,
+			filename: "/src/hosts/vscode/host-bridge.ts",
+		},
+		{
+			code: `vscode.workspace.fs.stat(uri)`,
+			filename: "/standalone/runtime-files/helpers.ts",
+		},
+		// Should allow other vscode API calls
+		{
+			code: `vscode.window.showInformationMessage("Hello")`,
+			filename: "test.ts",
+		},
+		// Should allow postMessage calls on other objects
+		{
+			code: `window.postMessage({ type: "test" }, "*")`,
+			filename: "test.ts",
+		},
+		// Should allow variables named vscode but not calling postMessage
+		{
+			code: `const vscode = { other: "method" }; vscode.other()`,
+			filename: "test.ts",
+		},
+	],
+	invalid: [
+		// Should disallow vscode.postMessage in regular files
+		{
+			code: `vscode.postMessage({ type: "test", data: {} })`,
+			filename: "test.ts",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow vscode.postMessage in components
+		{
+			code: `vscode.postMessage({ type: "apiConfiguration", apiConfiguration })`,
+			filename: "ApiOptions.tsx",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow vscode.postMessage in test files
+		{
+			code: `vscode.postMessage({ type: "newTask", text: message.text })`,
+			filename: "test.test.ts",
+			errors: [
+				{
+					messageId: "useGrpcClient",
+				},
+			],
+		},
+		// Should disallow property access for disallowed APIs
+		{
+			code: `const folders = vscode.workspace.workspaceFolders;`,
+			filename: "workspace.ts",
+			errors: [
+				{
+					messageId: "useHostBridge",
+				},
+			],
+		},
+		// Should disallow method calls for disallowed APIs
+		{
+			code: `const relativePath = vscode.workspace.asRelativePath(filePath);`,
+			filename: "path-utils.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+		// Should disallow nested property access
+		{
+			code: `const stats = await vscode.workspace.fs.stat(uri);`,
+			filename: "file-utils.ts",
+			errors: [
+				{
+					messageId: "useFsUtils",
+				},
+			],
+		},
+		// Should disallow getting a workspace folder
+		{
+			code: `const folder = vscode.workspace.getWorkspaceFolder(uri);`,
+			filename: "path-helper.ts",
+			errors: [
+				{
+					messageId: "usePathUtils",
+				},
+			],
+		},
+	],
+})

eslint-rules/index.js

@@ -1,11 +1,13 @@
 // eslint-rules/index.js
 const noProtobufObjectLiterals = require("./no-protobuf-object-literals")
 const noGrpcClientObjectLiterals = require("./no-grpc-client-object-literals")
+const noDirectVscodeApi = require("./no-direct-vscode-api")
 
 module.exports = {
 	rules: {
 		"no-protobuf-object-literals": noProtobufObjectLiterals,
 		"no-grpc-client-object-literals": noGrpcClientObjectLiterals,
+		"no-direct-vscode-api": noDirectVscodeApi,
 	},
 	configs: {
 		recommended: {
@@ -13,6 +15,7 @@ module.exports = {
 			rules: {
 				"local/no-protobuf-object-literals": "error",
 				"local/no-grpc-client-object-literals": "error",
+				"local/no-direct-vscode-api": "warn",
 			},
 		},
 	},

eslint-rules/no-direct-vscode-api.js

@@ -0,0 +1,164 @@
+const { ESLintUtils } = require("@typescript-eslint/utils")
+const path = require("path")
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://cline.bot/eslint-rules/${name}`)
+
+// Configuration of disallowed VSCode APIs and their recommended alternatives
+const disallowedApis = {
+	"vscode.postMessage": {
+		messageId: "useGrpcClient",
+	},
+	"vscode.workspace.fs.stat": {
+		messageId: "useFsUtils",
+	},
+	"vscode.workspace.workspaceFolders": {
+		messageId: "useHostBridge",
+	},
+	"vscode.workspace.asRelativePath": {
+		messageId: "usePathUtils",
+	},
+	"vscode.workspace.getWorkspaceFolder": {
+		messageId: "usePathUtils",
+	},
+}
+
+module.exports = createRule({
+	name: "no-direct-vscode-api",
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow direct VSCode API usage in favor of Cline's abstraction layers, except in src/hosts/vscode and standalone/runtime-files directories",
+			recommended: "error",
+		},
+		messages: {
+			useGrpcClient:
+				"Use gRPC service clients instead of vscode.postMessage().\n" +
+				"Example: AccountServiceClient.methodName(RequestType.create({...})) instead of vscode.postMessage({type: '...'}).\n" +
+				"Found: {{code}}",
+			useFsUtils:
+				"Use utilities in @/utils/fs instead of vscode.workspace.fs.stat.\n" +
+				"Example: import { isDirectory } from '@/utils/fs' or use the file system methods from the host bridge provider.\n" +
+				"Found: {{code}}",
+			useHostBridge:
+				"Use getHostBridgeProvider().workspaceClient.getWorkspacePaths({}) instead of vscode.workspace.workspaceFolders.\n" +
+				"This provides a consistent abstraction across VSCode and standalone environments.\n" +
+				"Found: {{code}}",
+			usePathUtils:
+				"Use path utilities from @/utils/path instead of direct VSCode workspace path methods.\n" +
+				"This provides consistent path handling across different environments.\n" +
+				"Found: {{code}}",
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+
+	create(context) {
+		// Check if current file is in an exception directory or is grpc-client-base.ts
+		const filename = context.filename
+		const isGrpcClientBase = path.basename(filename) === "grpc-client-base.ts"
+
+		// Skip checking files in src/hosts/vscode or standalone/runtime-files
+		const isExceptionDirectory = filename.includes("/src/hosts/vscode/") || filename.includes("/standalone/runtime-files/")
+
+		// Pattern for checking memberExpressions like vscode.workspace.fs.stat
+		function checkMemberExpression(node) {
+			// Skip if this file is in an exception directory or is grpc-client-base.ts
+			if (isGrpcClientBase || isExceptionDirectory) {
+				return
+			}
+
+			// For handling nested properties like vscode.workspace.fs.stat
+			function getFullPropertyPath(node) {
+				if (node.type !== "MemberExpression") {
+					return node.name || ""
+				}
+
+				const objectPart = getFullPropertyPath(node.object)
+				const propertyPart = node.property.name || ""
+
+				return objectPart ? `${objectPart}.${propertyPart}` : propertyPart
+			}
+
+			// Check if the expression matches one of our disallowed patterns
+			if (node.object && node.object.type === "Identifier" && node.object.name === "vscode") {
+				const fullPath = `vscode.${node.property.name}`
+				checkDisallowedApi(fullPath, node)
+			}
+			// Handle nested expressions like vscode.workspace.fs.stat
+			else if (node.object && node.object.type === "MemberExpression") {
+				const fullPath = getFullPropertyPath(node)
+
+				// Only proceed if it starts with vscode
+				if (fullPath.startsWith("vscode.")) {
+					checkDisallowedApi(fullPath, node)
+				}
+			}
+		}
+
+		// Check if an expression matches a disallowed API and report if it does
+		function checkDisallowedApi(expressionPath, node) {
+			// Check exact matches
+			if (disallowedApis[expressionPath]) {
+				reportViolation(expressionPath, node)
+				return
+			}
+
+			// Check prefix matches (for nested properties)
+			for (const disallowedApi in disallowedApis) {
+				// For direct property access like vscode.workspace.workspaceFolders
+				if (expressionPath === disallowedApi) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+
+				// For method calls like vscode.workspace.asRelativePath(...)
+				if (expressionPath.startsWith(`${disallowedApi}.`) || expressionPath.startsWith(`${disallowedApi}(`)) {
+					reportViolation(disallowedApi, node)
+					return
+				}
+			}
+		}
+
+		// Report a violation with the appropriate message
+		function reportViolation(disallowedApi, node) {
+			const sourceCode = context.sourceCode
+			const config = disallowedApis[disallowedApi]
+
+			// For method calls, get the whole call expression
+			let reportNode = node
+			let parentNode = sourceCode.getAncestors(node).pop()
+			if (parentNode && parentNode.type === "CallExpression" && parentNode.callee === node) {
+				reportNode = parentNode
+			}
+
+			const callText = sourceCode.getText(reportNode).trim()
+
+			context.report({
+				node: reportNode,
+				messageId: config.messageId,
+				data: {
+					code: callText,
+				},
+			})
+		}
+
+		return {
+			// Detect basic member expressions (e.g., vscode.postMessage)
+			MemberExpression(node) {
+				checkMemberExpression(node)
+			},
+
+			// Detect property access through destructuring
+			VariableDeclarator(node) {
+				// Skip if this file is in an exception directory or is grpc-client-base.ts
+				if (isGrpcClientBase || isExceptionDirectory) {
+					return
+				}
+
+				// Destructuring pattern checks removed as developers don't use the API this way
+				// They always use direct imports: import * as vscode from "vscode" and direct access: vscode.thing.foo
+			},
+		}
+	},
+})

evals/.gitignore

@@ -19,4 +19,6 @@ diff_editing/test_outputs/
 .cache
 
 # Python bytecode cache
-*__pycache__/
+*__pycache__/
+
+diff-edits/cases.zip

evals/cli/src/commands/runDiffEval.ts

@@ -6,6 +6,7 @@ interface RunDiffEvalOptions {
 	modelIds: string
 	systemPromptName: string
 	validAttemptsPerCase: number
+	maxAttemptsPerCase?: number
 	parsingFunction: string
 	diffEditFunction: string
 	thinkingBudget: number
@@ -14,6 +15,9 @@ interface RunDiffEvalOptions {
 	testPath: string
 	outputPath: string
 	replay: boolean
+	replayRunId?: string
+	diffApplyFile?: string
+	saveLocally: boolean
 	maxCases?: number
 }
 
@@ -56,14 +60,30 @@ export async function runDiffEvalHandler(options: RunDiffEvalOptions) {
 		args.push("--replay")
 	}
 
+	if (options.replayRunId) {
+		args.push("--replay-run-id", options.replayRunId)
+	}
+
+	if (options.diffApplyFile) {
+		args.push("--diff-apply-file", options.diffApplyFile)
+	}
+
 	if (options.verbose) {
 		args.push("--verbose")
 	}
 
+	if (options.maxAttemptsPerCase) {
+		args.push("--max-attempts-per-case", String(options.maxAttemptsPerCase))
+	}
+
 	if (options.maxCases) {
 		args.push("--max-cases", String(options.maxCases))
 	}
 
+	if (options.saveLocally) {
+		args.push("--save-locally")
+	}
+
 	try {
 		console.log(chalk.gray(`Executing: npx tsx ${scriptPath} ${args.join(" ")}`))
 

evals/cli/src/index.ts

@@ -87,18 +87,23 @@ program
 	.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 	.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 	.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+	.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 	.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 	.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 	.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
 	.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
 	.option("--parallel", "Run tests in parallel", false)
 	.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
+	.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
+	.option("--diff-apply-file <filename>", "The name of the diff apply file to use for the replay")
+	.option("--save-locally", "Save results to local JSON files in addition to database", false)
 	.option("-v, --verbose", "Enable verbose logging", false)
 	.action(async (options) => {
 		try {
 			const fullOptions = {
 				...options,
 				validAttemptsPerCase: parseInt(options.validAttemptsPerCase, 10),
+				maxAttemptsPerCase: options.maxAttemptsPerCase ? parseInt(options.maxAttemptsPerCase, 10) : undefined,
 				thinkingBudget: parseInt(options.thinkingBudget, 10),
 				maxCases: options.maxCases ? parseInt(options.maxCases, 10) : undefined,
 			}

evals/diff-edits/ClineWrapper.ts

@@ -8,11 +8,13 @@ import {
 	parseAssistantMessageV3,
 	AssistantMessageContent,
 } from "./parsing/parse-assistant-message-06-06-25" // "../../src/core/assistant-message"
-import { constructNewFileContent as constructNewFileContentV1, constructNewFileContentV2 } from "./diff-apply/diff-06-06-25"
-import { constructNewFileContent as constructNewFileContentV3 } from "../../src/core/assistant-message/diff" // this defaults to the new v1 when called
+import { constructNewFileContent as constructNewFileContent_06_06_25 } from "./diff-apply/diff-06-06-25"
+import { constructNewFileContent as constructNewFileContent_06_23_25 } from "./diff-apply/diff-06-23-25"
+import { constructNewFileContent as constructNewFileContent_06_25_25 } from "./diff-apply/diff-06-25-25"
+import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./diff-apply/diff-06-26-25"
 
 type ParseAssistantMessageFn = (message: string) => AssistantMessageContent[]
-type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string>
+type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string | any>
 
 const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
 	parseAssistantMessageV1: parseAssistantMessageV1,
@@ -21,12 +23,14 @@ const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
 }
 
 const diffEditingFunctions: Record<string, ConstructNewFileContentFn> = {
-	constructNewFileContentV1: constructNewFileContentV1,
-	constructNewFileContentV2: constructNewFileContentV2,
-	constructNewFileContentV3: constructNewFileContentV3, // position invariant diff
+	"diff-06-06-25": constructNewFileContent_06_06_25,
+	"diff-06-23-25": constructNewFileContent_06_23_25,
+	"diff-06-25-25": constructNewFileContent_06_25_25,
+	"diff-06-26-25": constructNewFileContent_06_26_25,
 }
 
 import { TestInput, TestResult, ExtractedToolCall } from "./types"
+import { log } from "./helpers"
 export { TestInput, TestResult, ExtractedToolCall }
 
 interface StreamResult {
@@ -151,6 +155,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 			diffEditFunction,
 			thinkingBudgetTokens,
 			originalDiffEditToolCallMessage,
+			diffApplyFile,
 		} = input
 
 		const requiredParams = {
@@ -176,7 +181,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 		}
 
 		const parseAssistantMessage = parsingFunctions[parsingFunction]
-		const constructNewFileContent = diffEditingFunctions[diffEditFunction]
+		const constructNewFileContent = diffEditingFunctions[diffApplyFile || diffEditFunction]
 
 		if (!parseAssistantMessage || !constructNewFileContent) {
 			return {
@@ -280,21 +285,21 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 		}
 
 		// check that we are editing the correct file path
-		console.log(`Expected file path: "${originalFilePath}"`);
-		console.log(`Actual file path used: "${diffToolPath}"`);
+		log(input.isVerbose, `Expected file path: "${originalFilePath}"`)
+		log(input.isVerbose, `Actual file path used: "${diffToolPath}"`)
 		if (diffToolPath !== originalFilePath) {
-			console.log(`❌ File path mismatch detected!`);
+			log(input.isVerbose, `❌ File path mismatch detected!`)
 			// Enhanced logging:
 			if (streamResult?.assistantMessage) {
-				console.log(`   Full model output (assistantMessage):`);
-				console.log(`   -----------------------------------------`);
-				console.log(`   ${streamResult.assistantMessage}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Full model output (assistantMessage):`)
+				log(input.isVerbose, `   -----------------------------------------`)
+				log(input.isVerbose, `   ${streamResult.assistantMessage}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			if (toolCall) {
-				console.log(`   Parsed tool call that caused mismatch:`);
-				console.log(`   ${JSON.stringify(toolCall, null, 2)}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Parsed tool call that caused mismatch:`)
+				log(input.isVerbose, `   ${JSON.stringify(toolCall, null, 2)}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			return {
 				success: false,
@@ -306,10 +311,18 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 
 		// checking if the diff edit succeeds, if it failed it will throw an error
 		let diffSuccess = true
+		let replacementData: any = undefined
 		try {
-			await constructNewFileContent(diffToolContent, originalFile, true)
+			const result = await constructNewFileContent(diffToolContent, originalFile, true)
+			
+			// Check if result is an object with replacements (new format)
+			if (typeof result === 'object' && result !== null && 'replacements' in result) {
+				replacementData = result.replacements
+			}
+			// If it's just a string, diffSuccess stays true and replacementData stays undefined
 		} catch (error: any) {
 			diffSuccess = false
+			log(input.isVerbose, `ERROR: ${error}`)
 		}
 
 		return {
@@ -318,6 +331,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 			toolCalls: detectedToolCalls,
 			diffEdit: diffToolContent,
 			diffEditSuccess: diffSuccess,
+			replacementData: replacementData,
 		}
 	} catch (error: any) {
 		return {

evals/diff-edits/README.md

@@ -36,7 +36,7 @@ It starts with our test cases. Each one is a JSON file in `./cases` that has the
 Then, for every test run, we set up a specific configuration. This includes which LLM we're testing, which system prompt it gets, which function we use to parse the model's raw output, and which function we use to actually apply the diff. Here's the command I've been using:
 
 ```bash
-npm run diff-eval -- --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-3-beta" --max-cases 4 --valid-attempts-per-case 2 --verbose --parallel
+npm run diff-eval -- --model-ids "anthropic/claude-3-5-sonnet,x-ai/grok-3-beta,anthropic/claude-3.7-sonnet,anthropic/claude-sonnet-4,google/gemini-2.5-pro-preview,google/gemini-2.5-flash" --max-cases 5 --valid-attempts-per-case 5 --parallel --diff-edit-function diff-06-26-25 --verbose 
 ```
 
 This will build the eval script, run it, and then open the streamlit dashboard to show the results.
@@ -63,9 +63,22 @@ For example, if we ask for 5 valid attempts per test case, the system will keep
 
 This way, if we're comparing two models and one gets a 10% success rate on its valid diff edit attempts, and another gets 90%, we have a much clearer picture of their actual diff-generating capabilities. It avoids muddying the waters with attempts where the model didn't even try to perform the specific action we're evaluating. This approach helps us isolate and measure the diff-editing skill more directly, despite the non-deterministic nature of these models.
 
-## Some known edge cases
+## Replays
 
-I noticed that some of the current conversation jsons in the `./cases` folder are a little big bogus. Here's a running list of these areas:
+You can also use the replay argument to replay a previous benchmark run. This is super useful for iterating on our diffing algorithms without having to re-run expensive and time-consuming LLM calls.
 
-- ~~What if the conversation json was using a model with a massive context window, like Google Gemini's 1M context window, and we're now re-rolling that case on a smaller context window model like claude 4 (200k) or grok-3 (128k)? It's def gonna fail, and we shouldn't just keep trying. We should have a smart system for selecting which cases we can use given the arguments passed in. For example, if we pass in claude and grok with `max cases = 2`, we shouldn't just pick the first two jsons in the folder. We should go through, use a tokenizer, and make sure it would fit with some padding like 20k tokens. Use tiktoken. 20k padding will be sufficient even though different models tokenize differently.~~
-- There are some weird jsons, where something weird happen, where essentially there's a fluke. Maybe the user was using an extremely dumb model that just hallucinated a fake filepath. Now when we try to reroll that case, we never get a valid case. This can easily be handled by making sure that the file is present before selecting that eval for testing. By "file is present" I mean, that file_contents is present in the eval. Additionally, we should in the streamlit dashboard show cases where getting a valid attempt is a challenge, so we can review those cases more easily and throw them out if they're bogus. Maybe a special tab/page in the dashboard for this purpose. Across all runs / cases, what the most consistently problematic cases are. Pop one open to see the case formatted json with all the user/assistant turns.
+When you run an evaluation, every detail is stored in the database—including the raw, unmodified output from the model. The replay feature takes advantage of this by pulling that raw output and feeding it into a *different* diffing algorithm. This lets you isolate the performance of the diffing logic itself. We can see if a new algorithm is better at applying the exact same set of diffs that a model generated in a previous run.
+
+This process is blazingly fast and free, as it completely bypasses the need to make new API calls. It ensures a true apples-to-apples comparison between diffing strategies, since the model's output—the "ground truth" for the evaluation—remains identical.
+
+Here’s an example of how you would replay a previous run with a new diffing algorithm:
+
+```shell
+cd evals && npm run diff-eval -- --replay-run-id 9902189e-63a8-4210-a4fc-fe59e2eaf2c2 --diff-apply-file diff-06-23-25 --verbose
+```
+
+In this command:
+-   `--replay-run-id` specifies the original run we want to use as our ground truth.
+-   `--diff-apply-file` tells the script to use the new diffing logic from the `diff-06-23-25.ts` file.
+
+The script will then create a new run in the database that mirrors the original, but with the results of applying the new diffing algorithm. This allows for a direct comparison in the dashboard, helping us quickly see which of our diffing strategies is the most robust.

evals/diff-edits/TestRunner.ts

@@ -1,7 +1,13 @@
 import { runSingleEvaluation, TestInput, TestResult } from "./ClineWrapper"
+import { parseAssistantMessageV2, AssistantMessageContent } from "./parsing/parse-assistant-message-06-06-25"
+import { constructNewFileContent as constructNewFileContent_06_06_25 } from "./diff-apply/diff-06-06-25"
+import { constructNewFileContent as constructNewFileContent_06_23_25 } from "./diff-apply/diff-06-23-25"
+import { constructNewFileContent as constructNewFileContent_06_25_25 } from "./diff-apply/diff-06-25-25"
+import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./diff-apply/diff-06-26-25"
+import { constructNewFileContent as constructNewFileContentV3 } from "../../src/core/assistant-message/diff"
 import { basicSystemPrompt } from "./prompts/basicSystemPrompt-06-06-25"
 import { claude4SystemPrompt } from "./prompts/claude4SystemPrompt-06-06-25"
-import { formatResponse } from "./helpers"
+import { formatResponse, log } from "./helpers"
 import { Anthropic } from "@anthropic-ai/sdk"
 import * as fs from "fs"
 import * as path from "path"
@@ -18,6 +24,10 @@ import {
 	insertResult,
 	DatabaseClient,
 	CreateResultInput,
+	getResultsByRun,
+	getCaseById,
+	getFileByHash,
+	getBenchmarkRun,
 } from "./database"
 
 // Load environment variables from .env file
@@ -30,12 +40,6 @@ const encoding = get_encoding("cl100k_base");
 
 let openRouterModelDataGlobal: Record<string, EvalOpenRouterModelInfo> = {}; // Global to store fetched data
 
-function log(isVerbose: boolean, message: string) {
-	if (isVerbose) {
-		console.log(message)
-	}
-}
-
 const systemPromptGeneratorLookup: Record<string, ConstructSystemPromptFn> = {
 	basicSystemPrompt: basicSystemPrompt,
 	claude4SystemPrompt: claude4SystemPrompt,
@@ -184,6 +188,78 @@ class NodeTestRunner {
 		log(isVerbose, `✓ Created ${this.caseIdMap.size} database case records`);
 	}
 
+	/**
+	 * Store replay result in database, copying original data but with new diffing results
+	 */
+	async storeReplayResultInDatabase(replayResult: TestResult, originalResult: any, testId: string, newCaseId: string): Promise<void> {
+		if (!this.currentRunId || !this.processingFunctionsHash) {
+			return; // Skip if database not initialized
+		}
+
+		try {
+			// Map error string to error enum (simple mapping)
+			const errorEnum = this.mapErrorToEnum(replayResult.error);
+
+			// Store diff edit content if available
+			let fileEditedHash: string | undefined;
+			if (replayResult.diffEdit) {
+				fileEditedHash = await upsertFile({
+					filepath: `diff-edit-${testId}`,
+					content: replayResult.diffEdit
+				});
+			}
+
+			// Calculate basic metrics from diff edit if available
+			let numEdits = 0;
+			let numLinesAdded = 0;
+			let numLinesDeleted = 0;
+			
+			if (replayResult.diffEdit) {
+				// Simple parsing to count edits - count SEARCH/REPLACE blocks
+				const searchBlocks = (replayResult.diffEdit.match(/------- SEARCH/g) || []).length;
+				numEdits = searchBlocks;
+				
+				// Count added/deleted lines (rough approximation)
+				const lines = replayResult.diffEdit.split('\n');
+				for (const line of lines) {
+					if (line.startsWith('+') && !line.startsWith('+++')) {
+						numLinesAdded++;
+					} else if (line.startsWith('-') && !line.startsWith('---')) {
+						numLinesDeleted++;
+					}
+				}
+			}
+
+			// Copy original result data but update replay-specific fields
+			const resultInput: CreateResultInput = {
+				run_id: this.currentRunId, // New run ID
+				case_id: newCaseId, // New case ID
+				model_id: originalResult.model_id, // Copy from original
+				processing_functions_hash: this.processingFunctionsHash, // New processing functions
+				succeeded: replayResult.success && (replayResult.diffEditSuccess ?? false), // New result
+				error_enum: errorEnum, // New error if any
+				num_edits: numEdits || originalResult.num_edits, // New or original
+				num_lines_deleted: numLinesDeleted || originalResult.num_lines_deleted, // New or original
+				num_lines_added: numLinesAdded || originalResult.num_lines_added, // New or original
+				// Copy timing and cost data from original (since we didn't make API calls)
+				time_to_first_token_ms: originalResult.time_to_first_token_ms,
+				time_to_first_edit_ms: originalResult.time_to_first_edit_ms,
+				time_round_trip_ms: originalResult.time_round_trip_ms,
+				cost_usd: originalResult.cost_usd,
+				completion_tokens: originalResult.completion_tokens,
+				// Use original model output (since we're replaying)
+				raw_model_output: originalResult.raw_model_output,
+				file_edited_hash: fileEditedHash || originalResult.file_edited_hash,
+				parsed_tool_call_json: replayResult.toolCalls ? JSON.stringify(replayResult.toolCalls) : originalResult.parsed_tool_call_json
+			};
+
+			await insertResult(resultInput);
+		} catch (error) {
+			console.error(`Failed to store replay result in database for ${testId}:`, error);
+			// Continue execution - don't fail the test run
+		}
+	}
+
 	/**
 	 * Store test result in database
 	 */
@@ -394,6 +470,144 @@ class NodeTestRunner {
 		}
 	}
 
+	async runDatabaseReplay(replayRunId: string, diffApplyFile: string, isVerbose: boolean) {
+		log(isVerbose, `Starting database replay for run_id: ${replayRunId}`)
+		log(isVerbose, `Using diff apply file: ${diffApplyFile}`)
+
+		// 1. Get the correct diffing function
+		const diffEditingFunctions: Record<string, any> = {
+			"diff-06-06-25": constructNewFileContent_06_06_25,
+			"diff-06-23-25": constructNewFileContent_06_23_25,
+			"diff-06-25-25": constructNewFileContent_06_25_25,
+			"diff-06-26-25": constructNewFileContent_06_26_25,
+			constructNewFileContentV3: constructNewFileContentV3,
+		}
+		const constructNewFileContent = diffEditingFunctions[diffApplyFile]
+
+		if (!constructNewFileContent) {
+			throw new Error(`Could not find diff apply function for: ${diffApplyFile}`)
+		}
+		log(isVerbose, `Successfully loaded diff apply function: ${diffApplyFile}`)
+
+		// 2. Fetch original run data
+		const originalResults = await getResultsByRun(replayRunId)
+		if (originalResults.length === 0) {
+			throw new Error(`No results found for run_id: ${replayRunId}`)
+		}
+		log(isVerbose, `Found ${originalResults.length} results to replay.`)
+
+		const originalRun = await getBenchmarkRun(replayRunId)
+		if (!originalRun) {
+			throw new Error(`Could not find original run with id ${replayRunId}`)
+		}
+
+		// 3. Create a new benchmark run for the replay
+		const replayRunDescription = `Replay of run ${replayRunId} using ${diffApplyFile}`
+		this.currentRunId = await createBenchmarkRun({
+			description: replayRunDescription,
+			system_prompt_hash: originalRun.system_prompt_hash,
+		})
+		log(isVerbose, `Created new run for replay: ${this.currentRunId}`)
+
+		// 4. Set up processing functions for the new run
+		this.processingFunctionsHash = await upsertProcessingFunctions({
+			name: `replay-${diffApplyFile}`,
+			parsing_function: "parseAssistantMessageV2",
+			diff_edit_function: diffApplyFile,
+		})
+
+		// 5. Process each result from the original run
+		let replayedCount = 0
+		const caseIdMirror: Map<string, string> = new Map()
+
+		for (const originalResult of originalResults) {
+			// 5a. Basic validation to ensure we can even process this
+			if (!originalResult.case_id) {
+				log(isVerbose, `Skipping result ${originalResult.result_id} due to missing case_id.`)
+				continue
+			}
+
+			// 5b. Mirror the case for the new run, reusing if already created
+			let newCaseId = caseIdMirror.get(originalResult.case_id)
+			if (!newCaseId) {
+				const originalCase = await getCaseById(originalResult.case_id)
+				if (!originalCase) {
+					log(isVerbose, `Skipping result ${originalResult.result_id} because original case could not be found.`)
+					continue
+				}
+				newCaseId = await createCase({
+					run_id: this.currentRunId,
+					description: `Replay of case ${originalCase.case_id} from run ${replayRunId}`,
+					system_prompt_hash: originalCase.system_prompt_hash,
+					task_id: originalCase.task_id,
+					tokens_in_context: originalCase.tokens_in_context,
+					file_hash: originalCase.file_hash,
+				})
+				caseIdMirror.set(originalResult.case_id, newCaseId)
+			}
+
+			// 5c. Determine if the original attempt was a "valid attempt"
+			const isValidOriginalAttempt = originalResult.error_enum === null || originalResult.error_enum === 3 // 3 is diff_edit_error
+
+			const newResultInput: CreateResultInput = {
+				...(originalResult as any),
+				run_id: this.currentRunId,
+				case_id: newCaseId,
+				processing_functions_hash: this.processingFunctionsHash,
+			}
+			delete (newResultInput as any).result_id
+
+			if (isValidOriginalAttempt) {
+				// This was a valid attempt. Re-run the diff algorithm.
+				const originalCase = await getCaseById(originalResult.case_id)
+				if (!originalCase) {
+					log(isVerbose, `  [WARN] Replay for result ${originalResult.result_id}: Could not find original case. Copying original result.`)
+					newResultInput.succeeded = originalResult.succeeded
+					newResultInput.error_enum = originalResult.error_enum
+				} else {
+					const originalFile = originalCase.file_hash ? await getFileByHash(originalCase.file_hash) : null
+					const parsedToolCall = originalResult.parsed_tool_call_json ? JSON.parse(originalResult.parsed_tool_call_json)[0] : null
+					const diffContent = parsedToolCall?.input?.diff
+
+					if (originalFile && diffContent) {
+						let diffSuccess = false
+						try {
+							await constructNewFileContent(diffContent, originalFile.content, true)
+							diffSuccess = true
+							log(isVerbose, `  [OK] Replay for task ${originalCase.task_id}: Diff applied successfully.`)
+						} catch (e) {
+							diffSuccess = false
+							log(isVerbose, `  [FAIL] Replay for task ${originalCase.task_id}: New diff algorithm failed.`)
+						}
+						newResultInput.succeeded = diffSuccess
+						newResultInput.error_enum = diffSuccess ? undefined : 3 // 3 = diff_edit_error
+					} else {
+						// Something is wrong with the ground truth data, just copy it.
+						log(
+							isVerbose,
+							`  [WARN] Replay for task ${originalCase.task_id}: Valid original attempt but missing file or diff content. Copying original result.`,
+						)
+						newResultInput.succeeded = originalResult.succeeded
+						newResultInput.error_enum = originalResult.error_enum
+					}
+				}
+			} else {
+				// This was not a valid attempt. Just copy the original result's outcome.
+				log(isVerbose, `  [SKIP] Replay for task ${originalResult.case_id}: Invalid original attempt. Copying original result.`)
+				newResultInput.succeeded = originalResult.succeeded
+				newResultInput.error_enum = originalResult.error_enum
+			}
+
+			await insertResult(newResultInput)
+			replayedCount++
+		}
+
+		log(isVerbose, `\n✓ Database replay completed successfully.`)
+		log(isVerbose, `  Total original results: ${originalResults.length}`)
+		log(isVerbose, `  Total replayed results: ${replayedCount}`)
+		log(isVerbose, `  New run ID: ${this.currentRunId}`)
+	}
+
 	/**
 	 * Run a single test example
 	 */
@@ -420,6 +634,8 @@ class NodeTestRunner {
 			diffEditFunction: testConfig.diff_edit_function,
 			thinkingBudgetTokens: testConfig.thinking_tokens_budget,
 			originalDiffEditToolCallMessage: testConfig.replay ? testCase.original_diff_edit_tool_call_message : undefined,
+			diffApplyFile: testConfig.diff_apply_file,
+			isVerbose: isVerbose,
 		}
 
 		if (isVerbose) {
@@ -586,8 +802,8 @@ class NodeTestRunner {
 					log(isVerbose, `Warning: Failed to store result in database: ${error}`);
 				}
 				
-				// Safety check to prevent infinite loops - limit to 10 attempts per valid attempt requested
-				if (totalAttempts >= testConfig.number_of_runs * 10) {
+				// Safety check to prevent infinite loops - use configurable max attempts limit
+				if (totalAttempts >= testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts (${totalAttempts}) for test case ${testCase.test_id}. Only got ${validAttempts}/${testConfig.number_of_runs} valid attempts.`);
 					break;
 				}
@@ -706,12 +922,16 @@ async function main() {
 		.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 		.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 		.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+		.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 		.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 		.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
-		.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
+		.option("--diff-edit-function <name>", "The diff editing function to use", "diff-06-26-25")
 		.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
 		.option("--parallel", "Run tests in parallel", false)
 		.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
+		.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
+		.option("--diff-apply-file <filename>", "The name of the diff apply file to use for the replay")
+		.option("--save-locally", "Save results to local JSON files in addition to database", false)
 		.option("-v, --verbose", "Enable verbose logging", false)
 		.option("--max-concurrency <number>", "Maximum number of parallel requests", "80")
 
@@ -722,6 +942,7 @@ async function main() {
 	const isVerbose = options.verbose
 	const testPath = options.testPath
 	const outputPath = options.outputPath
+	const saveLocally = options.saveLocally
 	const maxConcurrency = parseInt(options.maxConcurrency, 10);
 
 	// Parse model IDs from comma-separated string
@@ -733,6 +954,22 @@ async function main() {
 
 	const validAttemptsPerCase = parseInt(options.validAttemptsPerCase, 10);
 	
+	// Compute dynamic default for max attempts: 10x valid attempts if not specified
+	const maxAttemptsPerCase = options.maxAttemptsPerCase 
+		? parseInt(options.maxAttemptsPerCase, 10)
+		: validAttemptsPerCase * 10;
+
+	const runner = new NodeTestRunner(options.replay || !!options.replayRunId)
+
+	if (options.replayRunId) {
+		if (!options.diffApplyFile) {
+			console.error("Error: --diff-apply-file is required when using --replay-run-id")
+			process.exit(1)
+		}
+		await runner.runDatabaseReplay(options.replayRunId, options.diffApplyFile, isVerbose)
+		return
+	}
+	
 	try {
 		const startTime = Date.now()
 
@@ -826,6 +1063,7 @@ async function main() {
 					model_id: modelId,
 					system_prompt_name: options.systemPromptName,
 					number_of_runs: validAttemptsPerCase,
+					max_attempts_per_case: maxAttemptsPerCase,
 					parsing_function: options.parsingFunction,
 					diff_edit_function: options.diffEditFunction,
 					thinking_tokens_budget: parseInt(options.thinkingBudget, 10),
@@ -893,7 +1131,7 @@ async function main() {
 
 			remainingTasks = remainingTasks.filter(task => {
 				const taskId = `${task.modelId}-${task.testCase.test_id}`;
-				if (taskStates[taskId].total >= validAttemptsPerCase * 10) {
+				if (taskStates[taskId].total >= task.testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts for ${task.testCase.test_id} with ${task.modelId}.`);
 					return false;
 				}
@@ -918,6 +1156,12 @@ async function main() {
 		const durationSeconds = ((endTime - startTime) / 1000).toFixed(2)
 		log(isVerbose, `\n-Total execution time: ${durationSeconds} seconds`)
 
+		// Save results locally if requested
+		if (saveLocally) {
+			runner.saveTestResults(results, outputPath);
+			log(isVerbose, `✓ Results also saved to JSON files in ${outputPath}`);
+		}
+
 		log(isVerbose, `\n✓ All results stored in database. Use the dashboard to view results.`)
 	} catch (error) {
 		console.error("\nError running tests:", error)

evals/diff-edits/dashboard/app.py

@@ -420,21 +420,33 @@ def render_model_comparison_cards(model_performance):
                 metric_col1, metric_col2, metric_col3, metric_col4 = st.columns(4)
                 
                 with metric_col1:
-                    st.metric("Avg Latency", f"{model['avg_round_trip_ms']:.0f}ms")
+                    if pd.notna(model['avg_round_trip_ms']):
+                        st.metric("Avg Latency", f"{model['avg_round_trip_ms']:.0f}ms")
+                    else:
+                        st.metric("Avg Latency", "N/A")
                 
                 with metric_col2:
-                    st.metric("Avg Cost", f"${model['avg_cost']:.4f}")
+                    if pd.notna(model['avg_cost']):
+                        st.metric("Avg Cost", f"${model['avg_cost']:.4f}")
+                    else:
+                        st.metric("Avg Cost", "N/A")
                 
                 with metric_col3:
                     st.metric("Valid Results", f"{model['total_results']}")
                 
                 with metric_col4:
-                    st.metric("First Token", f"{model['avg_first_token_ms']:.0f}ms")
+                    if pd.notna(model['avg_first_token_ms']):
+                        st.metric("First Token", f"{model['avg_first_token_ms']:.0f}ms")
+                    else:
+                        st.metric("First Token", "N/A")
             
             with col2:
                 st.write("")  # Add some spacing
                 if st.button(f"Drill Down", key=f"drill_{model['model_id']}", use_container_width=True):
                     st.session_state.drill_down_model = model['model_id']
+                    # Update URL with model_id for drill down
+                    st.query_params["model_id"] = model['model_id']
+                    st.rerun()
             
             st.divider()  # Add a divider between models
 
@@ -835,6 +847,11 @@ def main():
     if 'selected_run_id' not in st.session_state:
         st.session_state.selected_run_id = None
     
+    # Handle URL parameters for direct linking
+    query_params = st.query_params
+    url_run_id = query_params.get("run_id")
+    url_model_id = query_params.get("model_id")
+    
     # Load all runs for sidebar
     all_runs = load_all_runs()
     
@@ -842,6 +859,18 @@ def main():
         st.error("No evaluation runs found in the database.")
         st.stop()
     
+    # Set initial run selection from URL or default to latest
+    if url_run_id and url_run_id in all_runs['run_id'].values:
+        if st.session_state.selected_run_id != url_run_id:
+            st.session_state.selected_run_id = url_run_id
+            st.session_state.drill_down_model = None  # Reset drill down when changing runs via URL
+    elif st.session_state.selected_run_id is None:
+        st.session_state.selected_run_id = all_runs.iloc[0]['run_id']  # Default to latest
+    
+    # Set drill down model from URL
+    if url_model_id and st.session_state.selected_run_id == url_run_id:
+        st.session_state.drill_down_model = url_model_id
+    
     # Sidebar for run selection
     with st.sidebar:
         st.markdown("## 📊 Evaluation Runs")
@@ -887,6 +916,10 @@ def main():
         if run_ids[selected_run_idx] != st.session_state.selected_run_id:
             st.session_state.selected_run_id = run_ids[selected_run_idx]
             st.session_state.drill_down_model = None  # Reset drill down when changing runs
+            # Update URL with new run_id
+            st.query_params["run_id"] = st.session_state.selected_run_id
+            if "model_id" in st.query_params:
+                del st.query_params["model_id"]  # Clear model_id when changing runs
             st.rerun()
         
         # Show run details in sidebar
@@ -897,6 +930,67 @@ def main():
         st.markdown(f"**Created:** {selected_run['created_at']}")
         if selected_run['description']:
             st.markdown(f"**Description:** {selected_run['description']}")
+        
+        # Show shareable URL
+        st.markdown("---")
+        st.markdown("### 🔗 Share This View")
+        
+        # Build current URL
+        # Dynamically derive the base URL
+        try:
+            # For older Streamlit versions
+            server_address = st.server.server_address
+            server_port = st.server.server_port
+        except AttributeError:
+            # Fallback for newer Streamlit versions where st.server is removed
+            # We can't reliably get the server address/port from within the script anymore.
+            # We'll default to localhost and the default port.
+            # The user can see the correct network URL in the terminal.
+            server_address = "localhost"
+            server_port = 8501
+        
+        base_url = f"http://{server_address}:{server_port}"
+        current_url = f"{base_url}/?run_id={st.session_state.selected_run_id}"
+        if st.session_state.drill_down_model:
+            current_url += f"&model_id={st.session_state.drill_down_model}"
+        
+        st.markdown("**Current URL:**")
+        st.code(current_url, language=None)
+        
+        # Copy button using HTML/JS
+        copy_button_html = f"""
+        <button onclick="copyToClipboard('{current_url}')" style="
+            padding: 8px 16px; 
+            border-radius: 5px; 
+            border: 1px solid #ccc; 
+            background: #f0f2f6;
+            cursor: pointer;
+            font-size: 14px;
+            margin-top: 5px;
+        ">📋 Copy Link</button>
+        <script>
+            function copyToClipboard(text) {{
+                navigator.clipboard.writeText(text).then(function() {{
+                    // Success feedback
+                    event.target.innerText = '✅ Copied!';
+                    event.target.style.backgroundColor = '#d4edda';
+                    setTimeout(() => {{ 
+                        event.target.innerText = '📋 Copy Link'; 
+                        event.target.style.backgroundColor = '#f0f2f6';
+                    }}, 2000);
+                }}, function(err) {{
+                    // Error feedback
+                    event.target.innerText = '❌ Failed';
+                    event.target.style.backgroundColor = '#f8d7da';
+                    setTimeout(() => {{ 
+                        event.target.innerText = '📋 Copy Link'; 
+                        event.target.style.backgroundColor = '#f0f2f6';
+                    }}, 2000);
+                }});
+            }}
+        </script>
+        """
+        st.components.v1.html(copy_button_html, height=50)
     
     # Load data for selected run
     current_run, model_performance = load_run_comparison(st.session_state.selected_run_id)
@@ -914,6 +1008,9 @@ def main():
         with col1:
             if st.button("Back to Overview", use_container_width=True):
                 st.session_state.drill_down_model = None
+                # Clear model_id from URL when going back to overview
+                if "model_id" in st.query_params:
+                    del st.query_params["model_id"]
                 st.rerun()
         
         render_detailed_analysis(current_run['run_id'], st.session_state.drill_down_model)

evals/diff-edits/database.md

@@ -33,7 +33,7 @@ This is the most granular and important table in the database. A `result` repres
 
 -   **Purpose**: To store the detailed outcome of every single model attempt, providing the raw data for all quantitative and qualitative analysis.
 -   **Key Columns**:
-    -   `result_id`: A unique identifier for the individual attempt.
+    -   `result_id`: The primary key for the result.
     -   `run_id`, `case_id`, `model_id`, `processing_functions_hash`: A set of foreign keys that precisely situate this result within the context of a specific run, case, model, and set of helper functions.
     -   `succeeded`: A boolean indicating if the generated diff was applied successfully.
     -   `error_enum`: A numeric code representing the specific type of error if the attempt failed (e.g., `1` for `no_tool_calls`, `7` for `wrong_file_edited`).
@@ -82,3 +82,15 @@ This relational schema provides a powerful foundation for sophisticated analysis
 -   "Which of our internal diffing algorithms is the most robust against a wide range of model-generated edits?"
 
 Ultimately, this data model enables us to move from simply *measuring* performance to truly *understanding* it, providing the insights needed to build more capable and reliable AI engineering systems.
+
+---
+
+## Viewing the Full Schema
+
+To see the most up-to-date and detailed schema for the database, you can use the `sqlite3` command-line tool. From the `evals/diff-edits` directory, run the following command:
+
+```bash
+sqlite3 evals.db .schema
+```
+
+This will print the complete `CREATE TABLE` statements for all tables in the database, providing a definitive reference for the database structure.

evals/diff-edits/diff-apply/diff-06-23-25.ts

@@ -0,0 +1,827 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH$/
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE$/
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. For each position in the original content:
+ *    - Checks if the next line matches the start anchor
+ *    - If it does, jumps ahead by the search block size
+ *    - Checks if that line matches the end anchor
+ *    - All comparisons are done after trimming whitespace
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Look for matching start and end anchors
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		// Check if first line matches
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue
+		}
+
+		// Check if last line matches at the expected position
+		if (originalLines[i + searchBlockSize - 1].trim() !== lastLineSearch) {
+			continue
+		}
+
+		// Calculate exact character positions
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+
+		return [matchStartIndex, matchEndIndex]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<string> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ start: number; end: number; content: string }> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex] = blockMatch
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	return result
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/diff-apply/diff-06-25-25.ts

@@ -0,0 +1,829 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH>?$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH>?$/
+
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE>?$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE>?$/
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. For each position in the original content:
+ *    - Checks if the next line matches the start anchor
+ *    - If it does, jumps ahead by the search block size
+ *    - Checks if that line matches the end anchor
+ *    - All comparisons are done after trimming whitespace
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Look for matching start and end anchors
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		// Check if first line matches
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue
+		}
+
+		// Check if last line matches at the expected position
+		if (originalLines[i + searchBlockSize - 1].trim() !== lastLineSearch) {
+			continue
+		}
+
+		// Calculate exact character positions
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+
+		return [matchStartIndex, matchEndIndex]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<string> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<string>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ start: number; end: number; content: string }> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex] = blockMatch
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	return result
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/diff-apply/diff-06-26-25.ts

@@ -0,0 +1,960 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH>?$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH>?$/
+
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE>?$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE>?$/
+
+// Similarity thresholds for block anchor fallback matching
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.0
+
+/**
+ * Levenshtein distance algorithm implementation
+ */
+function levenshtein(a: string, b: string): number {
+	// Handle empty strings
+	if (a === "" || b === "") {
+		return Math.max(a.length, b.length)
+	}
+	const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+		Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+	)
+
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1
+			matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+		}
+	}
+	return matrix[a.length][b.length]
+}
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors,
+ * with similarity checking to prevent false positives.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. Collects all candidate positions where both anchors match
+ * 4. Uses levenshtein distance to calculate similarity of middle lines
+ * 5. Returns match only if similarity meets threshold requirements
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ * - The middle content is reasonably similar (prevents false positives)
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Collect all candidate positions
+	const candidates: number[] = []
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		if (originalLines[i].trim() === firstLineSearch && originalLines[i + searchBlockSize - 1].trim() === lastLineSearch) {
+			candidates.push(i)
+		}
+	}
+
+	// Return immediately if no candidates
+	if (candidates.length === 0) {
+		return false
+	}
+
+	// Handle single candidate scenario (using relaxed threshold)
+	if (candidates.length === 1) {
+		const i = candidates[0]
+		let similarity = 0
+		let linesToCheck = searchBlockSize - 2
+
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += (1 - distance / maxLen) / linesToCheck
+
+			// Exit early when threshold is reached
+			if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+				break
+			}
+		}
+
+		if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1
+			}
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchBlockSize; k++) {
+				matchEndIndex += originalLines[i + k].length + 1
+			}
+			return [matchStartIndex, matchEndIndex, similarity]
+		}
+		return false
+	}
+
+	// Calculate similarity for multiple candidates
+	let bestMatchIndex = -1
+	let maxSimilarity = -1
+
+	for (const i of candidates) {
+		let similarity = 0
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += 1 - distance / maxLen
+		}
+		similarity /= searchBlockSize - 2 // Average similarity
+
+		if (similarity > maxSimilarity) {
+			maxSimilarity = similarity
+			bestMatchIndex = i
+		}
+	}
+
+	// Threshold judgment
+	if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD) {
+		const i = bestMatchIndex
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+		return [matchStartIndex, matchEndIndex, maxSimilarity]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<any> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<any>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<{
+	content: string;
+	replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}>;
+}> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+	let matchMethod = ""
+	let similarityScore = -1.0
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+					matchMethod = "empty_new_file"
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+					matchMethod = "exact_match"
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+						matchMethod = "line_trimmed_fallback"
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex, similarityScore] = blockMatch
+							matchMethod = "block_anchor_fallback"
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								matchMethod = "full_file_search"
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			if (searchMatchIndex === -1) {
+				throw new Error(
+					`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`,
+				)
+			}
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			similarityScore = -1.0
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	// For testing - return debug info
+	return {
+		content: result,
+		replacements: replacements
+	}
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex, /* ignore similarity */] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/helpers.ts

@@ -23,3 +23,9 @@ export const formatResponse = {
 		return formatImagesIntoBlocks(images)
 	},
 }
+
+export function log(isVerbose: boolean, message: string) {
+	if (isVerbose) {
+		console.log(message)
+	}
+}

evals/diff-edits/types.ts

@@ -29,10 +29,12 @@ export interface TestConfig {
 	model_id: string
 	system_prompt_name: string
 	number_of_runs: number
+	max_attempts_per_case: number
 	parsing_function: string
 	diff_edit_function: string
 	thinking_tokens_budget: number
 	replay: boolean
+	diff_apply_file?: string
 }
 
 export interface SystemPromptDetails {
@@ -80,6 +82,7 @@ export interface TestResult {
 	diffEdit?: string
 	toolCalls?: ExtractedToolCall[]
 	diffEditSuccess?: boolean
+	replacementData?: any
 	error?: string
 	errorString?: string
 }
@@ -100,4 +103,6 @@ export interface TestInput {
 	diffEditFunction: string
 	thinkingBudgetTokens: number
 	originalDiffEditToolCallMessage?: string
+	diffApplyFile?: string
+	isVerbose: boolean
 }

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.17.15",
+	"version": "3.19.6",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -330,20 +330,23 @@
 		"watch:esbuild": "node esbuild.js --watch",
 		"watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
 		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.js --production",
-		"protos": "node proto/build-proto.js && node scripts/generate-server-setup.mjs && node scripts/generate-host-bridge-client.mjs",
+		"protos": "node scripts/build-proto.mjs && node scripts/generate-server-setup.mjs && node scripts/generate-host-bridge-client.mjs",
 		"postprotos": "prettier src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --log-level warn",
+		"clean": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"compile-tests": "node ./scripts/build-tests.js",
 		"watch-tests": "tsc -p . -w --outDir out",
-		"pretest": "npm run compile-tests && npm run compile && npm run compile-standalone && npm run lint",
-		"check-types": "npm run protos && tsc --noEmit",
+		"check-types": "npm run protos && npx tsc --noEmit && cd webview-ui && npx tsc -b --noEmit",
 		"lint": "eslint src --ext ts && eslint webview-ui/src --ext ts && buf lint && cd webview-ui && npm run lint",
 		"format": "prettier . --check",
 		"format:fix": "prettier . --write",
+		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
 		"test": "npm-run-all test:unit test:integration",
 		"test:ci": "node scripts/test-ci.js",
 		"test:integration": "vscode-test",
 		"test:unit": "TS_NODE_PROJECT='./tsconfig.unit-test.json' mocha",
 		"test:coverage": "vscode-test --coverage",
+		"e2e": "playwright test -c playwright.config.ts",
+		"test:e2e": "playwright install && vsce package --no-dependencies --out dist/e2e.vsix && node src/test/e2e/utils/build.js && playwright test",
 		"install:all": "npm install && cd webview-ui && npm install",
 		"dev:webview": "cd webview-ui && npm run dev",
 		"build:webview": "cd webview-ui && npm run build",
@@ -382,7 +385,8 @@
 		"@typescript-eslint/parser": "^7.18.0",
 		"@typescript-eslint/utils": "^8.33.0",
 		"@vscode/test-cli": "^0.0.10",
-		"@vscode/test-electron": "^2.4.1",
+		"@vscode/test-electron": "^2.5.2",
+		"@vscode/vsce": "^3.6.0",
 		"chai": "^4.3.10",
 		"chalk": "^5.3.0",
 		"esbuild": "^0.25.0",
@@ -391,11 +395,13 @@
 		"grpc-tools": "^1.13.0",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.1.0",
+		"minimatch": "^3.0.3",
 		"mintlify": "^4.0.515",
 		"npm-run-all": "^4.1.5",
 		"prettier": "^3.3.3",
 		"protoc-gen-ts": "^0.8.7",
 		"proxyquire": "^2.1.3",
+		"rimraf": "^6.0.1",
 		"should": "^13.2.3",
 		"sinon": "^19.0.2",
 		"ts-node": "^10.9.2",
@@ -406,8 +412,8 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.37.0",
 		"@anthropic-ai/vertex-sdk": "^0.6.4",
-		"@aws-sdk/client-bedrock-runtime": "^3.826.0",
-		"@aws-sdk/credential-providers": "^3.826.0",
+		"@aws-sdk/client-bedrock-runtime": "^3.840.0",
+		"@aws-sdk/credential-providers": "^3.840.0",
 		"@bufbuild/protobuf": "^2.2.5",
 		"@cerebras/cerebras_cloud_sdk": "^1.35.0",
 		"@google-cloud/vertexai": "^1.9.3",
@@ -422,6 +428,7 @@
 		"@opentelemetry/sdk-node": "^0.39.1",
 		"@opentelemetry/sdk-trace-node": "^1.30.1",
 		"@opentelemetry/semantic-conventions": "^1.30.0",
+		"@playwright/test": "^1.53.2",
 		"@sentry/browser": "^9.12.0",
 		"@streamparser/json": "^0.0.22",
 		"@vscode/codicons": "^0.0.36",
@@ -446,6 +453,7 @@
 		"image-size": "^2.0.2",
 		"isbinaryfile": "^5.0.2",
 		"jschardet": "^3.1.4",
+		"jwt-decode": "^4.0.0",
 		"mammoth": "^1.8.0",
 		"monaco-vscode-textmate-theme-converter": "^0.1.7",
 		"nice-grpc": "^2.1.12",

playwright.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "@playwright/test"
+
+const isGitHubAction = !!process.env.CI
+
+export default defineConfig({
+	workers: 1,
+	retries: 1,
+	testDir: "src/test/e2e",
+	timeout: 20000,
+	expect: {
+		timeout: 20000,
+	},
+	fullyParallel: true,
+	reporter: isGitHubAction ? [["github"], ["list"]] : [["list"]],
+	globalSetup: require.resolve("./src/test/e2e/utils/setup"),
+	globalTeardown: require.resolve("./src/test/e2e/utils/teardown"),
+})

proto/account.proto

@@ -1,22 +1,129 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Service for account-related operations
 service AccountService {
-    // Handles the user clicking the login link in the UI.
-    // Generates a secure nonce for state validation, stores it in secrets,
-    // and opens the authentication URL in the external browser.
-    rpc accountLoginClicked(EmptyRequest) returns (String);
+  // Handles the user clicking the login link in the UI.
+  // Generates a secure nonce for state validation, stores it in secrets,
+  // and opens the authentication URL in the external browser.
+  rpc accountLoginClicked(EmptyRequest) returns (String);
     
-    // Handles the user clicking the logout button in the UI.
-    // Clears API keys and user state.
-    rpc accountLogoutClicked(EmptyRequest) returns (Empty);
+  // Handles the user clicking the logout button in the UI.
+  // Clears API keys and user state.
+  rpc accountLogoutClicked(EmptyRequest) returns (Empty);
 
-    // Subscribe to auth callback events (when authentication tokens are received)
-    rpc subscribeToAuthCallback(EmptyRequest) returns (stream String);
+  // Subscribe to auth status update events (when authentication state changes)
+  rpc subscribeToAuthStatusUpdate(EmptyRequest) 
+      returns (stream AuthState);
+    
+  // Handles authentication state changes from the Firebase context.
+  // Updates the user info in global state and returns the updated value.
+  rpc authStateChanged(AuthStateChangedRequest) 
+      returns (AuthState);
+    
+  // Fetches all user credits data
+  // (balance, usage transactions, payment transactions)
+  rpc getUserCredits(EmptyRequest) returns (UserCreditsData);
+
+  rpc getOrganizationCredits(GetOrganizationCreditsRequest) returns (OrganizationCreditsData);
+
+  // Fetches all user organizations data
+  // Returns a list of UserOrganization objects
+  rpc getUserOrganizations(EmptyRequest) returns (UserOrganizationsResponse);
+
+  rpc setUserOrganization(UserOrganizationUpdateRequest) returns (Empty);
 }
+
+message AuthStateChangedRequest {
+  Metadata metadata = 1;
+  UserInfo user = 2;
+}
+
+message AuthState {
+  optional UserInfo user = 1;
+}
+
+// User's information
+message UserInfo {
+  string uid = 1;
+  optional string display_name = 2;
+  optional string email = 3;
+  optional string photo_url = 4;
+}
+
+message UserOrganization {
+  bool active = 1;
+  string member_id = 2;
+  string name = 3;
+  string organization_id = 4;
+  repeated string roles = 5; // ["admin", "member", "owner"]
+}
+
+message UserOrganizationsResponse {
+  repeated UserOrganization organizations = 1;
+}
+
+message UserOrganizationUpdateRequest {
+  optional string organization_id = 1;
+}
+
+message UserCreditsData {
+  UserCreditsBalance balance = 1;
+  repeated UsageTransaction usage_transactions = 2;
+  repeated PaymentTransaction payment_transactions = 3;
+}
+
+message GetOrganizationCreditsRequest {
+  string organization_id = 1;
+}
+
+message OrganizationCreditsData {
+  UserCreditsBalance balance = 1;
+  string organization_id = 2;
+  repeated OrganizationUsageTransaction usage_transactions = 3;
+}
+
+message UserCreditsBalance {
+  double current_balance = 1;
+}
+
+message UsageTransaction {
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
+}
+
+message PaymentTransaction {
+  string paid_at = 1;
+  string creator_id = 2;
+  int32 amount_cents = 3;
+  double credits = 4;
+}
+
+message OrganizationUsageTransaction {
+  string ai_inference_provider_name = 1;
+  string ai_model_name = 2;
+  string ai_model_type_name = 3;
+  int32 completion_tokens = 4;
+  double cost_usd = 5;
+  string created_at = 6;
+  double credits_used = 7;
+  string generation_id = 8;
+  string organization_id = 9;
+  int32 prompt_tokens = 10;
+  int32 total_tokens = 11;
+  string user_id = 12;
+}

proto/browser.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service BrowserService {
   rpc getBrowserConnectionInfo(EmptyRequest) returns (BrowserConnectionInfo);
   rpc testBrowserConnection(StringRequest) returns (BrowserConnection);

proto/checkpoints.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service CheckpointsService {
   rpc checkpointDiff(Int64Request) returns (Empty);
   rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);

proto/file.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Service for file-related operations
 service FileService {
   // Copies text to clipboard
@@ -29,9 +28,6 @@ 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);
-
   // Select images and other files from the file system and returns as data URLs & paths respectively
   rpc selectFiles(BooleanRequest) returns (StringArrays);
   

proto/host/diff.proto

@@ -0,0 +1,39 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+// Provides methods for diff views.
+service DiffService {
+  // Open the diff view/editor.
+  rpc openDiff(OpenDiffRequest) returns (OpenDiffResponse);
+  rpc replaceText(ReplaceTextRequest) returns (ReplaceTextResponse);
+}
+
+message OpenDiffRequest {
+  optional cline.Metadata metadata = 1;
+  // The absolute path of the document being edited.
+  optional string path = 2;
+  // The new content for the file.
+  optional string content = 3;
+}
+
+message OpenDiffResponse {
+  // A unique identifier for the diff view that was opened.
+  optional string diff_id = 1;
+}
+
+message ReplaceTextRequest {
+  optional cline.Metadata metadata = 1;
+  optional string diff_id = 2;
+  optional string content = 3;
+  optional int32 start_line = 4;
+  optional int32 end_line = 5;
+}
+
+message ReplaceTextResponse {
+  // TBD
+}

proto/host/env.proto

@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+// Provides methods for working with the user's environment.
+service EnvService {
+  // Writes text to the system clipboard.
+  rpc clipboardWriteText(cline.StringRequest) returns (cline.Empty);
+
+  // Reads text from the system clipboard.
+  rpc clipboardReadText(cline.EmptyRequest) returns (cline.String);
+
+  // Opens a URL in the user's default browser or application.
+  rpc openExternal(cline.StringRequest) returns (cline.Empty);
+}

proto/host/uri.proto

@@ -1,36 +0,0 @@
-syntax = "proto3";
-
-package host;
-option java_package = "bot.cline.host.proto";
-option java_multiple_files = true;
-
-import "common.proto";
-
-// UriService provides methods for working with URIs in the IDE
-service UriService {
-  // Create a new file URI from a file path
-  rpc file(cline.StringRequest) returns (Uri);
-  
-  // Join a URI with additional path segments
-  rpc joinPath(JoinPathRequest) returns (Uri);
-  
-  // Parse a string URI into a Uri object
-  rpc parse(cline.StringRequest) returns (Uri);
-}
-
-// Uri represents a URI in the IDE
-message Uri {
-  string scheme = 1;
-  string authority = 2;
-  string path = 3;
-  string query = 4;
-  string fragment = 5;
-  string fs_path = 6;
-}
-
-// Request for joining path segments to a URI
-message JoinPathRequest {
-  cline.Metadata metadata = 1;
-  Uri base = 2;
-  repeated string path_segments = 3;
-}

proto/host/window.proto

@@ -0,0 +1,73 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+// Provides methods for working with IDE windows and editors.
+service WindowService {
+  // Opens a text document in the editor and returns editor information.
+  rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
+  rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
+  rpc showMessage(ShowMessageRequest) returns (SelectedResponse);
+}
+
+message ShowTextDocumentRequest {
+  cline.Metadata metadata = 1;
+  string path = 2;
+  optional ShowTextDocumentOptions options = 3;
+}
+
+// See https://code.visualstudio.com/api/references/vscode-api#TextDocumentShowOptions
+message ShowTextDocumentOptions {
+  optional bool preview = 1;
+  optional bool preserve_focus = 2;
+  optional int32 view_column = 3;
+}
+
+message TextEditorInfo {
+  string document_path = 1;
+  optional int32 view_column = 2;
+  bool is_active = 3;
+}
+
+message ShowOpenDialogueRequest {
+  cline.Metadata metadata = 1;
+  optional bool can_select_many = 2;
+  optional string open_label = 3;
+  optional ShowOpenDialogueFilterOption filters = 4;
+}
+
+message ShowOpenDialogueFilterOption {
+  repeated string files = 1;
+}
+
+message SelectedResources {
+  repeated string paths = 1;
+}
+
+enum ShowMessageType {
+  ERROR = 0;
+  INFORMATION = 1;
+  WARNING = 2;
+}
+
+message ShowMessageRequest {
+  cline.Metadata metadata = 1;
+  ShowMessageType type = 2;
+  string message = 3;
+  optional ShowMessageRequestOptions options = 4;
+}
+
+message ShowMessageRequestOptions {
+  repeated string items = 1;
+  optional bool modal = 2;
+  optional string detail = 3;
+
+}
+
+message SelectedResponse {
+  optional string selected_option = 1;
+}

proto/host/workspace.proto

@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+// Provides methods for working with workspaces/projects.
+service WorkspaceService {
+  // Returns a list of the top level directories of the workspace.
+  rpc getWorkspacePaths(GetWorkspacePathsRequest) returns (GetWorkspacePathsResponse);
+}
+
+message GetWorkspacePathsRequest {
+  // The unique ID for the workspace/project.
+  // This is currently optional in vscode. It is required in other environments where cline is running at
+  // the application level, and the user can open multiple projects.
+  optional string id = 1;
+}
+
+message GetWorkspacePathsResponse {
+  // The unique ID for the workspace/project.
+  optional string id = 1;
+  repeated string paths = 2;
+}

proto/mcp.proto

@@ -1,16 +1,15 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service McpService {
   rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
   rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
   rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
-  rpc downloadMcp(StringRequest) returns (Empty);
+  rpc downloadMcp(StringRequest) returns (McpDownloadResponse);
   rpc restartMcpServer(StringRequest) returns (McpServers);
   rpc deleteMcpServer(StringRequest) returns (McpServers);
   rpc toggleToolAutoApprove(ToggleToolAutoApproveRequest) returns (McpServers);
@@ -119,3 +118,15 @@ message McpMarketplaceItem {
 message McpMarketplaceCatalog {
   repeated McpMarketplaceItem items = 1;
 }
+
+message McpDownloadResponse {
+  string mcp_id = 1;
+  string github_url = 2;
+  string name = 3;
+  string author = 4;
+  string description = 5;
+  string readme_content = 6;
+  string llms_installation_content = 7;
+  bool requires_api_key = 8;
+  optional string error = 9;
+}

proto/models.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 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
@@ -24,6 +23,8 @@ service ModelsService {
   rpc subscribeToOpenRouterModels(EmptyRequest) returns (stream OpenRouterCompatibleModelInfo);
   // Updates API configuration
   rpc updateApiConfigurationProto(UpdateApiConfigurationRequest) returns (Empty);
+   // Refreshes and returns Groq models
+  rpc refreshGroqModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
 }
 
 // List of VS Code LM models
@@ -121,8 +122,10 @@ enum ApiProvider {
   XAI = 21;
   SAMBANOVA = 22;
   CEREBRAS = 23;
-  SAPAICORE = 24;
-  CLAUDE_CODE = 25;
+  GROQ = 24;
+  SAPAICORE = 25;
+  CLAUDE_CODE = 26;
+  MOONSHOT = 27;
 }
 
 // Model info for OpenAI-compatible models
@@ -165,7 +168,7 @@ message ModelsApiConfiguration {
   // From ApiHandlerOptions (excluding onRetryAttempt function)
   optional string api_model_id = 1;
   optional string api_key = 2;
-  optional string cline_api_key = 3;
+  optional string cline_account_id = 3;
   optional string task_id = 4;
   optional string lite_llm_base_url = 5;
   optional string lite_llm_model_id = 6;
@@ -236,4 +239,11 @@ message ModelsApiConfiguration {
   optional string sap_ai_core_token_url = 71;
   optional string sap_ai_core_base_url = 72;
   optional string claude_code_path = 73;
-}
+  optional string aws_authentication = 74;
+  optional string aws_bedrock_api_key = 75;
+  optional string moonshot_api_key = 76;
+  optional string moonshot_api_line = 77;
+  optional string groq_api_key = 78;
+  optional string groq_model_id = 79;
+  optional OpenRouterModelInfo groq_model_info = 80;
+}

proto/package.json

@@ -1,3 +0,0 @@
-{
-	"type": "module"
-}

proto/slash.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 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

proto/state.proto

@@ -1,10 +1,9 @@
 syntax = "proto3";
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service StateService {
   rpc getLatestState(EmptyRequest) returns (State);
   rpc updateTerminalConnectionTimeout(Int64Request) returns (Int64);
@@ -17,6 +16,8 @@ service StateService {
   rpc togglePlanActMode(TogglePlanActModeRequest) returns (Boolean);
   rpc updateAutoApprovalSettings(AutoApprovalSettingsRequest) returns (Empty);
   rpc updateSettings(UpdateSettingsRequest) returns (Empty);
+  rpc updateTelemetrySetting(TelemetrySettingRequest) returns (Empty);
+  rpc setWelcomeViewCompleted(BooleanRequest) returns (Empty);
 }
 
 message State {
@@ -88,6 +89,17 @@ message AutoApprovalSettingsRequest {
   repeated string favorites = 7;
 }
 
+enum TelemetrySettingEnum {
+  UNSET = 0;
+  ENABLED = 1;
+  DISABLED = 2;
+}
+
+message TelemetrySettingRequest {
+  Metadata metadata = 1;
+  TelemetrySettingEnum setting = 2;
+}
+
 // Message for updating settings
 message UpdateSettingsRequest {
   Metadata metadata = 1;
@@ -100,7 +112,7 @@ message UpdateSettingsRequest {
   optional int64 shell_integration_timeout = 8;
   optional bool terminal_reuse_enabled = 9;
   optional bool mcp_responses_collapsed = 10;
-  optional bool mcp_rich_display_enabled = 11;
+  optional string mcp_display_mode = 11;
   optional int64 terminal_output_line_limit = 12;
 }
 
@@ -113,7 +125,7 @@ message ApiConfiguration {
   optional string api_base_url = 4;
   
   // Provider-specific API keys
-  optional string cline_api_key = 5;
+  optional string cline_account_id = 5;
   optional string openrouter_api_key = 6;
   optional string anthropic_base_url = 7;
   optional string openai_api_key = 8;
@@ -220,4 +232,12 @@ message ApiConfiguration {
 
   // Claude Code specific
   optional string claude_code_path = 77;
+
+  // Extension fields for Bedrock Api Keys
+  optional string aws_authentication = 78;
+  optional string aws_bedrock_api_key = 79;
+
+  // Moonshot
+  optional string moonshot_api_key = 80;
+  optional string moonshot_api_line = 81;
 }

proto/task.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service TaskService {
   // Cancels the currently running task
   rpc cancelTask(EmptyRequest) returns (Empty);
@@ -23,8 +22,6 @@ service TaskService {
   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
@@ -35,6 +32,8 @@ service TaskService {
   rpc taskCompletionViewChanges(Int64Request) returns (Empty);
   // Executes a quick win task with command and title
   rpc executeQuickWin(ExecuteQuickWinRequest) returns (Empty);
+  // Deletes all task history
+  rpc deleteAllTaskHistory(EmptyRequest) returns (DeleteAllTaskHistoryCount);
 }
 
 // Request message for creating a new task
@@ -66,12 +65,6 @@ message TaskResponse {
   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;
@@ -116,3 +109,8 @@ message ExecuteQuickWinRequest {
   string command = 2;
   string title = 3;
 }
+
+// Results returned when deleting all task history
+message DeleteAllTaskHistoryCount {
+  int32 tasks_deleted = 1;
+}

proto/ui.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 // Enum for webview provider types
 enum WebviewProviderType {
   SIDEBAR = 0;
@@ -265,4 +264,7 @@ service UiService {
 
   // Returns the HTML for the webview index page. This is only used by external clients, not by the vscode webview.
   rpc getWebviewHtml(EmptyRequest) returns (String);
+  
+  // Opens a URL in the default browser
+  rpc openUrl(StringRequest) returns (Empty);
 }

proto/web.proto

@@ -1,11 +1,10 @@
 syntax = "proto3";
 
 package cline;
+import "common.proto";
 option java_package = "bot.cline.proto";
 option java_multiple_files = true;
 
-import "common.proto";
-
 service WebService {
   rpc checkIsImageUrl(StringRequest) returns (IsImageUrl);
   rpc fetchOpenGraphData(StringRequest) returns (OpenGraphData);

scripts/build-proto-config.mjs

@@ -0,0 +1,32 @@
+// Configuration file for protocol buffer build scripts
+// Contains service name mappings used by both build-proto.js and build-go-proto.js
+
+// List of gRPC services
+// To add a new service, simply add it to this map and run the build scripts
+// The service handler will be automatically discovered and used by grpc-handler.ts
+export 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",
+	ui: "cline.UiService",
+	// Add new services here - no other code changes needed!
+}
+
+// List of host gRPC services (IDE API bridge)
+// These services are implemented in the IDE extension and called by the standalone Cline Core
+export const hostServiceNameMap = {
+	uri: "host.UriService",
+	watch: "host.WatchService",
+	workspace: "host.WorkspaceService",
+	env: "host.EnvService",
+	window: "host.WindowService",
+	diff: "host.DiffService",
+	// Add new host services here
+}

scripts/build-proto.mjs

@@ -9,20 +9,22 @@ import chalk from "chalk"
 import os from "os"
 
 import { createRequire } from "module"
+import { serviceNameMap } from "./build-proto-config.mjs"
+
 const require = createRequire(import.meta.url)
 const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
-const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
+const SCRIPT_NAME = path.relative(process.cwd(), fileURLToPath(import.meta.url))
 
-const TS_OUT_DIR = path.join(ROOT_DIR, "src/shared/proto")
-const GRPC_JS_OUT_DIR = path.join(ROOT_DIR, "src/generated/grpc-js")
-const NICE_JS_OUT_DIR = path.join(ROOT_DIR, "src/generated/nice-grpc")
-const DESCRIPTOR_OUT_DIR = path.join(ROOT_DIR, "dist-standalone/proto")
+const PROTO_DIR = path.resolve("proto")
+const TS_OUT_DIR = path.resolve("src/shared/proto")
+const GRPC_JS_OUT_DIR = path.resolve("src/generated/grpc-js")
+const NICE_JS_OUT_DIR = path.resolve("src/generated/nice-grpc")
+const DESCRIPTOR_OUT_DIR = path.resolve("dist-standalone/proto")
 
 const isWindows = process.platform === "win32"
 const TS_PROTO_PLUGIN = isWindows
-	? path.join(ROOT_DIR, "node_modules", ".bin", "protoc-gen-ts_proto.cmd") // Use the .bin directory path for Windows
+	? path.resolve("node_modules/.bin/protoc-gen-ts_proto.cmd") // Use the .bin directory path for Windows
 	: require.resolve("ts-proto/protoc-gen-ts_proto")
 
 const TS_PROTO_OPTIONS = [
@@ -34,33 +36,8 @@ const TS_PROTO_OPTIONS = [
 	"useDate=false", // Timestamp fields will not be automatically converted to Date.
 ]
 
-// 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",
-	ui: "cline.UiService",
-	// Add new services here - no other code changes needed!
-}
-const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src/core/controller", serviceKey))
-
-// List of host gRPC services (IDE API bridge)
-// These services are implemented in the IDE extension and called by the standalone Cline Core
-const hostServiceNameMap = {
-	uri: "host.UriService",
-	watch: "host.WatchService",
-	// Add new host services here
-}
-const hostServiceDirs = Object.keys(hostServiceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src/hosts/vscode", serviceKey))
+// Service directories derived from imported serviceNameMap
+const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join("src/core/controller", serviceKey))
 
 async function main() {
 	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))
@@ -79,8 +56,8 @@ async function main() {
 	await ensureProtoFilesExist()
 
 	// Process all proto files
-	const protoFiles = await globby("**/*.proto", { cwd: SCRIPT_DIR, realpath: true })
-	console.log(chalk.cyan(`Processing ${protoFiles.length} proto files from`), SCRIPT_DIR)
+	const protoFiles = await globby("**/*.proto", { cwd: PROTO_DIR, realpath: true })
+	console.log(chalk.cyan(`Processing ${protoFiles.length} proto files from`), PROTO_DIR)
 
 	tsProtoc(TS_OUT_DIR, protoFiles, TS_PROTO_OPTIONS)
 	// grpc-js is used to generate service impls for the ProtoBus service.
@@ -91,7 +68,7 @@ async function main() {
 	const descriptorFile = path.join(DESCRIPTOR_OUT_DIR, "descriptor_set.pb")
 	const descriptorProtocCommand = [
 		PROTOC,
-		`--proto_path="${SCRIPT_DIR}"`,
+		`--proto_path="${PROTO_DIR}"`,
 		`--descriptor_set_out="${descriptorFile}"`,
 		"--include_imports",
 		...protoFiles,
@@ -107,11 +84,9 @@ async function main() {
 	log_verbose(chalk.green("Protocol Buffer code generation completed successfully."))
 	log_verbose(chalk.green(`TypeScript files generated in: ${TS_OUT_DIR}`))
 
-	await generateMethodRegistrations()
-	await generateHostMethodRegistrations()
-	await generateServiceConfig()
-	await generateHostServiceConfig()
-	await generateGrpcClientConfig()
+	await generateProtoBusServiceConfig()
+	await generateProtoBusMethodRegistrations()
+	await generateProtoBusGrpcClientConfig()
 
 	console.log(chalk.bold.blue("Finished Protocol Buffer code generation."))
 }
@@ -120,7 +95,7 @@ async function tsProtoc(outDir, protoFiles, protoOptions) {
 	// Build the protoc command with proper path handling for cross-platform
 	const command = [
 		PROTOC,
-		`--proto_path="${SCRIPT_DIR}"`,
+		`--proto_path="${PROTO_DIR}"`,
 		`--plugin=protoc-gen-ts_proto="${TS_PROTO_PLUGIN}"`,
 		`--ts_proto_out="${outDir}"`,
 		`--ts_proto_opt=${protoOptions.join(",")} `,
@@ -140,7 +115,7 @@ async function tsProtoc(outDir, protoFiles, protoOptions) {
  * 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() {
+async function generateProtoBusGrpcClientConfig() {
 	log_verbose(chalk.cyan("Generating gRPC client configuration..."))
 
 	const serviceImports = []
@@ -165,7 +140,7 @@ async function generateGrpcClientConfig() {
 
 	// Generate the file content
 	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
+// Generated by ${SCRIPT_NAME}
 
 import { createGrpcClient } from "./grpc-client-base"
 ${serviceImports.join("\n")}
@@ -176,7 +151,7 @@ export {
 	${serviceExports.join(",\n\t")}
 }`
 
-	const filePath = path.join(ROOT_DIR, "webview-ui/src/services/grpc-client.ts")
+	const filePath = path.resolve("webview-ui/src/services/grpc-client.ts")
 	await writeFileWithMkdirs(filePath, content)
 	log_verbose(chalk.green(`Generated gRPC client at ${filePath}`))
 }
@@ -239,12 +214,12 @@ async function parseProtoForStreamingMethods(protoFiles, scriptDir) {
 	return streamingMethodsMap
 }
 
-async function generateMethodRegistrations() {
+async function generateProtoBusMethodRegistrations() {
 	log_verbose(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 protoFiles = await globby("*.proto", { cwd: PROTO_DIR })
+	const streamingMethodsMap = await parseProtoForStreamingMethods(protoFiles, PROTO_DIR)
 
 	for (const serviceDir of serviceDirs) {
 		const serviceName = path.basename(serviceDir)
@@ -261,7 +236,7 @@ async function generateMethodRegistrations() {
 
 		// Create the methods.ts file with header
 		let methodsContent = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
+// Generated by ${SCRIPT_NAME}
 
 // Import all method implementations
 import { registerMethod } from "./index"\n`
@@ -310,7 +285,7 @@ export function registerAllMethods(): void {
 		// 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
+// Generated by ${SCRIPT_NAME}
 
 import { createServiceRegistry, ServiceMethodHandler, StreamingMethodHandler } from "../grpc-service"
 import { StreamingResponseHandler } from "../grpc-handler"
@@ -345,7 +320,7 @@ registerAllMethods()`
  * 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() {
+async function generateProtoBusServiceConfig() {
 	log_verbose(chalk.cyan("Generating service configuration file..."))
 
 	const serviceImports = []
@@ -365,7 +340,7 @@ async function generateServiceConfig() {
 	}
 
 	const content = `// AUTO-GENERATED FILE - DO NOT MODIFY DIRECTLY
-// Generated by proto/build-proto.js
+// Generated by ${SCRIPT_NAME}
 
 import { Controller } from "./index"
 import { StreamingResponseHandler } from "./grpc-handler"
@@ -385,7 +360,7 @@ export interface ServiceHandlerConfig {
 export const serviceHandlers: Record<string, ServiceHandlerConfig> = {${serviceConfigs.join(",")}
 };`
 
-	const configPath = path.join(ROOT_DIR, "src/core/controller/grpc-service-config.ts")
+	const configPath = path.resolve("src/core/controller/grpc-service-config.ts")
 	await writeFileWithMkdirs(configPath, content)
 	log_verbose(chalk.green(`Generated service configuration at ${configPath}`))
 }
@@ -398,7 +373,7 @@ async function ensureProtoFilesExist() {
 	log_verbose(chalk.cyan("Checking for missing proto files..."))
 
 	// Get existing proto files
-	const existingProtoFiles = await globby("*.proto", { cwd: SCRIPT_DIR })
+	const existingProtoFiles = await globby("*.proto", { cwd: PROTO_DIR })
 	const existingProtoServices = existingProtoFiles.map((file) => path.basename(file, ".proto"))
 
 	// Check each service in serviceNameMap
@@ -435,165 +410,13 @@ service ${serviceClassName} {
 `
 
 			// Write the template proto file
-			const protoFilePath = path.join(SCRIPT_DIR, `${serviceName}.proto`)
+			const protoFilePath = path.join(PROTO_DIR, `${serviceName}.proto`)
 			await fs.writeFile(protoFilePath, protoContent)
 			log_verbose(chalk.green(`Created template proto file at ${protoFilePath}`))
 		}
 	}
 }
 
-/**
- * Generate method registration files for host services
- */
-async function generateHostMethodRegistrations() {
-	log_verbose(chalk.cyan("Generating host method registration files..."))
-
-	// Parse proto files for streaming methods
-	const hostProtoFiles = await globby("*.proto", { cwd: path.join(SCRIPT_DIR, "host") })
-	const streamingMethodsMap = await parseProtoForStreamingMethods(hostProtoFiles, path.join(SCRIPT_DIR, "host"))
-
-	for (const serviceDir of hostServiceDirs) {
-		const serviceName = path.basename(serviceDir)
-		const fullServiceName = hostServiceNameMap[serviceName]
-		const streamingMethods = streamingMethodsMap.get(fullServiceName) || []
-
-		log_verbose(chalk.cyan(`Generating method registrations for host ${serviceName}...`))
-
-		// Get all TypeScript files in the service directory
-		const files = await globby("*.ts", { cwd: serviceDir })
-
-		// 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
-// Generated by proto/build-proto.js
-
-// Import all method implementations
-import { registerMethod } from "./index"\n`
-
-		// Import implementations directly
-		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`
-		}
-
-		// Add registration function
-		methodsContent += `\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`
-			}
-		}
-
-		// Close the function
-		methodsContent += `}`
-
-		// Write the methods.ts file
-		const registryFile = path.join(serviceDir, "methods.ts")
-		await writeFileWithMkdirs(registryFile, methodsContent)
-		log_verbose(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 "../host-grpc-service"
-import { StreamingResponseHandler } from "../host-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
-		const indexFile = path.join(serviceDir, "index.ts")
-		await writeFileWithMkdirs(indexFile, indexContent)
-		log_verbose(chalk.green(`Generated ${indexFile}`))
-	}
-
-	log_verbose(chalk.green("Host method registration files generated successfully."))
-}
-
-/**
- * Generate a service configuration file for host services
- */
-async function generateHostServiceConfig() {
-	log_verbose(chalk.cyan("Generating host service configuration file..."))
-
-	const serviceImports = []
-	const serviceConfigs = []
-
-	// Add all services from the hostServiceNameMap
-	for (const [dirName, fullServiceName] of Object.entries(hostServiceNameMap)) {
-		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 { StreamingResponseHandler } from "./host-grpc-handler"
-${serviceImports.join("\n")}
-
-/**
- * Configuration for a host service handler
- */
-export interface HostServiceHandlerConfig {
-  requestHandler: (method: string, message: any) => Promise<any>;
-  streamingHandler: (method: string, message: any, responseStream: StreamingResponseHandler, requestId?: string) => Promise<void>;
-}
-
-/**
- * Map of host service names to their handler configurations
- */
-export const hostServiceHandlers: Record<string, HostServiceHandlerConfig> = {${serviceConfigs.join(",")}
-};`
-
-	const filePath = path.join(ROOT_DIR, "src/hosts/vscode/host-grpc-service-config.ts")
-	await writeFileWithMkdirs(filePath, content)
-	log_verbose(chalk.green(`Generated host service configuration at ${filePath}`))
-}
-
 async function cleanup() {
 	// Clean up existing generated files
 	log_verbose(chalk.cyan("Cleaning up existing generated TypeScript files..."))
@@ -601,16 +424,33 @@ async function cleanup() {
 	for (const file of existingFiles) {
 		await fs.unlink(path.join(TS_OUT_DIR, file))
 	}
-	await rmdir(path.join(ROOT_DIR, "src/generated"))
+	await rmdir("src/generated")
 
 	// Clean up generated files that were moved.
-	await fs.rm(path.join(ROOT_DIR, "src/standalone/services/host-grpc-client.ts"), { force: true })
-	await rmdir(path.join(ROOT_DIR, "src/standalone/services"))
+	await fs.rm("src/standalone/services/host-grpc-client.ts", { force: true })
+	await rmdir("src/standalone/services")
+	await fs.rm("hosts/vscode", { force: true, recursive: true })
+	await rmdir("hosts")
 
-	await fs.rm(path.join(ROOT_DIR, "hosts/vscode"), { force: true, recursive: true })
-	await rmdir(path.join(ROOT_DIR, "hosts"))
-
-	await fs.rm(path.join(ROOT_DIR, "src/standalone/server-setup.ts"), { force: true })
+	await fs.rm("src/standalone/server-setup.ts", { force: true })
+	await fs.rm("src/hosts/vscode/host-grpc-service-config.ts", { force: true })
+	const oldhostbridgefiles = [
+		"src/hosts/vscode/workspace/methods.ts",
+		"src/hosts/vscode/workspace/index.ts",
+		"src/hosts/vscode/diff/methods.ts",
+		"src/hosts/vscode/diff/index.ts",
+		"src/hosts/vscode/env/methods.ts",
+		"src/hosts/vscode/env/index.ts",
+		"src/hosts/vscode/window/methods.ts",
+		"src/hosts/vscode/window/index.ts",
+		"src/hosts/vscode/watch/methods.ts",
+		"src/hosts/vscode/watch/index.ts",
+		"src/hosts/vscode/uri/methods.ts",
+		"src/hosts/vscode/uri/index.ts",
+	]
+	for (const file of oldhostbridgefiles) {
+		await fs.rm(file, { force: true })
+	}
 }
 
 /**
@@ -635,13 +475,6 @@ async function rmdir(path) {
 	}
 }
 
-function serviceNameWithoutPackage(fullServiceName) {
-	return fullServiceName.replace(/.*\./, "")
-}
-function lowercaseFirstChar(str) {
-	return str.charAt(0).toLowerCase() + str.slice(1)
-}
-
 // Check for Apple Silicon compatibility
 function checkAppleSiliconCompatibility() {
 	// Only run check on macOS

scripts/generate-host-bridge-client.mjs

@@ -6,10 +6,15 @@ import * as grpc from "@grpc/grpc-js"
 import * as protoLoader from "@grpc/proto-loader"
 import chalk from "chalk"
 
-const IMPL_FILE = path.resolve("src/generated/standalone/host-bridge-clients.ts")
-const INTERFACE_FILE = path.resolve("src/generated/hosts/host-bridge-client-types.ts")
 const DESCRIPTOR_SET = path.resolve("dist-standalone/proto/descriptor_set.pb")
 
+// Contains the interface definitions for the host bridge clients.
+const TYPES_FILE = path.resolve("src/generated/hosts/host-bridge-client-types.ts")
+// Contains the ExternalHostBridgeClientManager for the external host bridge clients (using nice-grpc).
+const EXTERNAL_CLIENT_FILE = path.resolve("src/generated/hosts/standalone/host-bridge-clients.ts")
+// Contains the handler map for the external host bridge clients (using the custom service registry).
+const VSCODE_CLIENT_FILE = path.resolve("src/generated/hosts/vscode/hostbridge-grpc-service-config.ts")
+
 const typeNameToFQN = new Map()
 
 function addTypeNameToFqn(name, fqn) {
@@ -48,24 +53,23 @@ async function main() {
 		}
 	}
 
-	// Generate interfaces file
-	await generateInterfacesFile(hostServices)
-
-	// // Generate implementation file
-	await generateImplementationFile(hostServices)
+	await generateTypesFile(hostServices)
+	await generateExternalClientFile(hostServices)
+	await generateVscodeClientFile(hostServices)
 
 	console.log(`Generated host bridge client files at:`)
-	console.log(`- ${INTERFACE_FILE}`)
-	console.log(`- ${IMPL_FILE}`)
+	console.log(`- ${TYPES_FILE}`)
+	console.log(`- ${EXTERNAL_CLIENT_FILE}`)
+	console.log(`- ${VSCODE_CLIENT_FILE}`)
 }
 
 /**
  * Generate the client interfaces file.
  */
-async function generateInterfacesFile(hostServices) {
+async function generateTypesFile(hostServices) {
 	const clientInterfaces = []
 	for (const [name, def] of Object.entries(hostServices)) {
-		const clientInterface = generateClientInterface(name, def)
+		const clientInterface = generateClientInterfaceType(name, def)
 		clientInterfaces.push(clientInterface)
 	}
 	const content = `// GENERATED CODE -- DO NOT EDIT!
@@ -76,14 +80,14 @@ import { StreamingCallbacks } from "@hosts/host-provider-types"
 ${clientInterfaces.join("\n\n")}
 `
 	// Write output file
-	await fs.mkdir(path.dirname(INTERFACE_FILE), { recursive: true })
-	await fs.writeFile(INTERFACE_FILE, content)
+	await fs.mkdir(path.dirname(TYPES_FILE), { recursive: true })
+	await fs.writeFile(TYPES_FILE, content)
 }
 
 /**
  * Generate a client interface for a service.
  */
-function generateClientInterface(serviceName, serviceDefinition) {
+function generateClientInterfaceType(serviceName, serviceDefinition) {
 	// Get the methods from the service definition
 	const methods = Object.entries(serviceDefinition.service)
 		.map(([methodName, methodDef]) => {
@@ -110,9 +114,9 @@ ${methods}
 }
 
 /**
- * Generate the client implementations file.
+ * Generate the external client implementations file.
  */
-async function generateImplementationFile(hostServices) {
+async function generateExternalClientFile(hostServices) {
 	// Generate imports
 	const imports = []
 	// Add imports for the interfaces
@@ -121,7 +125,7 @@ async function generateImplementationFile(hostServices) {
 	}
 	const clientImplementations = []
 	for (const [name, def] of Object.entries(hostServices)) {
-		clientImplementations.push(generateClientImplementation(name, def))
+		clientImplementations.push(generateExternalClientSetup(name, def))
 	}
 
 	const content = `// GENERATED CODE -- DO NOT EDIT!
@@ -136,16 +140,15 @@ ${imports.join("\n")}
 
 ${clientImplementations.join("\n\n")}
 `
-
 	// Write output file
-	await fs.mkdir(path.dirname(IMPL_FILE), { recursive: true })
-	await fs.writeFile(IMPL_FILE, content)
+	await fs.mkdir(path.dirname(EXTERNAL_CLIENT_FILE), { recursive: true })
+	await fs.writeFile(EXTERNAL_CLIENT_FILE, content)
 }
 
 /**
  * Generate a client implementation class for a service
  */
-function generateClientImplementation(serviceName, serviceDefinition) {
+function generateExternalClientSetup(serviceName, serviceDefinition) {
 	// Get the methods from the service definition
 	const methods = Object.entries(serviceDefinition.service)
 		.map(([methodName, methodDef]) => {
@@ -185,6 +188,71 @@ ${methods}
 }`
 }
 
+/**
+ * Generate the Vscode client setup file.
+ */
+async function generateVscodeClientFile(hostServices) {
+	const imports = []
+	const clientImplementations = []
+	const handlerMap = []
+	for (const [serviceName, serviceDefinition] of Object.entries(hostServices)) {
+		const name = serviceName.replace(/Service$/, "").toLowerCase()
+		for (const [methodName, _methodDef] of Object.entries(serviceDefinition.service)) {
+			imports.push(`import { ${methodName} } from "@/hosts/vscode/hostbridge/${name}/${methodName}"`)
+		}
+		imports.push("")
+
+		clientImplementations.push(generateVscodeClientImplementation(name, serviceDefinition))
+
+		handlerMap.push(`	"host.${serviceName}": {
+		requestHandler: ${name}ServiceRegistry.handleRequest,
+		streamingHandler: ${name}ServiceRegistry.handleStreamingRequest,
+	},`)
+	}
+
+	const content = `// GENERATED CODE -- DO NOT EDIT!
+// Generated by scripts/generate-host-bridge-client.mjs
+import { createServiceRegistry } from "@hosts/vscode/hostbridge-grpc-service"
+import { HostServiceHandlerConfig } from "@hosts/vscode/hostbridge-grpc-handler"
+
+${imports.join("\n")}
+${clientImplementations.join("\n\n")}
+
+/**
+ * Map of host service names to their handler configurations
+ */
+export const hostServiceHandlers: Record<string, HostServiceHandlerConfig> = {
+${handlerMap.join("\n")}
+}
+`
+
+	// Write output file
+	await fs.mkdir(path.dirname(VSCODE_CLIENT_FILE), { recursive: true })
+	await fs.writeFile(VSCODE_CLIENT_FILE, content)
+}
+
+function generateVscodeClientImplementation(serviceName, serviceDefinition) {
+	// Get the methods from the service definition
+	const name = serviceName.replace(/Service$/, "").toLowerCase()
+
+	const methods = Object.entries(serviceDefinition.service)
+		.map(([methodName, methodDef]) => {
+			// Get fully qualified type names
+			const isStreamingResponse = methodDef.responseStream
+			if (!isStreamingResponse) {
+				return `${name}ServiceRegistry.registerMethod("${methodName}", ${methodName})`
+			} else {
+				return `${name}ServiceRegistry.registerMethod("${methodName}", ${methodName}, { isStreaming: true })`
+			}
+		})
+		.join("\n")
+
+	// Generate the class
+	return `// Setup ${name} service registry
+const ${name}ServiceRegistry = createServiceRegistry("${name}")
+${methods}`
+}
+
 // Run the main function
 main().catch((error) => {
 	console.error(chalk.red("Error:"), error)

scripts/get-vscode-usages.sh

@@ -5,16 +5,31 @@ DIR=${1:-src/}
 DEST_DIR=dist-standalone
 SDK_DEST=$DEST_DIR/vscode-sdk-uses.txt
 CSS_DEST=$DEST_DIR/vscode-css-uses.txt
+TMP=/tmp/vscode-sdk-uses.txt.tmp
 mkdir -p $DEST_DIR
 
 {
 git grep -h 'vscode\.' $DIR |
 grep -Ev '//.*vscode' | # remove commented out code
+grep -v vscode.commands.executeCommand | # executeCommand is handled separately
+grep -Ev '"vscode' | # remove command strings that get included because they start with vscode
 sed 's|.*vscode\.|vscode.|'| # remove everything before vscode.
 sed 's/[^a-zA-Z0-9_.].*$//' | # remove everything after last identifier
 grep -E '\.[a-z][^.]+$' | # remove types (last part of identifier should be lowercase)
-sort | uniq > $SDK_DEST
+cat > $TMP
 }
+{
+  grep -rh vscode.commands.executeCommand $DIR |
+  perl -ne 'print if /["\x27"]/'  | # Remove occurrences where the command is not on the same line (line doesnt contain quote chars) :(
+  sed -n 's|.*\(vscode.commands.executeCommand[^,]*\).*|\1|p'| # Remove all params after the first one
+  sed 's|\(".*"\).*|\1)|'| # Close the parantheses
+  cat >> $TMP
+}
+
+# Count occurrences
+cat $TMP | sort | uniq -c | sort -n > $SDK_DEST
+rm $TMP
+
 echo Wrote uses of the vscode SDK to $(realpath $SDK_DEST)
 
 {

scripts/package-standalone.mjs

@@ -1,83 +1,175 @@
-import fs from "fs"
-import path from "path"
-import { glob } from "glob"
+#!/usr/bin/env node
+
 import archiver from "archiver"
-import { cp } from "fs/promises"
 import { execSync } from "child_process"
-
+import fs from "fs"
+import { cp } from "fs/promises"
+import { glob } from "glob"
+import minimatch from "minimatch"
+import path from "path"
 const BUILD_DIR = "dist-standalone"
-const SOURCE_DIR = "standalone/runtime-files"
+const RUNTIME_DEPS_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" })
-	// Move the vscode directory into node_modules.
-	// It can't be installed using npm because it will create a symlink which is not portable.
-	fs.renameSync("vscode", path.join("node_modules", "vscode"))
-} catch (error) {
-	console.error("Error during setup:", error)
-	process.exit(1)
-} finally {
-	process.chdir(cwd)
+async function main() {
+	await installNodeDependencies()
+	await zipDistribution()
 }
 
-// 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)
+async function installNodeDependencies() {
+	await cpr(RUNTIME_DEPS_DIR, BUILD_DIR)
+
+	console.log("Running npm install in distribution directory...")
+	const cwd = process.cwd()
+	process.chdir(BUILD_DIR)
+
+	try {
+		execSync("npm install", { stdio: "inherit" })
+		// Move the vscode directory into node_modules.
+		// It can't be installed using npm because it will create a symlink which cannot be unzipped correctly on windows.
+		fs.renameSync("vscode", path.join("node_modules", "vscode"))
+	} catch (error) {
+		console.error("Error during setup:", 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: 3 } })
+async function zipDistribution() {
+	// 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: 3 } })
 
-output.on("close", () => {
-	console.log(`Created ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB)`)
-})
-archive.on("warning", (err) => {
-	console.warn(`Warning: ${err}`)
-})
-archive.on("error", (err) => {
-	throw err
-})
+	output.on("close", () => {
+		console.log(`Created ${zipPath} (${(archive.pointer() / 1024 / 1024).toFixed(1)} MB)`)
+	})
+	archive.on("warning", (err) => {
+		console.warn(`Warning: ${err}`)
+	})
+	archive.on("error", (err) => {
+		throw err
+	})
 
-archive.pipe(output)
-archive.glob("**/*", {
-	cwd: BUILD_DIR,
-	ignore: ["standalone.zip"],
-})
+	archive.pipe(output)
+	// Add all the files from the standalone build dir.
+	archive.glob("**/*", {
+		cwd: BUILD_DIR,
+		ignore: ["standalone.zip"],
+	})
 
-// Add the whole cline directory under "extension"
-archive.directory(process.cwd(), "extension", (entry) => {
-	// Skip certain directories.
-	const exclude = [
-		BUILD_DIR + "/",
-		"node_modules/", // node_modules nearly 1GB.
-		"webview-ui/node_modules/", // node_modules nearly 1GB.
-	]
-	// These node modules are used at runtime as assets, they need to be included.
-	const include = ["node_modules/@vscode/", "webview-ui/node_modules/katex"]
-	const name = entry.name
+	// Exclude the same files as the VCE vscode extension packager.
+	// Also ignore the dist directory, the build directory for the extension.
+	const isIgnored = createIsIgnored(["dist/**"])
 
-	if (include.some((prefix) => name.startsWith(prefix))) {
+	// Add the whole cline directory under "extension", except the for the ignored files.
+	archive.directory(process.cwd(), "extension", (entry) => {
+		if (isIgnored(entry.name)) {
+			log_verbose("Ignoring", entry.name)
+			return false
+		}
 		return entry
-	}
-	if (exclude.some((prefix) => name.startsWith(prefix))) {
-		return false
-	}
-	if (name.match(/(^|\/)\./)) {
-		// exclude dot directories
-		return false
-	}
-	return entry
-})
+	})
 
-console.log("Zipping package...")
-await archive.finalize()
+	console.log("Zipping package...")
+	await archive.finalize()
+}
+
+/**
+ * This is based on https://github.com/microsoft/vscode-vsce/blob/fafad8a63e9cf31179f918eb7a4eeb376834c904/src/package.ts#L1695
+ * because the .vscodeignore format is not compatible with the `ignore` npm module.
+ */
+function createIsIgnored(standaloneIgnores) {
+	const MinimatchOptions = { dot: true }
+	const defaultIgnore = [
+		".vscodeignore",
+		"package-lock.json",
+		"npm-debug.log",
+		"yarn.lock",
+		"yarn-error.log",
+		"npm-shrinkwrap.json",
+		".editorconfig",
+		".npmrc",
+		".yarnrc",
+		".gitattributes",
+		"*.todo",
+		"tslint.yaml",
+		".eslintrc*",
+		".babelrc*",
+		".prettierrc*",
+		".cz-config.js",
+		".commitlintrc*",
+		"webpack.config.js",
+		"ISSUE_TEMPLATE.md",
+		"CONTRIBUTING.md",
+		"PULL_REQUEST_TEMPLATE.md",
+		"CODE_OF_CONDUCT.md",
+		".github",
+		".travis.yml",
+		"appveyor.yml",
+		"**/.git",
+		"**/.git/**",
+		"**/*.vsix",
+		"**/.DS_Store",
+		"**/*.vsixmanifest",
+		"**/.vscode-test/**",
+		"**/.vscode-test-web/**",
+	]
+
+	const rawIgnore = fs.readFileSync(".vscodeignore", "utf8")
+
+	// Parse raw ignore by splitting output into lines and filtering out empty lines and comments
+	const parsedIgnore = rawIgnore
+		.split(/[\n\r]/)
+		.map((s) => s.trim())
+		.filter((s) => !!s)
+		.filter((i) => !/^\s*#/.test(i))
+
+	// Add '/**' to possible folder names
+	const expandedIgnore = [
+		...parsedIgnore,
+		...parsedIgnore.filter((i) => !/(^|\/)[^/]*\*[^/]*$/.test(i)).map((i) => (/\/$/.test(i) ? `${i}**` : `${i}/**`)),
+	]
+
+	// Combine with default ignore list
+	// Also ignore the dist directory- the build directory for the extension.
+	const allIgnore = [...defaultIgnore, ...expandedIgnore, ...standaloneIgnores]
+
+	// Split into ignore and negate list
+	const [ignore, negate] = allIgnore.reduce(
+		(r, e) => (!/^\s*!/.test(e) ? [[...r[0], e], r[1]] : [r[0], [...r[1], e]]),
+		[[], []],
+	)
+
+	function isIgnored(f) {
+		return (
+			ignore.some((i) => minimatch(f, i, MinimatchOptions)) &&
+			!negate.some((i) => minimatch(f, i.substr(1), MinimatchOptions))
+		)
+	}
+	return isIgnored
+}
+
+/* cp -r */
+async function cpr(source, dest) {
+	await cp(source, dest, {
+		recursive: true,
+		preserveTimestamps: true,
+		dereference: false, // preserve symlinks instead of following them
+	})
+}
+
+function log_verbose(...args) {
+	if (process.argv.includes("-v") || process.argv.includes("--verbose")) {
+		console.log(...args)
+	}
+}
+
+await main()

scripts/runclinecore.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -eu #x
+# This compiles the cline-core app, installs it to the user's home directory,
+# and runs the service.
+
+CORE_DIR=~/.cline/core
+INSTALL_DIR=$CORE_DIR/0.0.1
+
+# Build cline core
+npm run compile-standalone
+
+# Remove old unpacked versions to force reinstall
+rm -rf $CORE_DIR/* || true
+
+mkdir -p $INSTALL_DIR
+cp dist-standalone/standalone.zip $INSTALL_DIR
+cd $INSTALL_DIR
+unp standalone.zip > /dev/null
+
+pkill -f cline-core.js || true
+NODE_PATH=./node_modules node cline-core.js

src/api/index.ts

@@ -27,6 +27,8 @@ import { SambanovaHandler } from "./providers/sambanova"
 import { CerebrasHandler } from "./providers/cerebras"
 import { SapAiCoreHandler } from "./providers/sapaicore"
 import { ClaudeCodeHandler } from "./providers/claude-code"
+import { MoonshotHandler } from "./providers/moonshot"
+import { GroqHandler } from "./providers/groq"
 
 export interface ApiHandler {
 	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
@@ -38,62 +40,240 @@ export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
 }
 
-export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
-	const { apiProvider, ...options } = configuration
+function createHandlerForProvider(apiProvider: string | undefined, options: Omit<ApiConfiguration, "apiProvider">): ApiHandler {
 	switch (apiProvider) {
 		case "anthropic":
-			return new AnthropicHandler(options)
+			return new AnthropicHandler({
+				apiKey: options.apiKey,
+				anthropicBaseUrl: options.anthropicBaseUrl,
+				apiModelId: options.apiModelId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 		case "openrouter":
-			return new OpenRouterHandler(options)
+			return new OpenRouterHandler({
+				openRouterApiKey: options.openRouterApiKey,
+				openRouterModelId: options.openRouterModelId,
+				openRouterModelInfo: options.openRouterModelInfo,
+				openRouterProviderSorting: options.openRouterProviderSorting,
+				reasoningEffort: options.reasoningEffort,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 		case "bedrock":
-			return new AwsBedrockHandler(options)
+			return new AwsBedrockHandler({
+				apiModelId: options.apiModelId,
+				awsAccessKey: options.awsAccessKey,
+				awsSecretKey: options.awsSecretKey,
+				awsSessionToken: options.awsSessionToken,
+				awsRegion: options.awsRegion,
+				awsAuthentication: options.awsAuthentication,
+				awsBedrockApiKey: options.awsBedrockApiKey,
+				awsUseCrossRegionInference: options.awsUseCrossRegionInference,
+				awsBedrockUsePromptCache: options.awsBedrockUsePromptCache,
+				awsUseProfile: options.awsUseProfile,
+				awsProfile: options.awsProfile,
+				awsBedrockEndpoint: options.awsBedrockEndpoint,
+				awsBedrockCustomSelected: options.awsBedrockCustomSelected,
+				awsBedrockCustomModelBaseId: options.awsBedrockCustomModelBaseId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 		case "vertex":
-			return new VertexHandler(options)
+			return new VertexHandler({
+				vertexProjectId: options.vertexProjectId,
+				vertexRegion: options.vertexRegion,
+				apiModelId: options.apiModelId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				geminiApiKey: options.geminiApiKey,
+				geminiBaseUrl: options.geminiBaseUrl,
+				taskId: options.taskId,
+			})
 		case "openai":
-			return new OpenAiHandler(options)
+			return new OpenAiHandler({
+				openAiApiKey: options.openAiApiKey,
+				openAiBaseUrl: options.openAiBaseUrl,
+				azureApiVersion: options.azureApiVersion,
+				openAiHeaders: options.openAiHeaders,
+				openAiModelId: options.openAiModelId,
+				openAiModelInfo: options.openAiModelInfo,
+				reasoningEffort: options.reasoningEffort,
+			})
 		case "ollama":
-			return new OllamaHandler(options)
+			return new OllamaHandler({
+				ollamaBaseUrl: options.ollamaBaseUrl,
+				ollamaModelId: options.ollamaModelId,
+				ollamaApiOptionsCtxNum: options.ollamaApiOptionsCtxNum,
+				requestTimeoutMs: options.requestTimeoutMs,
+			})
 		case "lmstudio":
-			return new LmStudioHandler(options)
+			return new LmStudioHandler({
+				lmStudioBaseUrl: options.lmStudioBaseUrl,
+				lmStudioModelId: options.lmStudioModelId,
+			})
 		case "gemini":
-			return new GeminiHandler(options)
+			return new GeminiHandler({
+				vertexProjectId: options.vertexProjectId,
+				vertexRegion: options.vertexRegion,
+				geminiApiKey: options.geminiApiKey,
+				geminiBaseUrl: options.geminiBaseUrl,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				apiModelId: options.apiModelId,
+				taskId: options.taskId,
+			})
 		case "openai-native":
-			return new OpenAiNativeHandler(options)
+			return new OpenAiNativeHandler({
+				openAiNativeApiKey: options.openAiNativeApiKey,
+				reasoningEffort: options.reasoningEffort,
+				apiModelId: options.apiModelId,
+			})
 		case "deepseek":
-			return new DeepSeekHandler(options)
+			return new DeepSeekHandler({
+				deepSeekApiKey: options.deepSeekApiKey,
+				apiModelId: options.apiModelId,
+			})
 		case "requesty":
-			return new RequestyHandler(options)
+			return new RequestyHandler({
+				requestyApiKey: options.requestyApiKey,
+				reasoningEffort: options.reasoningEffort,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				requestyModelId: options.requestyModelId,
+				requestyModelInfo: options.requestyModelInfo,
+			})
 		case "fireworks":
-			return new FireworksHandler(options)
+			return new FireworksHandler({
+				fireworksApiKey: options.fireworksApiKey,
+				fireworksModelId: options.fireworksModelId,
+				fireworksModelMaxCompletionTokens: options.fireworksModelMaxCompletionTokens,
+				fireworksModelMaxTokens: options.fireworksModelMaxTokens,
+			})
 		case "together":
-			return new TogetherHandler(options)
+			return new TogetherHandler({
+				togetherApiKey: options.togetherApiKey,
+				togetherModelId: options.togetherModelId,
+			})
 		case "qwen":
-			return new QwenHandler(options)
+			return new QwenHandler({
+				qwenApiKey: options.qwenApiKey,
+				qwenApiLine: options.qwenApiLine,
+				apiModelId: options.apiModelId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 		case "doubao":
-			return new DoubaoHandler(options)
+			return new DoubaoHandler({
+				doubaoApiKey: options.doubaoApiKey,
+				apiModelId: options.apiModelId,
+			})
 		case "mistral":
-			return new MistralHandler(options)
+			return new MistralHandler({
+				mistralApiKey: options.mistralApiKey,
+				apiModelId: options.apiModelId,
+			})
 		case "vscode-lm":
-			return new VsCodeLmHandler(options)
+			return new VsCodeLmHandler({
+				vsCodeLmModelSelector: options.vsCodeLmModelSelector,
+			})
 		case "cline":
-			return new ClineHandler(options)
+			return new ClineHandler({
+				taskId: options.taskId,
+				reasoningEffort: options.reasoningEffort,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				openRouterProviderSorting: options.openRouterProviderSorting,
+				openRouterModelId: options.openRouterModelId,
+				openRouterModelInfo: options.openRouterModelInfo,
+			})
 		case "litellm":
-			return new LiteLlmHandler(options)
+			return new LiteLlmHandler({
+				liteLlmApiKey: options.liteLlmApiKey,
+				liteLlmBaseUrl: options.liteLlmBaseUrl,
+				liteLlmModelId: options.liteLlmModelId,
+				liteLlmModelInfo: options.liteLlmModelInfo,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+				liteLlmUsePromptCache: options.liteLlmUsePromptCache,
+				taskId: options.taskId,
+			})
+		case "moonshot":
+			return new MoonshotHandler({
+				moonshotApiKey: options.moonshotApiKey,
+				moonshotApiLine: options.moonshotApiLine,
+				apiModelId: options.apiModelId,
+			})
 		case "nebius":
-			return new NebiusHandler(options)
+			return new NebiusHandler({
+				nebiusApiKey: options.nebiusApiKey,
+				apiModelId: options.apiModelId,
+			})
 		case "asksage":
-			return new AskSageHandler(options)
+			return new AskSageHandler({
+				asksageApiKey: options.asksageApiKey,
+				asksageApiUrl: options.asksageApiUrl,
+				apiModelId: options.apiModelId,
+			})
 		case "xai":
-			return new XAIHandler(options)
+			return new XAIHandler({
+				xaiApiKey: options.xaiApiKey,
+				reasoningEffort: options.reasoningEffort,
+				apiModelId: options.apiModelId,
+			})
 		case "sambanova":
-			return new SambanovaHandler(options)
+			return new SambanovaHandler({
+				sambanovaApiKey: options.sambanovaApiKey,
+				apiModelId: options.apiModelId,
+			})
 		case "cerebras":
-			return new CerebrasHandler(options)
+			return new CerebrasHandler({
+				cerebrasApiKey: options.cerebrasApiKey,
+				apiModelId: options.apiModelId,
+			})
+		case "groq":
+			return new GroqHandler({
+				groqApiKey: options.groqApiKey,
+				groqModelId: options.groqModelId,
+				groqModelInfo: options.groqModelInfo,
+				apiModelId: options.apiModelId,
+			})
 		case "sapaicore":
-			return new SapAiCoreHandler(options)
+			return new SapAiCoreHandler({
+				sapAiCoreClientId: options.sapAiCoreClientId,
+				sapAiCoreClientSecret: options.sapAiCoreClientSecret,
+				sapAiCoreTokenUrl: options.sapAiCoreTokenUrl,
+				sapAiResourceGroup: options.sapAiResourceGroup,
+				sapAiCoreBaseUrl: options.sapAiCoreBaseUrl,
+				apiModelId: options.apiModelId,
+			})
 		case "claude-code":
-			return new ClaudeCodeHandler(options)
+			return new ClaudeCodeHandler({
+				claudeCodePath: options.claudeCodePath,
+				apiModelId: options.apiModelId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 		default:
-			return new AnthropicHandler(options)
+			return new AnthropicHandler({
+				apiKey: options.apiKey,
+				anthropicBaseUrl: options.anthropicBaseUrl,
+				apiModelId: options.apiModelId,
+				thinkingBudgetTokens: options.thinkingBudgetTokens,
+			})
 	}
 }
+
+export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
+	const { apiProvider, ...options } = configuration
+
+	// Validate thinking budget tokens against model's maxTokens to prevent API errors
+	// wrapped in a try-catch for safety, but this should never throw
+	try {
+		if (options.thinkingBudgetTokens && options.thinkingBudgetTokens > 0) {
+			const handler = createHandlerForProvider(apiProvider, options)
+
+			const modelInfo = handler.getModel().info
+			if (modelInfo.maxTokens && options.thinkingBudgetTokens > modelInfo.maxTokens) {
+				const clippedValue = modelInfo.maxTokens - 1
+				options.thinkingBudgetTokens = clippedValue
+			} else {
+				return handler // don't rebuild unless its necessary
+			}
+		}
+	} catch (error) {
+		console.error("buildApiHandler error:", error)
+	}
+
+	return createHandlerForProvider(apiProvider, options)
+}

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

@@ -182,6 +182,24 @@ describe("AwsBedrockHandler", () => {
 
 			process.env["AWS_PROFILE"]!.should.equal(preAWSProfile)
 		})
+
+		it("should work with AWS_BEARER_TOKEN_BEDROCK", async () => {
+			process.env["AWS_BEARER_TOKEN_BEDROCK"] = "test-key"
+
+			const preAWSProfile = process.env["AWS_BEARER_TOKEN_BEDROCK"]
+
+			await AwsBedrockHandler["withTempEnv"](
+				() => {
+					delete process.env["AWS_BEARER_TOKEN_BEDROCK"]
+				},
+				async () => {
+					should.not.exist(process.env["AWS_BEARER_TOKEN_BEDROCK"])
+					return "test"
+				},
+			)
+
+			process.env["AWS_BEARER_TOKEN_BEDROCK"]!.should.equal(preAWSProfile)
+		})
 	})
 
 	const mockOptions: ApiHandlerOptions = {
@@ -192,6 +210,7 @@ describe("AwsBedrockHandler", () => {
 		awsSessionToken: "",
 		awsUseProfile: false,
 		awsProfile: "",
+		awsBedrockApiKey: "",
 		awsBedrockUsePromptCache: false,
 		awsUseCrossRegionInference: false,
 		awsBedrockEndpoint: "",

src/api/providers/__tests__/ollama.test.ts

@@ -45,8 +45,10 @@ describe("OllamaHandler", () => {
 				this.skip()
 			}
 			this.timeout(5000)
+			// Ensure client is initialized
+			const client = (handler as any).ensureClient()
 			// Mock the Ollama client's chat method
-			const chatStub = sinon.stub(handler["client"], "chat").resolves({
+			const chatStub = sinon.stub(client, "chat").resolves({
 				[Symbol.asyncIterator]: async function* () {
 					yield {
 						message: { content: "Hello, world!" },
@@ -139,8 +141,9 @@ describe("OllamaHandler", () => {
 			// Restore real timers for this test
 			clock.restore()
 
-			// Mock the Ollama client's chat method to fail on first call and succeed on second
-			const chatStub = sinon.stub(handler["client"], "chat")
+			// Ensure client is initialized and mock the Ollama client's chat method to fail on first call and succeed on second
+			const client = (handler as any).ensureClient()
+			const chatStub = sinon.stub(client, "chat")
 
 			// First call throws an error
 			chatStub.onFirstCall().rejects(new Error("API Error"))

src/api/providers/anthropic.ts

@@ -5,20 +5,42 @@ import { anthropicDefaultModelId, AnthropicModelId, anthropicModels, ApiHandlerO
 import { ApiHandler } from "../index"
 import { ApiStream } from "../transform/stream"
 
+interface AnthropicHandlerOptions {
+	apiKey?: string
+	anthropicBaseUrl?: string
+	apiModelId?: string
+	thinkingBudgetTokens?: number
+}
+
 export class AnthropicHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: Anthropic
+	private client: Anthropic | undefined
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: AnthropicHandlerOptions) {
 		this.options = options
-		this.client = new Anthropic({
-			apiKey: this.options.apiKey,
-			baseURL: this.options.anthropicBaseUrl || undefined,
-		})
+	}
+
+	private ensureClient(): Anthropic {
+		if (!this.client) {
+			if (!this.options.apiKey) {
+				throw new Error("Anthropic API key is required")
+			}
+			try {
+				this.client = new Anthropic({
+					apiKey: this.options.apiKey,
+					baseURL: this.options.anthropicBaseUrl || undefined,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Anthropic client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+
 		const model = this.getModel()
 		let stream: AnthropicStream<Anthropic.RawMessageStreamEvent>
 		const modelId = model.id
@@ -44,7 +66,7 @@ export class AnthropicHandler implements ApiHandler {
 				)
 				const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1
 				const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1
-				stream = await this.client.messages.create(
+				stream = await client.messages.create(
 					{
 						model: modelId,
 						thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
@@ -118,7 +140,7 @@ export class AnthropicHandler implements ApiHandler {
 				break
 			}
 			default: {
-				stream = await this.client.messages.create({
+				stream = await client.messages.create({
 					model: modelId,
 					max_tokens: model.info.maxTokens || 8192,
 					temperature: 0,

src/api/providers/asksage.ts

@@ -1,16 +1,15 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ApiHandler } from ".."
-import {
-	ApiHandlerOptions,
-	ModelInfo,
-	AskSageModelId,
-	askSageModels,
-	askSageDefaultModelId,
-	askSageDefaultURL,
-} from "@shared/api"
+import { ModelInfo, AskSageModelId, askSageModels, askSageDefaultModelId, askSageDefaultURL } from "@shared/api"
 import { ApiStream } from "../transform/stream"
 import { withRetry } from "../retry"
 
+interface AskSageHandlerOptions {
+	asksageApiKey?: string
+	asksageApiUrl?: string
+	apiModelId?: string
+}
+
 type AskSageRequest = {
 	system_prompt: string
 	message: {
@@ -31,11 +30,11 @@ type AskSageResponse = {
 }
 
 export class AskSageHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private options: AskSageHandlerOptions
 	private apiUrl: string
 	private apiKey: string
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: AskSageHandlerOptions) {
 		console.log("init api url", options.asksageApiUrl, askSageDefaultURL)
 		this.options = options
 		this.apiKey = options.asksageApiKey || ""

src/api/providers/bedrock.ts

@@ -2,7 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
 import { convertToR1Format } from "../transform/r1-format"
-import { ApiHandlerOptions, bedrockDefaultModelId, BedrockModelId, bedrockModels, ModelInfo } from "@shared/api"
+import { bedrockDefaultModelId, BedrockModelId, bedrockModels, ModelInfo } from "@shared/api"
 import { calculateApiCostOpenAI } from "../../utils/cost"
 import { ApiStream } from "../transform/stream"
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers"
@@ -16,6 +16,24 @@ import {
 // Import proper AWS SDK types
 import type { Message, ContentBlock } from "@aws-sdk/client-bedrock-runtime"
 
+interface AwsBedrockHandlerOptions {
+	apiModelId?: string
+	awsAccessKey?: string
+	awsSecretKey?: string
+	awsSessionToken?: string
+	awsRegion?: string
+	awsAuthentication?: string
+	awsBedrockApiKey?: string
+	awsUseCrossRegionInference?: boolean
+	awsBedrockUsePromptCache?: boolean
+	awsUseProfile?: boolean
+	awsProfile?: string
+	awsBedrockEndpoint?: string
+	awsBedrockCustomSelected?: boolean
+	awsBedrockCustomModelBaseId?: BedrockModelId
+	thinkingBudgetTokens?: number
+}
+
 // Extend AWS SDK types to include additionalModelResponseFields
 interface ExtendedMetadata {
 	usage?: {
@@ -90,9 +108,9 @@ interface ProviderChainOptions {
 
 // https://docs.anthropic.com/en/api/claude-on-amazon-bedrock
 export class AwsBedrockHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private options: AwsBedrockHandlerOptions
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: AwsBedrockHandlerOptions) {
 		this.options = options
 	}
 
@@ -170,7 +188,10 @@ export class AwsBedrockHandler implements ApiHandler {
 	}> {
 		// Configure provider options
 		const providerOptions: ProviderChainOptions = {}
-		if (this.options.awsUseProfile) {
+		const useProfile =
+			(this.options.awsAuthentication === undefined && this.options.awsUseProfile) ||
+			this.options.awsAuthentication === "profile"
+		if (useProfile) {
 			// For profile-based auth, always use ignoreCache to detect credential file changes
 			// This solves the AWS Identity Manager issue where credential files change externally
 			providerOptions.ignoreCache = true
@@ -184,7 +205,7 @@ export class AwsBedrockHandler implements ApiHandler {
 		return await AwsBedrockHandler.withTempEnv(
 			() => {
 				AwsBedrockHandler.setEnv("AWS_REGION", this.options.awsRegion)
-				if (this.options.awsUseProfile) {
+				if (useProfile) {
 					AwsBedrockHandler.setEnv("AWS_PROFILE", this.options.awsProfile)
 				} else {
 					delete process.env["AWS_PROFILE"]
@@ -208,15 +229,26 @@ export class AwsBedrockHandler implements ApiHandler {
 	 * Creates a BedrockRuntimeClient with the appropriate credentials
 	 */
 	private async getBedrockClient(): Promise<BedrockRuntimeClient> {
-		const credentials = await this.getAwsCredentials()
+		let auth: any
 
+		if (this.options.awsAuthentication === "apikey") {
+			auth = {
+				token: { token: this.options.awsBedrockApiKey },
+				authSchemePreference: ["httpBearerAuth"],
+			}
+		} else {
+			const credentials = await this.getAwsCredentials()
+			auth = {
+				credentials: {
+					accessKeyId: credentials.accessKeyId,
+					secretAccessKey: credentials.secretAccessKey,
+					sessionToken: credentials.sessionToken,
+				},
+			}
+		}
 		return new BedrockRuntimeClient({
 			region: this.getRegion(),
-			credentials: {
-				accessKeyId: credentials.accessKeyId,
-				secretAccessKey: credentials.secretAccessKey,
-				sessionToken: credentials.sessionToken,
-			},
+			...auth,
 			...(this.options.awsBedrockEndpoint && { endpoint: this.options.awsBedrockEndpoint }),
 		})
 	}

src/api/providers/cerebras.ts

@@ -1,38 +1,63 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import Cerebras from "@cerebras/cerebras_cloud_sdk"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, ModelInfo, CerebrasModelId, cerebrasDefaultModelId, cerebrasModels } from "@shared/api"
+import { ModelInfo, CerebrasModelId, cerebrasDefaultModelId, cerebrasModels } from "@shared/api"
 import { ApiHandler } from "../index"
 import { ApiStream } from "@api/transform/stream"
 
+interface CerebrasHandlerOptions {
+	cerebrasApiKey?: string
+	apiModelId?: string
+}
+
 export class CerebrasHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: Cerebras
+	private options: CerebrasHandlerOptions
+	private client: Cerebras | undefined
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: CerebrasHandlerOptions) {
 		this.options = options
+	}
 
-		// Clean and validate the API key
-		const cleanApiKey = this.options.cerebrasApiKey?.trim()
+	private ensureClient(): Cerebras {
+		if (!this.client) {
+			// Clean and validate the API key
+			const cleanApiKey = this.options.cerebrasApiKey?.trim()
 
-		if (!cleanApiKey) {
-			throw new Error("Cerebras API key is required")
+			if (!cleanApiKey) {
+				throw new Error("Cerebras API key is required")
+			}
+
+			try {
+				this.client = new Cerebras({
+					apiKey: cleanApiKey,
+					timeout: 30000, // 30 second timeout
+				})
+			} catch (error) {
+				throw new Error(`Error creating Cerebras client: ${error.message}`)
+			}
 		}
-
-		this.client = new Cerebras({
-			apiKey: cleanApiKey,
-			timeout: 30000, // 30 second timeout
-		})
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+
 		// Convert Anthropic messages to Cerebras format
 		const cerebrasMessages: Array<{
 			role: "system" | "user" | "assistant"
 			content: string
 		}> = [{ role: "system", content: systemPrompt }]
 
+		// Helper function to strip thinking tags from content
+		const stripThinkingTags = (content: string): string => {
+			return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim()
+		}
+
+		// Check if this is a reasoning model that uses thinking tags
+		const modelId = this.getModel().id
+		const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
+
 		// Convert Anthropic messages to Cerebras format
 		for (const message of messages) {
 			if (message.role === "user") {
@@ -50,7 +75,7 @@ export class CerebrasHandler implements ApiHandler {
 					: message.content
 				cerebrasMessages.push({ role: "user", content })
 			} else if (message.role === "assistant") {
-				const content = Array.isArray(message.content)
+				let content = Array.isArray(message.content)
 					? message.content
 							.map((block) => {
 								if (block.type === "text") {
@@ -60,12 +85,19 @@ export class CerebrasHandler implements ApiHandler {
 							})
 							.join("\n")
 					: message.content || ""
+
+				// Strip thinking tags from assistant messages for reasoning models
+				// so the model doesn't see its own thinking in the conversation history
+				if (isReasoningModel) {
+					content = stripThinkingTags(content)
+				}
+
 				cerebrasMessages.push({ role: "assistant", content })
 			}
 		}
 
 		try {
-			const stream = await this.client.chat.completions.create({
+			const stream = await client.chat.completions.create({
 				model: this.getModel().id,
 				messages: cerebrasMessages,
 				temperature: 0,
@@ -74,8 +106,6 @@ export class CerebrasHandler implements ApiHandler {
 
 			// Handle streaming response
 			let reasoning: string | null = null // Track reasoning content for models that support thinking
-			const modelId = this.getModel().id
-			const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
 
 			for await (const chunk of stream as any) {
 				// Type assertion for the streaming chunk

src/api/providers/claude-code.ts

@@ -1,15 +1,21 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
-import { claudeCodeDefaultModelId, ClaudeCodeModelId, claudeCodeModels, type ApiHandlerOptions } from "@/shared/api"
+import { claudeCodeDefaultModelId, ClaudeCodeModelId, claudeCodeModels } from "@/shared/api"
 import { type ApiHandler } from ".."
 import { ApiStreamUsageChunk, type ApiStream } from "../transform/stream"
 import { withRetry } from "../retry"
 import { runClaudeCode } from "@/integrations/claude-code/run"
-import { ClaudeCodeMessage } from "@/integrations/claude-code/types"
+import { filterMessagesForClaudeCode } from "@/integrations/claude-code/message-filter"
+
+interface ClaudeCodeHandlerOptions {
+	claudeCodePath?: string
+	apiModelId?: string
+	thinkingBudgetTokens?: number
+}
 
 export class ClaudeCodeHandler implements ApiHandler {
-	private options: ApiHandlerOptions
+	private options: ClaudeCodeHandlerOptions
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: ClaudeCodeHandlerOptions) {
 		this.options = options
 	}
 
@@ -19,37 +25,15 @@ export class ClaudeCodeHandler implements ApiHandler {
 		maxDelay: 15000,
 	})
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		// Filter out image blocks since Claude Code doesn't support them
+		const filteredMessages = filterMessagesForClaudeCode(messages)
+
 		const claudeProcess = runClaudeCode({
 			systemPrompt,
-			messages,
+			messages: filteredMessages,
 			path: this.options.claudeCodePath,
 			modelId: this.getModel().id,
-		})
-
-		const dataQueue: string[] = []
-		let processError = null
-		let errorOutput = ""
-		let exitCode: number | null = null
-
-		claudeProcess.stdout.on("data", (data) => {
-			const output = data.toString()
-			const lines = output.split("\n").filter((line: string) => line.trim() !== "")
-
-			for (const line of lines) {
-				dataQueue.push(line)
-			}
-		})
-
-		claudeProcess.stderr.on("data", (data) => {
-			errorOutput += data.toString()
-		})
-
-		claudeProcess.on("close", (code) => {
-			exitCode = code
-		})
-
-		claudeProcess.on("error", (error) => {
-			processError = error
+			thinkingBudgetTokens: this.options.thinkingBudgetTokens,
 		})
 
 		// Usage is included with assistant messages,
@@ -62,61 +46,75 @@ export class ClaudeCodeHandler implements ApiHandler {
 			cacheWriteTokens: 0,
 		}
 
-		while (exitCode !== 0 || dataQueue.length > 0) {
-			if (dataQueue.length === 0) {
-				await new Promise((resolve) => setImmediate(resolve))
-			}
+		let isPaidUsage = true
 
-			if (exitCode !== null && exitCode !== 0) {
-				throw new Error(
-					`Claude Code process exited with code ${exitCode}.${errorOutput ? ` Error output: ${errorOutput.trim()}` : ""}`,
-				)
-			}
-
-			const data = dataQueue.shift()
-			if (!data) {
-				continue
-			}
-
-			const chunk = this.attemptParseChunk(data)
-
-			if (!chunk) {
+		for await (const chunk of claudeProcess) {
+			if (typeof chunk === "string") {
 				yield {
 					type: "text",
-					text: data || "",
+					text: chunk,
 				}
 
 				continue
 			}
 
 			if (chunk.type === "system" && chunk.subtype === "init") {
+				// Based on my tests, subscription usage sets the `apiKeySource` to "none"
+				isPaidUsage = chunk.apiKeySource !== "none"
 				continue
 			}
 
 			if (chunk.type === "assistant" && "message" in chunk) {
 				const message = chunk.message
 
-				if (message.stop_reason !== null && message.stop_reason !== "tool_use") {
-					const errorMessage = message.content[0]?.text || `Claude Code stopped with reason: ${message.stop_reason}`
+				if (message.stop_reason !== null) {
+					const content = "text" in message.content[0] ? message.content[0] : undefined
 
-					if (errorMessage.includes("Invalid model name")) {
-						throw new Error(
-							errorMessage +
-								`\n\nAPI keys and subscription plans allow different models. Make sure the selected model is included in your plan.`,
-						)
+					const isError = content && content.text.startsWith(`API Error`)
+					if (isError) {
+						// Error messages are formatted as: `API Error: <<status code>> <<json>>`
+						const errorMessageStart = content.text.indexOf("{")
+						const errorMessage = content.text.slice(errorMessageStart)
+
+						const error = this.attemptParse(errorMessage)
+						if (!error) {
+							throw new Error(content.text)
+						}
+
+						if (error.error.message.includes("Invalid model name")) {
+							throw new Error(
+								content.text +
+									`\n\nAPI keys and subscription plans allow different models. Make sure the selected model is included in your plan.`,
+							)
+						}
+
+						throw new Error(errorMessage)
 					}
-
-					throw new Error(errorMessage)
 				}
 
 				for (const content of message.content) {
-					if (content.type === "text") {
-						yield {
-							type: "text",
-							text: content.text,
-						}
-					} else {
-						console.warn("Unsupported content type:", content.type)
+					switch (content.type) {
+						case "text":
+							yield {
+								type: "text",
+								text: content.text,
+							}
+							break
+						case "thinking":
+							yield {
+								type: "reasoning",
+								reasoning: content.thinking || "",
+							}
+							break
+						case "redacted_thinking":
+							yield {
+								type: "reasoning",
+								reasoning: "[Redacted thinking block]",
+							}
+							break
+						case "tool_use":
+							console.error(`tool_use is not supported yet. Received: ${JSON.stringify(content)}`)
+							break
 					}
 				}
 
@@ -129,14 +127,18 @@ export class ClaudeCodeHandler implements ApiHandler {
 			}
 
 			if (chunk.type === "result" && "result" in chunk) {
-				usage.totalCost = chunk.cost_usd || 0
+				usage.totalCost = isPaidUsage ? chunk.total_cost_usd : 0
 
 				yield usage
 			}
+		}
+	}
 
-			if (processError) {
-				throw processError
-			}
+	private attemptParse(str: string) {
+		try {
+			return JSON.parse(str)
+		} catch (err) {
+			return null
 		}
 	}
 
@@ -152,14 +154,4 @@ export class ClaudeCodeHandler implements ApiHandler {
 			info: claudeCodeModels[claudeCodeDefaultModelId],
 		}
 	}
-
-	// TOOD: Validate instead of parsing
-	private attemptParseChunk(data: string): ClaudeCodeMessage | null {
-		try {
-			return JSON.parse(data)
-		} catch (error) {
-			console.error("Error parsing chunk:", error)
-			return null
-		}
-	}
 }

src/api/providers/cline.ts

@@ -1,129 +1,231 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
+import { ClineAccountService } from "@/services/account/ClineAccountService"
+import { ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
 import axios from "axios"
 import { OpenRouterErrorResponse } from "./types"
 import { withRetry } from "../retry"
+import { AuthService } from "@/services/auth/AuthService"
+import OpenAI from "openai"
+import { version as extensionVersion } from "../../../package.json"
+import { shouldSkipReasoningForModel } from "@utils/model-utils"
+import { CLINE_ACCOUNT_AUTH_ERROR_MESSAGE } from "@/shared/ClineAccount"
+import { clineEnvConfig } from "@/config"
+
+interface ClineHandlerOptions {
+	taskId?: string
+	reasoningEffort?: string
+	thinkingBudgetTokens?: number
+	openRouterProviderSorting?: string
+	openRouterModelId?: string
+	openRouterModelInfo?: ModelInfo
+	clineAccountId?: string
+}
 
 export class ClineHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+	private options: ClineHandlerOptions
+	private clineAccountService = ClineAccountService.getInstance()
+	private _authService: AuthService
+	private client: OpenAI | undefined
+	private readonly _baseUrl = clineEnvConfig.apiBaseUrl
 	lastGenerationId?: string
+	private counter = 0
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: ClineHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.cline.bot/v1",
-			apiKey: this.options.clineApiKey || "",
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot", // Optional, for including your app on cline.bot rankings.
-				"X-Title": "Cline", // Optional. Shows in rankings on cline.bot.
-				"X-Task-ID": this.options.taskId || "", // Include the task ID in the request headers
-			},
-		})
+		this._authService = AuthService.getInstance()
+	}
+
+	private async ensureClient(): Promise<OpenAI> {
+		const clineAccountAuthToken = await this._authService.getAuthToken()
+		if (!clineAccountAuthToken) {
+			throw new Error(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE)
+		}
+		if (!this.client) {
+			try {
+				this.client = new OpenAI({
+					baseURL: `${this._baseUrl}/api/v1`,
+					apiKey: clineAccountAuthToken,
+					defaultHeaders: {
+						"HTTP-Referer": "https://cline.bot",
+						"X-Title": "Cline",
+						"X-Task-ID": this.options.taskId || "",
+						"X-Cline-Version": extensionVersion,
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Cline client: ${error.message}`)
+			}
+		}
+		// Ensure the client is always using the latest auth token
+		this.client.apiKey = clineAccountAuthToken
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		this.lastGenerationId = undefined
+		try {
+			const client = await this.ensureClient()
 
-		const stream = await createOpenRouterStream(
-			this.client,
-			systemPrompt,
-			messages,
-			this.getModel(),
-			this.options.reasoningEffort,
-			this.options.thinkingBudgetTokens,
-			this.options.openRouterProviderSorting,
-		)
+			this.lastGenerationId = undefined
 
-		let didOutputUsage: boolean = false
+			let didOutputUsage: boolean = false
 
-		for await (const chunk of stream) {
-			// openrouter returns an error object instead of the openai sdk throwing an error
-			if ("error" in chunk) {
-				const error = chunk.error as OpenRouterErrorResponse["error"]
-				console.error(`Cline API Error: ${error?.code} - ${error?.message}`)
-				// Include metadata in the error message if available
-				const metadataStr = error.metadata ? `\nMetadata: ${JSON.stringify(error.metadata, null, 2)}` : ""
-				throw new Error(`Cline API Error ${error.code}: ${error.message}${metadataStr}`)
-			}
+			const stream = await createOpenRouterStream(
+				client,
+				systemPrompt,
+				messages,
+				this.getModel(),
+				this.options.reasoningEffort,
+				this.options.thinkingBudgetTokens,
+				this.options.openRouterProviderSorting,
+			)
 
-			if (!this.lastGenerationId && chunk.id) {
-				this.lastGenerationId = chunk.id
-			}
-
-			const delta = chunk.choices[0]?.delta
-			if (delta?.content) {
-				yield {
-					type: "text",
-					text: delta.content,
+			for await (const chunk of stream) {
+				// openrouter returns an error object instead of the openai sdk throwing an error
+				if ("error" in chunk) {
+					const error = chunk.error as OpenRouterErrorResponse["error"]
+					console.error(`Cline API Error: ${error?.code} - ${error?.message}`)
+					// Include metadata in the error message if available
+					const metadataStr = error.metadata ? `\nMetadata: ${JSON.stringify(error.metadata, null, 2)}` : ""
+					throw new Error(`Cline API Error ${error.code}: ${error.message}${metadataStr}`)
+				}
+				if (!this.lastGenerationId && chunk.id) {
+					this.lastGenerationId = chunk.id
 				}
-			}
 
-			// Reasoning tokens are returned separately from the content
-			if ("reasoning" in delta && delta.reasoning) {
-				yield {
-					type: "reasoning",
+				// Check for mid-stream error via finish_reason
+				const choice = chunk.choices?.[0]
+				// OpenRouter may return finish_reason = "error" with error details
+				if ((choice?.finish_reason as string) === "error") {
+					const choiceWithError = choice as any
+					if (choiceWithError.error) {
+						const error = choiceWithError.error
+						console.error(`Cline Mid-Stream Error: ${error.code || error.type || "Unknown"} - ${error.message}`)
+						throw new Error(`Cline Mid-Stream Error: ${error.code || error.type || "Unknown"} - ${error.message}`)
+					} else {
+						throw new Error(
+							"Cline Mid-Stream Error: Stream terminated with error status but no error details provided",
+						)
+					}
+				}
+
+				const delta = choice?.delta
+				if (delta?.content) {
+					yield {
+						type: "text",
+						text: delta.content,
+					}
+				}
+
+				// Reasoning tokens are returned separately from the content
+				// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
+				if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
+					yield {
+						type: "reasoning",
+						// @ts-ignore-next-line
+						reasoning: delta.reasoning,
+					}
+				}
+
+				if (!didOutputUsage && chunk.usage) {
 					// @ts-ignore-next-line
-					reasoning: delta.reasoning,
+					let totalCost = (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0)
+					const modelId = this.getModel().id
+
+					// const provider = modelId.split("/")[0]
+					// // If provider is x-ai, set totalCost to 0 (we're doing a promo)
+					// if (provider === "x-ai") {
+					// 	totalCost = 0
+					// }
+
+					if (modelId.includes("gemini")) {
+						yield {
+							type: "usage",
+							cacheWriteTokens: 0,
+							cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+							inputTokens:
+								(chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+							outputTokens: chunk.usage.completion_tokens || 0,
+							// @ts-ignore-next-line
+							totalCost,
+						}
+					} else {
+						yield {
+							type: "usage",
+							cacheWriteTokens: 0,
+							cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+							inputTokens: chunk.usage.prompt_tokens || 0,
+							outputTokens: chunk.usage.completion_tokens || 0,
+							// @ts-ignore-next-line
+							totalCost,
+						}
+					}
+					didOutputUsage = true
 				}
 			}
 
-			if (!didOutputUsage && chunk.usage) {
-				// @ts-ignore-next-line
-				let totalCost = chunk.usage.cost || 0
-				const modelId = this.getModel().id
-				const provider = modelId.split("/")[0]
-
-				// If provider is x-ai, set totalCost to 0 (we're doing a promo)
-				if (provider === "x-ai") {
-					totalCost = 0
+			// Fallback to generation endpoint if usage chunk not returned
+			if (!didOutputUsage) {
+				console.warn("Cline API did not return usage chunk, fetching from generation endpoint")
+				const apiStreamUsage = await this.getApiStreamUsage()
+				if (apiStreamUsage) {
+					yield apiStreamUsage
 				}
-
-				yield {
-					type: "usage",
-					cacheWriteTokens: 0,
-					cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-					inputTokens: chunk.usage.prompt_tokens || 0,
-					outputTokens: chunk.usage.completion_tokens || 0,
-					// @ts-ignore-next-line
-					totalCost,
+			}
+		} catch (error) {
+			console.error("Cline API Error:", error)
+			const requestId = error?.request_id ? `\n | Request ID: ${error.request_id}` : ""
+			if (error.code === "ERR_BAD_REQUEST" || error.status === 401) {
+				throw new Error(CLINE_ACCOUNT_AUTH_ERROR_MESSAGE + requestId)
+			} else if (error.code === "insufficient_credits" || error.status === 402) {
+				if (error.error) {
+					throw new Error(JSON.stringify(error.error))
 				}
-				didOutputUsage = true
-			}
-		}
-
-		// Fallback to generation endpoint if usage chunk not returned
-		if (!didOutputUsage) {
-			const apiStreamUsage = await this.getApiStreamUsage()
-			if (apiStreamUsage) {
-				yield apiStreamUsage
 			}
+			const _error = error instanceof Error ? error : new Error(String(error))
+			_error.message = _error.message + requestId
+			throw _error
 		}
 	}
 
 	async getApiStreamUsage(): Promise<ApiStreamUsageChunk | undefined> {
 		if (this.lastGenerationId) {
 			try {
-				const response = await axios.get(`https://api.cline.bot/v1/generation?id=${this.lastGenerationId}`, {
+				// TODO: replace this with firebase auth
+				// TODO: use global API Host
+
+				const response = await axios.get(`${this.clineAccountService.baseUrl}/generation?id=${this.lastGenerationId}`, {
 					headers: {
-						Authorization: `Bearer ${this.options.clineApiKey}`,
+						Authorization: `Bearer ${this.options.clineAccountId}`,
 					},
 					timeout: 15_000, // this request hangs sometimes
 				})
 
 				const generation = response.data
-				return {
-					type: "usage",
-					cacheWriteTokens: 0,
-					cacheReadTokens: generation?.native_tokens_cached || 0,
-					inputTokens: generation?.native_tokens_prompt || 0,
-					outputTokens: generation?.native_tokens_completion || 0,
-					totalCost: generation?.total_cost || 0,
+				let modelId = this.options.openRouterModelId
+				if (modelId && modelId.includes("gemini")) {
+					return {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: generation?.native_tokens_cached || 0,
+						// openrouter generation endpoint fails often
+						inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
+						outputTokens: generation?.native_tokens_completion || 0,
+						totalCost: generation?.total_cost || 0,
+					}
+				} else {
+					return {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: generation?.native_tokens_cached || 0,
+						// openrouter generation endpoint fails often
+						inputTokens: generation?.native_tokens_prompt || 0,
+						outputTokens: generation?.native_tokens_completion || 0,
+						totalCost: generation?.total_cost || 0,
+					}
 				}
 			} catch (error) {
 				// ignore if fails
@@ -135,9 +237,6 @@ export class ClineHandler implements ApiHandler {
 
 	getModel(): { id: string; info: ModelInfo } {
 		let modelId = this.options.openRouterModelId
-		if (modelId === "x-ai/grok-3") {
-			modelId = "x-ai/grok-3-beta"
-		}
 		const modelInfo = this.options.openRouterModelInfo
 		if (modelId && modelInfo) {
 			return { id: modelId, info: modelInfo }

src/api/providers/deepseek.ts

@@ -8,16 +8,34 @@ import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { convertToR1Format } from "../transform/r1-format"
 
-export class DeepSeekHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface DeepSeekHandlerOptions {
+	deepSeekApiKey?: string
+	apiModelId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class DeepSeekHandler implements ApiHandler {
+	private options: DeepSeekHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: DeepSeekHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.deepseek.com/v1",
-			apiKey: this.options.deepSeekApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.deepSeekApiKey) {
+				throw new Error("DeepSeek API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.deepseek.com/v1",
+					apiKey: this.options.deepSeekApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating DeepSeek client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
@@ -54,6 +72,7 @@ export class DeepSeekHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const isDeepseekReasoner = model.id.includes("deepseek-reasoner")
@@ -67,7 +86,7 @@ export class DeepSeekHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/doubao.ts

@@ -1,20 +1,38 @@
 import { ApiHandler } from ".."
-import { ApiHandlerOptions, doubaoDefaultModelId, DoubaoModelId, doubaoModels, ModelInfo } from "@shared/api"
+import { doubaoDefaultModelId, DoubaoModelId, doubaoModels, ModelInfo } from "@shared/api"
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { withRetry } from "../retry"
 
+interface DoubaoHandlerOptions {
+	doubaoApiKey?: string
+	apiModelId?: string
+}
+
 export class DoubaoHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
-	constructor(options: ApiHandlerOptions) {
+	private options: DoubaoHandlerOptions
+	private client: OpenAI | undefined
+	constructor(options: DoubaoHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://ark.cn-beijing.volces.com/api/v3/",
-			apiKey: this.options.doubaoApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.doubaoApiKey) {
+				throw new Error("Doubao API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://ark.cn-beijing.volces.com/api/v3/",
+					apiKey: this.options.doubaoApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Doubao client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	getModel(): { id: DoubaoModelId; info: ModelInfo } {
@@ -31,12 +49,13 @@ export class DoubaoHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },
 			...convertToOpenAiMessages(messages),
 		]
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/fireworks.ts

@@ -2,31 +2,45 @@ 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 { ModelInfo, 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
+interface FireworksHandlerOptions {
+	fireworksApiKey?: string
+	fireworksModelId?: string
+	fireworksModelMaxCompletionTokens?: number
+	fireworksModelMaxTokens?: number
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class FireworksHandler implements ApiHandler {
+	private options: FireworksHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: FireworksHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.fireworks.ai/inference/v1",
-			apiKey: this.options.fireworksApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.fireworksApiKey) {
+				throw new Error("Fireworks API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.fireworks.ai/inference/v1",
+					apiKey: this.options.fireworksApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Fireworks client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.options.fireworksModelId ?? ""
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -34,7 +48,7 @@ export class FireworksHandler implements ApiHandler {
 			...convertToOpenAiMessages(messages),
 		]
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			...(this.options.fireworksModelMaxCompletionTokens
 				? { max_completion_tokens: this.options.fireworksModelMaxCompletionTokens }

src/api/providers/gemini.ts

@@ -12,8 +12,15 @@ 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
 
-interface GeminiHandlerOptions extends ApiHandlerOptions {
+interface GeminiHandlerOptions {
 	isVertex?: boolean
+	vertexProjectId?: string
+	vertexRegion?: string
+	geminiApiKey?: string
+	geminiBaseUrl?: string
+	thinkingBudgetTokens?: number
+	apiModelId?: string
+	taskId?: string
 }
 
 /**
@@ -38,30 +45,45 @@ interface GeminiHandlerOptions extends ApiHandlerOptions {
  */
 export class GeminiHandler implements ApiHandler {
 	private options: ApiHandlerOptions
-	private client: GoogleGenAI
+	private client: GoogleGenAI | undefined
 
 	constructor(options: GeminiHandlerOptions) {
 		// Store the options
 		this.options = options
+	}
 
-		if (options.isVertex) {
-			// Initialize with Vertex AI configuration
-			const project = this.options.vertexProjectId ?? "not-provided"
-			const location = this.options.vertexRegion ?? "not-provided"
+	private ensureClient(): GoogleGenAI {
+		if (!this.client) {
+			const options = this.options as GeminiHandlerOptions
 
-			this.client = new GoogleGenAI({
-				vertexai: true,
-				project,
-				location,
-			})
-		} else {
-			// Initialize with standard API key
-			if (!options.geminiApiKey) {
-				throw new Error("API key is required for Google Gemini when not using Vertex AI")
+			if (options.isVertex) {
+				// Initialize with Vertex AI configuration
+				const project = this.options.vertexProjectId ?? "not-provided"
+				const location = this.options.vertexRegion ?? "not-provided"
+
+				try {
+					this.client = new GoogleGenAI({
+						vertexai: true,
+						project,
+						location,
+					})
+				} catch (error) {
+					throw new Error(`Error creating Gemini Vertex AI client: ${error.message}`)
+				}
+			} else {
+				// Initialize with standard API key
+				if (!options.geminiApiKey) {
+					throw new Error("API key is required for Google Gemini when not using Vertex AI")
+				}
+
+				try {
+					this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
+				} catch (error) {
+					throw new Error(`Error creating Gemini client: ${error.message}`)
+				}
 			}
-
-			this.client = new GoogleGenAI({ apiKey: options.geminiApiKey })
 		}
+		return this.client
 	}
 
 	/**
@@ -80,6 +102,7 @@ export class GeminiHandler implements ApiHandler {
 		maxDelay: 15000,
 	})
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const { id: modelId, info } = this.getModel()
 		const contents = messages.map(convertAnthropicMessageToGemini)
 
@@ -117,7 +140,7 @@ export class GeminiHandler implements ApiHandler {
 		let lastUsageMetadata: GenerateContentResponseUsageMetadata | undefined
 
 		try {
-			const result = await this.client.models.generateContentStream({
+			const result = await client.models.generateContentStream({
 				model: modelId,
 				contents: contents,
 				config: {
@@ -233,23 +256,18 @@ export class GeminiHandler implements ApiHandler {
 				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,
-				)
+				telemetryService.captureGeminiApiPerformance(this.options.taskId, modelId, {
+					ttftSec: ttftSdkMs !== undefined ? ttftSdkMs / 1000 : undefined,
+					totalDurationSec: totalDurationSdkMs / 1000,
+					promptTokens,
+					outputTokens,
+					cacheReadTokens,
+					cacheHit,
+					cacheHitPercentage,
+					apiSuccess,
+					apiError,
+					throughputTokensPerSec: throughputTokensPerSecSdk,
+				})
 			} else {
 				console.warn("GeminiHandler: taskId not available for telemetry in createMessage.")
 			}
@@ -351,6 +369,7 @@ export class GeminiHandler implements ApiHandler {
 	 */
 	async countTokens(content: Array<any>): Promise<number> {
 		try {
+			const client = this.ensureClient()
 			const { id: model } = this.getModel()
 
 			// Convert content to Gemini format
@@ -362,7 +381,7 @@ export class GeminiHandler implements ApiHandler {
 			})
 
 			// Use Gemini's token counting API
-			const response = await this.client.models.countTokens({
+			const response = await client.models.countTokens({
 				model,
 				contents: [{ parts: geminiContent }],
 			})

src/api/providers/groq.ts

@@ -0,0 +1,290 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { withRetry } from "../retry"
+import { ApiHandler } from "../"
+import { GroqModelId, ModelInfo, groqDefaultModelId, groqModels } from "@shared/api"
+import { calculateApiCostOpenAI } from "../../utils/cost"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+
+interface GroqHandlerOptions {
+	groqApiKey?: string
+	groqModelId?: string
+	groqModelInfo?: ModelInfo
+	apiModelId?: string // For backward compatibility
+}
+
+// Model family definitions for enhanced behavior
+interface GroqModelFamily {
+	name: string
+	supportedFeatures: {
+		streaming: boolean
+		temperature: boolean
+		vision: boolean
+		tools: boolean
+	}
+	maxTokensOverride?: number
+	specialParams?: Record<string, any>
+}
+
+const MODEL_FAMILIES: Record<string, GroqModelFamily> = {
+	// Moonshort 4 Family - Latest generation with vision support
+	"kimi-k2": {
+		name: "kimi-k2",
+		supportedFeatures: { streaming: true, temperature: true, vision: true, tools: true },
+		maxTokensOverride: 8192,
+	},
+	// Llama 4 Family - Latest generation with vision support
+	llama4: {
+		name: "Llama 4",
+		supportedFeatures: { streaming: true, temperature: true, vision: true, tools: true },
+		maxTokensOverride: 8192,
+	},
+	// Llama 3.3 Family - Balanced performance
+	"llama3.3": {
+		name: "Llama 3.3",
+		supportedFeatures: { streaming: true, temperature: true, vision: false, tools: true },
+		maxTokensOverride: 32768,
+	},
+	// Llama 3.1 Family - Fast inference
+	"llama3.1": {
+		name: "Llama 3.1",
+		supportedFeatures: { streaming: true, temperature: true, vision: false, tools: true },
+		maxTokensOverride: 131072,
+	},
+	// DeepSeek Family - Reasoning-optimized
+	deepseek: {
+		name: "DeepSeek",
+		supportedFeatures: { streaming: true, temperature: true, vision: false, tools: true },
+		maxTokensOverride: 8192,
+		specialParams: {
+			top_p: 0.95,
+			reasoning_format: "parsed",
+		},
+	},
+	// Qwen Family - Enhanced for Q&A
+	qwen: {
+		name: "Qwen",
+		supportedFeatures: { streaming: true, temperature: true, vision: false, tools: true },
+		maxTokensOverride: 32768,
+	},
+	// Compound Models - Hybrid architectures
+	compound: {
+		name: "Compound",
+		supportedFeatures: { streaming: true, temperature: true, vision: false, tools: true },
+		maxTokensOverride: 8192,
+	},
+}
+
+export class GroqHandler implements ApiHandler {
+	private options: GroqHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: GroqHandlerOptions) {
+		this.options = options
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.groqApiKey) {
+				throw new Error("Groq API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.groq.com/openai/v1",
+					apiKey: this.options.groqApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Groq client: ${error.message}`)
+			}
+		}
+		return this.client
+	}
+
+	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
+		const inputTokens = usage?.prompt_tokens || 0
+		const outputTokens = usage?.completion_tokens || 0
+		const totalCost = calculateApiCostOpenAI(info, inputTokens, outputTokens)
+		yield {
+			type: "usage",
+			inputTokens,
+			outputTokens,
+			cacheWriteTokens: 0,
+			cacheReadTokens: 0,
+			totalCost,
+		}
+	}
+
+	/**
+	 * Detects the model family based on the model ID
+	 */
+	private detectModelFamily(modelId: string): GroqModelFamily {
+		if (modelId.includes("kimi-k2")) {
+			return MODEL_FAMILIES["kimi-k2"]
+		}
+		// Llama 4 variants
+		if (modelId.includes("llama-4") || modelId.includes("llama/llama-4")) {
+			return MODEL_FAMILIES.llama4
+		}
+		// Llama 3.3 variants
+		if (modelId.includes("llama-3.3")) {
+			return MODEL_FAMILIES["llama3.3"]
+		}
+		// Llama 3.1 variants
+		if (modelId.includes("llama-3.1")) {
+			return MODEL_FAMILIES["llama3.1"]
+		}
+		// DeepSeek variants
+		if (modelId.includes("deepseek")) {
+			return MODEL_FAMILIES.deepseek
+		}
+		// Qwen variants
+		if (modelId.includes("qwen")) {
+			return MODEL_FAMILIES.qwen
+		}
+		// Compound variants
+		if (modelId.includes("compound")) {
+			return MODEL_FAMILIES.compound
+		}
+
+		// Default fallback to Llama 3.3 behavior
+		return MODEL_FAMILIES["kimi-k2"]
+	}
+
+	/**
+	 * Gets the optimal max_tokens based on model family and capabilities
+	 */
+	private getOptimalMaxTokens(model: { id: string; info: ModelInfo }, modelFamily: GroqModelFamily): number {
+		// Use model-specific max tokens if available
+		if (model.info.maxTokens && model.info.maxTokens > 0) {
+			return model.info.maxTokens
+		}
+
+		// Use family override if available
+		if (modelFamily.maxTokensOverride) {
+			return modelFamily.maxTokensOverride
+		}
+
+		// Default fallback
+		return 8192
+	}
+
+	@withRetry()
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+		const model = this.getModel()
+		const modelFamily = this.detectModelFamily(model.id)
+
+		// Optimize parameters based on model family
+		const temperature = 0
+		const maxTokens = this.getOptimalMaxTokens(model, modelFamily)
+
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+
+		// Build request parameters with model-specific optimizations
+		const requestParams: OpenAI.Chat.ChatCompletionCreateParamsStreaming & {
+			reasoning_format?: "parsed" | "raw" | "hidden"
+			top_p?: number
+		} = {
+			model: model.id,
+			max_tokens: maxTokens,
+			messages: openAiMessages,
+			stream: true,
+			stream_options: { include_usage: true },
+			temperature,
+		}
+
+		// Add any special parameters for specific model families
+		if (modelFamily.specialParams) {
+			Object.assign(requestParams, modelFamily.specialParams)
+		}
+
+		const stream = await client.chat.completions.create(requestParams)
+
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+
+			// Handle reasoning field if present (for reasoning models with parsed output)
+			if ((delta as any)?.reasoning) {
+				const reasoningContent = (delta as any).reasoning as string
+				yield {
+					type: "reasoning",
+					reasoning: reasoningContent,
+				}
+				continue
+			}
+
+			// Handle content field - trust the parsed output from Groq
+			if (delta?.content) {
+				yield {
+					type: "text",
+					text: delta.content,
+				}
+			}
+
+			// Handle usage information
+			if (chunk.usage) {
+				yield* this.yieldUsage(model.info, chunk.usage)
+			}
+		}
+	}
+
+	/**
+	 * Checks if the current model supports vision/images
+	 */
+	supportsImages(): boolean {
+		const model = this.getModel()
+		return model.info.supportsImages === true
+	}
+
+	/**
+	 * Checks if the current model supports tools
+	 */
+	supportsTools(): boolean {
+		const model = this.getModel()
+		const modelFamily = this.detectModelFamily(model.id)
+		return modelFamily.supportedFeatures.tools
+	}
+
+	/**
+	 * Gets model information with enhanced family detection
+	 */
+	getModel(): { id: string; info: ModelInfo } {
+		// First priority: groqModelId and groqModelInfo (like Requesty does)
+		const groqModelId = this.options.groqModelId
+		const groqModelInfo = this.options.groqModelInfo
+		if (groqModelId && groqModelInfo) {
+			return { id: groqModelId, info: groqModelInfo }
+		}
+
+		// Second priority: groqModelId with static model info
+		if (groqModelId && groqModelId in groqModels) {
+			const id = groqModelId as GroqModelId
+			return { id, info: groqModels[id] }
+		}
+
+		// Third priority: apiModelId (for backward compatibility)
+		const apiModelId = this.options.apiModelId
+		if (apiModelId && apiModelId in groqModels) {
+			const id = apiModelId as GroqModelId
+			return { id, info: groqModels[id] }
+		}
+
+		// Default fallback
+		return {
+			id: groqDefaultModelId,
+			info: groqModels[groqDefaultModelId],
+		}
+	}
+
+	/**
+	 * Gets model family information for debugging/introspection
+	 */
+	getModelFamily(): GroqModelFamily {
+		const model = this.getModel()
+		return this.detectModelFamily(model.id)
+	}
+}

src/api/providers/litellm.ts

@@ -1,28 +1,52 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
-import { ApiHandlerOptions, liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults } from "@shared/api"
+import { liteLlmDefaultModelId, liteLlmModelInfoSaneDefaults, LiteLLMModelInfo } from "@shared/api"
 import { ApiHandler } from ".."
 import { ApiStream } from "../transform/stream"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { withRetry } from "../retry"
 
-export class LiteLlmHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface LiteLlmHandlerOptions {
+	liteLlmApiKey?: string
+	liteLlmBaseUrl?: string
+	liteLlmModelId?: string
+	liteLlmModelInfo?: LiteLLMModelInfo
+	thinkingBudgetTokens?: number
+	liteLlmUsePromptCache?: boolean
+	taskId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class LiteLlmHandler implements ApiHandler {
+	private options: LiteLlmHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: LiteLlmHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: this.options.liteLlmBaseUrl || "http://localhost:4000",
-			apiKey: this.options.liteLlmApiKey || "noop",
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.liteLlmApiKey) {
+				throw new Error("LiteLLM API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: this.options.liteLlmBaseUrl || "http://localhost:4000",
+					apiKey: this.options.liteLlmApiKey || "noop",
+				})
+			} catch (error) {
+				throw new Error(`Error creating LiteLLM client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	async calculateCost(prompt_tokens: number, completion_tokens: number): Promise<number | undefined> {
 		// Reference: https://github.com/BerriAI/litellm/blob/122ee634f434014267af104814022af1d9a0882f/litellm/proxy/spend_tracking/spend_management_endpoints.py#L1473
+		const client = this.ensureClient()
 		const modelId = this.options.liteLlmModelId || liteLlmDefaultModelId
 		try {
-			const response = await fetch(`${this.client.baseURL}/spend/calculate`, {
+			const response = await fetch(`${client.baseURL}/spend/calculate`, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -54,6 +78,7 @@ export class LiteLlmHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const formattedMessages = convertToOpenAiMessages(messages)
 		const systemMessage: OpenAI.Chat.ChatCompletionSystemMessageParam = {
 			role: "system",
@@ -101,13 +126,14 @@ export class LiteLlmHandler implements ApiHandler {
 			return message
 		})
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: this.options.liteLlmModelId || liteLlmDefaultModelId,
 			messages: [enhancedSystemMessage, ...enhancedMessages],
 			temperature,
 			stream: true,
 			stream_options: { include_usage: true },
 			...(thinkingConfig && { thinking: thinkingConfig }), // Add thinking configuration when applicable
+			...(this.options.taskId && { litellm_session_id: `cline-${this.options.taskId}` }), // Add session ID for LiteLLM tracking
 		})
 
 		const inputCost = (await this.calculateCost(1e6, 0)) || 0

src/api/providers/lmstudio.ts

@@ -6,27 +6,43 @@ import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { withRetry } from "../retry"
 
-export class LmStudioHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface LmStudioHandlerOptions {
+	lmStudioBaseUrl?: string
+	lmStudioModelId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class LmStudioHandler implements ApiHandler {
+	private options: LmStudioHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: LmStudioHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: (this.options.lmStudioBaseUrl || "http://localhost:1234") + "/v1",
-			apiKey: "noop",
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			try {
+				this.client = new OpenAI({
+					baseURL: (this.options.lmStudioBaseUrl || "http://localhost:1234") + "/v1",
+					apiKey: "noop",
+				})
+			} catch (error) {
+				throw new Error(`Error creating LM Studio client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry({ retryAllErrors: true })
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
 			{ role: "system", content: systemPrompt },
 			...convertToOpenAiMessages(messages),
 		]
 
 		try {
-			const stream = await this.client.chat.completions.create({
+			const stream = await client.chat.completions.create({
 				model: this.getModel().id,
 				messages: openAiMessages,
 				stream: true,

src/api/providers/mistral.ts

@@ -2,24 +2,43 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import { Mistral } from "@mistralai/mistralai"
 import { withRetry } from "../retry"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, mistralDefaultModelId, MistralModelId, mistralModels, ModelInfo } from "@shared/api"
+import { mistralDefaultModelId, MistralModelId, mistralModels, ModelInfo } from "@shared/api"
 import { convertToMistralMessages } from "../transform/mistral-format"
 import { ApiStream } from "../transform/stream"
 
-export class MistralHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: Mistral
+interface MistralHandlerOptions {
+	mistralApiKey?: string
+	apiModelId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class MistralHandler implements ApiHandler {
+	private options: MistralHandlerOptions
+	private client: Mistral | undefined
+
+	constructor(options: MistralHandlerOptions) {
 		this.options = options
-		this.client = new Mistral({
-			apiKey: this.options.mistralApiKey,
-		})
+	}
+
+	private ensureClient(): Mistral {
+		if (!this.client) {
+			if (!this.options.mistralApiKey) {
+				throw new Error("Mistral API key is required")
+			}
+			try {
+				this.client = new Mistral({
+					apiKey: this.options.mistralApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Mistral client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		const stream = await this.client.chat
+		const client = this.ensureClient()
+		const stream = await client.chat
 			.stream({
 				model: this.getModel().id,
 				// max_completion_tokens: this.getModel().info.maxTokens,

src/api/providers/moonshot.ts

@@ -0,0 +1,90 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { withRetry } from "../retry"
+import { ApiHandler } from "../index"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+import { ModelInfo, MoonshotModelId, moonshotModels, moonshotDefaultModelId } from "@/shared/api"
+
+interface MoonshotHandlerOptions {
+	moonshotApiKey?: string
+	moonshotApiLine?: string
+	apiModelId?: string
+}
+
+export class MoonshotHandler implements ApiHandler {
+	private client: OpenAI | undefined
+
+	constructor(private readonly options: MoonshotHandlerOptions) {}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.moonshotApiKey) {
+				throw new Error("Moonshot API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL:
+						this.options.moonshotApiLine === "china" ? "https://api.moonshot.cn/v1" : "https://api.moonshot.ai/v1",
+					apiKey: this.options.moonshotApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Moonshot client: ${error.message}`)
+			}
+		}
+		return this.client
+	}
+
+	@withRetry()
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
+		const model = this.getModel()
+
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+
+		const stream = await client.chat.completions.create({
+			model: model.id,
+			messages: openAiMessages,
+			temperature: 0,
+			stream: true,
+			stream_options: { include_usage: true },
+		})
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+			if (delta?.content) {
+				yield {
+					type: "text",
+					text: delta.content,
+				}
+			}
+
+			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
+				yield {
+					type: "reasoning",
+					reasoning: (delta.reasoning_content as string | undefined) || "",
+				}
+			}
+
+			if (chunk.usage) {
+				yield {
+					type: "usage",
+					inputTokens: chunk.usage.prompt_tokens || 0,
+					outputTokens: chunk.usage.completion_tokens || 0,
+				}
+			}
+		}
+	}
+
+	getModel(): { id: MoonshotModelId; info: ModelInfo } {
+		const modelId = this.options.apiModelId
+
+		if (modelId && modelId in moonshotModels) {
+			const id = modelId as MoonshotModelId
+			return { id, info: moonshotModels[id] }
+		}
+		return { id: moonshotDefaultModelId, info: moonshotModels[moonshotDefaultModelId] }
+	}
+}

src/api/providers/nebius.ts

@@ -5,27 +5,45 @@ import { ApiHandler } from "../index"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { convertToR1Format } from "../transform/r1-format"
-import { nebiusDefaultModelId, nebiusModels, type ModelInfo, type ApiHandlerOptions, type NebiusModelId } from "../../shared/api"
+import { nebiusDefaultModelId, nebiusModels, type ModelInfo, type NebiusModelId } from "../../shared/api"
+
+interface NebiusHandlerOptions {
+	nebiusApiKey?: string
+	apiModelId?: string
+}
 
 export class NebiusHandler implements ApiHandler {
-	private client: OpenAI
+	private client: OpenAI | undefined
 
-	constructor(private readonly options: ApiHandlerOptions) {
-		this.client = new OpenAI({
-			baseURL: "https://api.studio.nebius.ai/v1",
-			apiKey: this.options.nebiusApiKey,
-		})
+	constructor(private readonly options: NebiusHandlerOptions) {}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.nebiusApiKey) {
+				throw new Error("Nebius API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.studio.nebius.ai/v1",
+					apiKey: this.options.nebiusApiKey,
+				})
+			} catch (error) {
+				throw new Error(`Error creating Nebius client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = model.id.includes("DeepSeek-R1")
 			? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 			: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)]
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			messages: openAiMessages,
 			temperature: 0,

src/api/providers/ollama.ts

@@ -6,17 +6,35 @@ import { convertToOllamaMessages } from "../transform/ollama-format"
 import { ApiStream } from "../transform/stream"
 import { withRetry } from "../retry"
 
-export class OllamaHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: Ollama
+interface OllamaHandlerOptions {
+	ollamaBaseUrl?: string
+	ollamaModelId?: string
+	ollamaApiOptionsCtxNum?: string
+	requestTimeoutMs?: number
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class OllamaHandler implements ApiHandler {
+	private options: OllamaHandlerOptions
+	private client: Ollama | undefined
+
+	constructor(options: OllamaHandlerOptions) {
 		this.options = options
-		this.client = new Ollama({ host: this.options.ollamaBaseUrl || "http://localhost:11434" })
+	}
+
+	private ensureClient(): Ollama {
+		if (!this.client) {
+			try {
+				this.client = new Ollama({ host: this.options.ollamaBaseUrl || "http://localhost:11434" })
+			} catch (error) {
+				throw new Error(`Error creating Ollama client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry({ retryAllErrors: true })
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const ollamaMessages: Message[] = [{ role: "system", content: systemPrompt }, ...convertToOllamaMessages(messages)]
 
 		try {
@@ -27,7 +45,7 @@ export class OllamaHandler implements ApiHandler {
 			})
 
 			// Create the actual API request promise
-			const apiPromise = this.client.chat({
+			const apiPromise = client.chat({
 				model: this.getModel().id,
 				messages: ollamaMessages,
 				stream: true,

src/api/providers/openai-native.ts

@@ -8,15 +8,34 @@ import { calculateApiCostOpenAI } from "../../utils/cost"
 import { ApiStream } from "../transform/stream"
 import type { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
 
-export class OpenAiNativeHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface OpenAiNativeHandlerOptions {
+	openAiNativeApiKey?: string
+	reasoningEffort?: string
+	apiModelId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class OpenAiNativeHandler implements ApiHandler {
+	private options: OpenAiNativeHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: OpenAiNativeHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			apiKey: this.options.openAiNativeApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openAiNativeApiKey) {
+				throw new Error("OpenAI API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					apiKey: this.options.openAiNativeApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating OpenAI client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	private async *yieldUsage(info: ModelInfo, usage: OpenAI.Completions.CompletionUsage | undefined): ApiStream {
@@ -38,6 +57,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		switch (model.id) {
@@ -45,7 +65,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 			case "o1-preview":
 			case "o1-mini": {
 				// o1 doesn't support streaming, non-1 temp, or system prompt
-				const response = await this.client.chat.completions.create({
+				const response = await client.chat.completions.create({
 					model: model.id,
 					messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 				})
@@ -61,7 +81,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 			case "o4-mini":
 			case "o3":
 			case "o3-mini": {
-				const stream = await this.client.chat.completions.create({
+				const stream = await client.chat.completions.create({
 					model: model.id,
 					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
 					stream: true,
@@ -85,7 +105,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 				break
 			}
 			default: {
-				const stream = await this.client.chat.completions.create({
+				const stream = await client.chat.completions.create({
 					model: model.id,
 					// max_completion_tokens: this.getModel().info.maxTokens,
 					temperature: 0,

src/api/providers/openai.ts

@@ -1,44 +1,68 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI, { AzureOpenAI } from "openai"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, azureOpenAiDefaultApiVersion, ModelInfo, openAiModelInfoSaneDefaults } from "@shared/api"
+import { azureOpenAiDefaultApiVersion, ModelInfo, openAiModelInfoSaneDefaults, OpenAiCompatibleModelInfo } from "@shared/api"
 import { ApiHandler } from "../index"
 import { convertToOpenAiMessages } from "../transform/openai-format"
 import { ApiStream } from "../transform/stream"
 import { convertToR1Format } from "../transform/r1-format"
 import type { ChatCompletionReasoningEffort } from "openai/resources/chat/completions"
 
-export class OpenAiHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface OpenAiHandlerOptions {
+	openAiApiKey?: string
+	openAiBaseUrl?: string
+	azureApiVersion?: string
+	openAiHeaders?: Record<string, string>
+	openAiModelId?: string
+	openAiModelInfo?: OpenAiCompatibleModelInfo
+	reasoningEffort?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class OpenAiHandler implements ApiHandler {
+	private options: OpenAiHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: OpenAiHandlerOptions) {
 		this.options = options
-		// Azure API shape slightly differs from the core API shape: https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai
-		// 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.openAiModelId?.toLowerCase().includes("deepseek"))
-		) {
-			this.client = new AzureOpenAI({
-				baseURL: this.options.openAiBaseUrl,
-				apiKey: this.options.openAiApiKey,
-				apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion,
-				defaultHeaders: this.options.openAiHeaders,
-			})
-		} else {
-			this.client = new OpenAI({
-				baseURL: this.options.openAiBaseUrl,
-				apiKey: this.options.openAiApiKey,
-				defaultHeaders: this.options.openAiHeaders,
-			})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openAiApiKey) {
+				throw new Error("OpenAI API key is required")
+			}
+			try {
+				// Azure API shape slightly differs from the core API shape: https://github.com/openai/openai-node?tab=readme-ov-file#microsoft-azure-openai
+				// 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.openAiModelId?.toLowerCase().includes("deepseek"))
+				) {
+					this.client = new AzureOpenAI({
+						baseURL: this.options.openAiBaseUrl,
+						apiKey: this.options.openAiApiKey,
+						apiVersion: this.options.azureApiVersion || azureOpenAiDefaultApiVersion,
+						defaultHeaders: this.options.openAiHeaders,
+					})
+				} else {
+					this.client = new OpenAI({
+						baseURL: this.options.openAiBaseUrl,
+						apiKey: this.options.openAiApiKey,
+						defaultHeaders: this.options.openAiHeaders,
+					})
+				}
+			} catch (error: any) {
+				throw new Error(`Error creating OpenAI client: ${error.message}`)
+			}
 		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const modelId = this.options.openAiModelId ?? ""
 		const isDeepseekReasoner = modelId.includes("deepseek-reasoner")
 		const isR1FormatRequired = this.options.openAiModelInfo?.isR1FormatRequired ?? false
@@ -68,7 +92,7 @@ export class OpenAiHandler implements ApiHandler {
 			reasoningEffort = (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium"
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: modelId,
 			messages: openAiMessages,
 			temperature,

src/api/providers/openrouter.ts

@@ -3,35 +3,59 @@ import axios from "axios"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
-import { ApiHandlerOptions, ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
+import { ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from "@shared/api"
 import { withRetry } from "../retry"
 import { createOpenRouterStream } from "../transform/openrouter-stream"
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
 import { OpenRouterErrorResponse } from "./types"
+import { shouldSkipReasoningForModel } from "@utils/model-utils"
+
+interface OpenRouterHandlerOptions {
+	openRouterApiKey?: string
+	openRouterModelId?: string
+	openRouterModelInfo?: ModelInfo
+	openRouterProviderSorting?: string
+	reasoningEffort?: string
+	thinkingBudgetTokens?: number
+}
 
 export class OpenRouterHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+	private options: OpenRouterHandlerOptions
+	private client: OpenAI | undefined
 	lastGenerationId?: string
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: OpenRouterHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://openrouter.ai/api/v1",
-			apiKey: this.options.openRouterApiKey,
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot", // Optional, for including your app on openrouter.ai rankings.
-				"X-Title": "Cline", // Optional. Shows in rankings on openrouter.ai.
-			},
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.openRouterApiKey) {
+				throw new Error("OpenRouter API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://openrouter.ai/api/v1",
+					apiKey: this.options.openRouterApiKey,
+					defaultHeaders: {
+						"HTTP-Referer": "https://cline.bot", // Optional, for including your app on openrouter.ai rankings.
+						"X-Title": "Cline", // Optional. Shows in rankings on openrouter.ai.
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating OpenRouter client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		this.lastGenerationId = undefined
 
 		const stream = await createOpenRouterStream(
-			this.client,
+			client,
 			systemPrompt,
 			messages,
 			this.getModel(),
@@ -44,6 +68,7 @@ export class OpenRouterHandler implements ApiHandler {
 
 		for await (const chunk of stream) {
 			// openrouter returns an error object instead of the openai sdk throwing an error
+			// Check for error field directly on chunk
 			if ("error" in chunk) {
 				const error = chunk.error as OpenRouterErrorResponse["error"]
 				console.error(`OpenRouter API Error: ${error?.code} - ${error?.message}`)
@@ -52,6 +77,29 @@ export class OpenRouterHandler implements ApiHandler {
 				throw new Error(`OpenRouter API Error ${error.code}: ${error.message}${metadataStr}`)
 			}
 
+			// Check for error in choices[0].finish_reason
+			// OpenRouter may return errors in a non-standard way within choices
+			const choice = chunk.choices?.[0]
+			// Use type assertion since OpenRouter uses non-standard "error" finish_reason
+			if ((choice?.finish_reason as string) === "error") {
+				// Use type assertion since OpenRouter adds non-standard error property
+				const choiceWithError = choice as any
+				if (choiceWithError.error) {
+					const error = choiceWithError.error
+					console.error(
+						`OpenRouter Mid-Stream Error: ${error?.code || "Unknown"} - ${error?.message || "Unknown error"}`,
+					)
+					// Format error details
+					const errorDetails = typeof error === "object" ? JSON.stringify(error, null, 2) : String(error)
+					throw new Error(`OpenRouter Mid-Stream Error: ${errorDetails}`)
+				} else {
+					// Fallback if error details are not available
+					throw new Error(
+						`OpenRouter Mid-Stream Error: Stream terminated with error status but no error details provided`,
+					)
+				}
+			}
+
 			if (!this.lastGenerationId && chunk.id) {
 				this.lastGenerationId = chunk.id
 			}
@@ -65,7 +113,8 @@ export class OpenRouterHandler implements ApiHandler {
 			}
 
 			// Reasoning tokens are returned separately from the content
-			if ("reasoning" in delta && delta.reasoning) {
+			// Skip reasoning content for Grok 4 models since it only displays "thinking" without providing useful information
+			if ("reasoning" in delta && delta.reasoning && !shouldSkipReasoningForModel(this.options.openRouterModelId)) {
 				yield {
 					type: "reasoning",
 					// @ts-ignore-next-line
@@ -74,14 +123,27 @@ export class OpenRouterHandler implements ApiHandler {
 			}
 
 			if (!didOutputUsage && chunk.usage) {
-				yield {
-					type: "usage",
-					cacheWriteTokens: 0,
-					cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-					inputTokens: chunk.usage.prompt_tokens || 0,
-					outputTokens: chunk.usage.completion_tokens || 0,
-					// @ts-ignore-next-line
-					totalCost: chunk.usage.cost || 0,
+				let modelId = this.options.openRouterModelId
+				if (modelId && modelId.includes("gemini")) {
+					yield {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+						inputTokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+						outputTokens: chunk.usage.completion_tokens || 0,
+						// @ts-ignore-next-line
+						totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
+					}
+				} else {
+					yield {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
+						inputTokens: chunk.usage.prompt_tokens || 0,
+						outputTokens: chunk.usage.completion_tokens || 0,
+						// @ts-ignore-next-line
+						totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
+					}
 				}
 				didOutputUsage = true
 			}
@@ -103,14 +165,27 @@ export class OpenRouterHandler implements ApiHandler {
 				const generationIterator = this.fetchGenerationDetails(this.lastGenerationId)
 				const generation = (await generationIterator.next()).value
 				// console.log("OpenRouter generation details:", generation)
-				return {
-					type: "usage",
-					cacheWriteTokens: 0,
-					cacheReadTokens: generation?.native_tokens_cached || 0,
-					// openrouter generation endpoint fails often
-					inputTokens: generation?.native_tokens_prompt || 0,
-					outputTokens: generation?.native_tokens_completion || 0,
-					totalCost: generation?.total_cost || 0,
+				let modelId = this.options.openRouterModelId
+				if (modelId && modelId.includes("gemini")) {
+					return {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: generation?.native_tokens_cached || 0,
+						// openrouter generation endpoint fails often
+						inputTokens: (generation?.native_tokens_prompt || 0) - (generation?.native_tokens_cached || 0),
+						outputTokens: generation?.native_tokens_completion || 0,
+						totalCost: generation?.total_cost || 0,
+					}
+				} else {
+					return {
+						type: "usage",
+						cacheWriteTokens: 0,
+						cacheReadTokens: generation?.native_tokens_cached || 0,
+						// openrouter generation endpoint fails often
+						inputTokens: generation?.native_tokens_prompt || 0,
+						outputTokens: generation?.native_tokens_completion || 0,
+						totalCost: generation?.total_cost || 0,
+					}
 				}
 			} catch (error) {
 				// ignore if fails
@@ -140,9 +215,6 @@ export class OpenRouterHandler implements ApiHandler {
 
 	getModel(): { id: string; info: ModelInfo } {
 		let modelId = this.options.openRouterModelId
-		if (modelId === "x-ai/grok-3") {
-			modelId = "x-ai/grok-3-beta"
-		}
 		const modelInfo = this.options.openRouterModelInfo
 		if (modelId && modelInfo) {
 			return { id: modelId, info: modelInfo }

src/api/providers/qwen.ts

@@ -2,7 +2,6 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { ApiHandler } from "../"
 import {
-	ApiHandlerOptions,
 	ModelInfo,
 	mainlandQwenModels,
 	internationalQwenModels,
@@ -16,19 +15,39 @@ import { ApiStream } from "../transform/stream"
 import { convertToR1Format } from "../transform/r1-format"
 import { withRetry } from "../retry"
 
-export class QwenHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface QwenHandlerOptions {
+	qwenApiKey?: string
+	qwenApiLine?: string
+	apiModelId?: string
+	thinkingBudgetTokens?: number
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class QwenHandler implements ApiHandler {
+	private options: QwenHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: QwenHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL:
-				this.options.qwenApiLine === "china"
-					? "https://dashscope.aliyuncs.com/compatible-mode/v1"
-					: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
-			apiKey: this.options.qwenApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.qwenApiKey) {
+				throw new Error("Alibaba API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL:
+						this.options.qwenApiLine === "china"
+							? "https://dashscope.aliyuncs.com/compatible-mode/v1"
+							: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+					apiKey: this.options.qwenApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Alibaba client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	getModel(): { id: MainlandQwenModelId | InternationalQwenModelId; info: ModelInfo } {
@@ -51,6 +70,7 @@ export class QwenHandler implements ApiHandler {
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 		const isDeepseekReasoner = model.id.includes("deepseek-r1")
 		const isReasoningModelFamily = model.id.includes("qwen3") || ["qwen-plus-latest", "qwen-turbo-latest"].includes(model.id)
@@ -76,7 +96,7 @@ export class QwenHandler implements ApiHandler {
 			temperature = undefined
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_completion_tokens: model.info.maxTokens,
 			messages: openAiMessages,

src/api/providers/requesty.ts

@@ -7,6 +7,14 @@ import { convertToOpenAiMessages } from "@api/transform/openai-format"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import { ApiStream } from "@api/transform/stream"
 
+interface RequestyHandlerOptions {
+	requestyApiKey?: string
+	reasoningEffort?: string
+	thinkingBudgetTokens?: number
+	requestyModelId?: string
+	requestyModelInfo?: ModelInfo
+}
+
 // Requesty usage includes an extra field for Anthropic use cases.
 // Safely cast the prompt token details section to the appropriate structure.
 interface RequestyUsage extends OpenAI.CompletionUsage {
@@ -18,23 +26,37 @@ interface RequestyUsage extends OpenAI.CompletionUsage {
 }
 
 export class RequestyHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+	private options: RequestyHandlerOptions
+	private client: OpenAI | undefined
 
-	constructor(options: ApiHandlerOptions) {
+	constructor(options: RequestyHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://router.requesty.ai/v1",
-			apiKey: this.options.requestyApiKey,
-			defaultHeaders: {
-				"HTTP-Referer": "https://cline.bot",
-				"X-Title": "Cline",
-			},
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.requestyApiKey) {
+				throw new Error("Requesty API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://router.requesty.ai/v1",
+					apiKey: this.options.requestyApiKey,
+					defaultHeaders: {
+						"HTTP-Referer": "https://cline.bot",
+						"X-Title": "Cline",
+					},
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating Requesty client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -57,7 +79,7 @@ export class RequestyHandler implements ApiHandler {
 				: {}
 
 		// @ts-ignore-next-line
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: model.id,
 			max_tokens: model.info.maxTokens || undefined,
 			messages: openAiMessages,

src/api/providers/sambanova.ts

@@ -1,26 +1,45 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 import { withRetry } from "../retry"
-import { ApiHandlerOptions, ModelInfo, SambanovaModelId, sambanovaDefaultModelId, sambanovaModels } from "@shared/api"
+import { ModelInfo, SambanovaModelId, sambanovaDefaultModelId, sambanovaModels } from "@shared/api"
 import { ApiHandler } from "../index"
 import { convertToOpenAiMessages } from "@/api/transform/openai-format"
 import { ApiStream } from "@api/transform/stream"
 import { convertToR1Format } from "@api/transform/r1-format"
 
-export class SambanovaHandler implements ApiHandler {
-	private options: ApiHandlerOptions
-	private client: OpenAI
+interface SambanovaHandlerOptions {
+	sambanovaApiKey?: string
+	apiModelId?: string
+}
 
-	constructor(options: ApiHandlerOptions) {
+export class SambanovaHandler implements ApiHandler {
+	private options: SambanovaHandlerOptions
+	private client: OpenAI | undefined
+
+	constructor(options: SambanovaHandlerOptions) {
 		this.options = options
-		this.client = new OpenAI({
-			baseURL: "https://api.sambanova.ai/v1",
-			apiKey: this.options.sambanovaApiKey,
-		})
+	}
+
+	private ensureClient(): OpenAI {
+		if (!this.client) {
+			if (!this.options.sambanovaApiKey) {
+				throw new Error("SambaNova API key is required")
+			}
+			try {
+				this.client = new OpenAI({
+					baseURL: "https://api.sambanova.ai/v1",
+					apiKey: this.options.sambanovaApiKey,
+				})
+			} catch (error: any) {
+				throw new Error(`Error creating SambaNova client: ${error.message}`)
+			}
+		}
+		return this.client
 	}
 
 	@withRetry()
 	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const client = this.ensureClient()
 		const model = this.getModel()
 
 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -34,7 +53,7 @@ export class SambanovaHandler implements ApiHandler {
 			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 		}
 
-		const stream = await this.client.chat.completions.create({
+		const stream = await client.chat.completions.create({
 			model: this.getModel().id,
 			messages: openAiMessages,
 			temperature: 0,