remove

* Raise error on openrouter stream termination midway

* Raise error on openrouter stream termination midway

* type fix

---------

Co-authored-by: Cline Evaluation <cline@example.com>

.changeset/brave-humans-marry.md

@@ -0,0 +1,12 @@
+---
+"claude-dev": patch
+---
+
+Adding Gemini CLI Provider
+
+ * This implementation provides access to Google's Gemini models through OAuth authentication,
+ * leveraging the same authentication mechanism as the official Gemini CLI tool.
+ * 
+ * Attribution: This implementation is inspired by and uses concepts from the Google Gemini CLI,
+ * which is licensed under the Apache License 2.0.
+ * Original project: https://github.com/google-gemini/gemini-cli

.changeset/eighty-timers-camp.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Optimizing cline to work for gemini 2.5 family of models

.changeset/nine-dolphins-judge.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Modified diff regex to account for trailing > in search & replace blocks

.changeset/sixty-toys-look.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Optimized Cline for Claude 4

.changeset/wet-parrots-fold.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Updating default and recommended model to claude 4 sonnet

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:

evals/diff-edits/ClineWrapper.ts

@@ -8,9 +8,9 @@ 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 constructNewFileContentV2_1 } from "./diff-apply/diff-06-23-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"
 
 type ParseAssistantMessageFn = (message: string) => AssistantMessageContent[]
 type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string>
@@ -22,11 +22,9 @@ const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
 }
 
 const diffEditingFunctions: Record<string, ConstructNewFileContentFn> = {
-	"diff-06-06-25": constructNewFileContentV2,
-	"diff-06-23-25": constructNewFileContentV2_1,
-	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,
 }
 
 import { TestInput, TestResult, ExtractedToolCall } from "./types"

evals/diff-edits/TestRunner.ts

@@ -1,7 +1,8 @@
 import { runSingleEvaluation, TestInput, TestResult } from "./ClineWrapper"
 import { parseAssistantMessageV2, AssistantMessageContent } from "./parsing/parse-assistant-message-06-06-25"
-import { constructNewFileContent as constructNewFileContentV2 } from "./diff-apply/diff-06-06-25"
-import { constructNewFileContent as constructNewFileContentV2_1 } from "./diff-apply/diff-06-23-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 constructNewFileContentV3 } from "../../src/core/assistant-message/diff"
 import { basicSystemPrompt } from "./prompts/basicSystemPrompt-06-06-25"
 import { claude4SystemPrompt } from "./prompts/claude4SystemPrompt-06-06-25"
@@ -480,8 +481,9 @@ class NodeTestRunner {
 
 		// 1. Get the correct diffing function
 		const diffEditingFunctions: Record<string, any> = {
-			"diff-06-06-25": constructNewFileContentV2,
-			"diff-06-23-25": constructNewFileContentV2_1,
+			"diff-06-06-25": constructNewFileContent_06_06_25,
+			"diff-06-23-25": constructNewFileContent_06_23_25,
+			"diff-06-25-25": constructNewFileContent_06_25_25,
 			constructNewFileContentV3: constructNewFileContentV3,
 		}
 		const constructNewFileContent = diffEditingFunctions[diffApplyFile]

evals/diff-edits/dashboard/app.py

@@ -444,6 +444,9 @@ def render_model_comparison_cards(model_performance):
                 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
 
@@ -844,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()
     
@@ -851,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")
@@ -896,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
@@ -906,6 +930,57 @@ 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
+        server_address = st.server.server_address if hasattr(st.server, 'server_address') else "localhost"
+        server_port = st.server.server_port if hasattr(st.server, 'server_port') else "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)
@@ -923,6 +998,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/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
+}

package-lock.json

@@ -45,6 +45,7 @@
 				"fzf": "^0.5.2",
 				"get-folder-size": "^5.0.0",
 				"globby": "^14.0.2",
+				"google-auth-library": "^10.1.0",
 				"grpc-health-check": "^2.0.2",
 				"iconv-lite": "^0.6.3",
 				"ignore": "^7.0.3",
@@ -201,6 +202,75 @@
 				"undici-types": "~5.26.4"
 			}
 		},
+		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gaxios": {
+			"version": "6.7.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"extend": "^3.0.2",
+				"https-proxy-agent": "^7.0.1",
+				"is-stream": "^2.0.0",
+				"node-fetch": "^2.6.9",
+				"uuid": "^9.0.1"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gcp-metadata": {
+			"version": "6.1.1",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"gaxios": "^6.1.1",
+				"google-logging-utils": "^0.0.2",
+				"json-bigint": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@anthropic-ai/vertex-sdk/node_modules/google-auth-library": {
+			"version": "9.15.1",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"base64-js": "^1.3.0",
+				"ecdsa-sig-formatter": "^1.0.11",
+				"gaxios": "^6.1.1",
+				"gcp-metadata": "^6.1.0",
+				"gtoken": "^7.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@anthropic-ai/vertex-sdk/node_modules/google-logging-utils": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gtoken": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+			"license": "MIT",
+			"dependencies": {
+				"gaxios": "^6.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
 		"node_modules/@asyncapi/parser": {
 			"version": "3.4.0",
 			"resolved": "https://registry.npmjs.org/@asyncapi/parser/-/parser-3.4.0.tgz",
@@ -2868,6 +2938,75 @@
 				"node": ">=18.0.0"
 			}
 		},
+		"node_modules/@google-cloud/vertexai/node_modules/gaxios": {
+			"version": "6.7.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"extend": "^3.0.2",
+				"https-proxy-agent": "^7.0.1",
+				"is-stream": "^2.0.0",
+				"node-fetch": "^2.6.9",
+				"uuid": "^9.0.1"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google-cloud/vertexai/node_modules/gcp-metadata": {
+			"version": "6.1.1",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"gaxios": "^6.1.1",
+				"google-logging-utils": "^0.0.2",
+				"json-bigint": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google-cloud/vertexai/node_modules/google-auth-library": {
+			"version": "9.15.1",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"base64-js": "^1.3.0",
+				"ecdsa-sig-formatter": "^1.0.11",
+				"gaxios": "^6.1.1",
+				"gcp-metadata": "^6.1.0",
+				"gtoken": "^7.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google-cloud/vertexai/node_modules/google-logging-utils": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google-cloud/vertexai/node_modules/gtoken": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+			"license": "MIT",
+			"dependencies": {
+				"gaxios": "^6.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
 		"node_modules/@google/genai": {
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/@google/genai/-/genai-1.0.0.tgz",
@@ -2886,6 +3025,75 @@
 				"@modelcontextprotocol/sdk": "^1.11.0"
 			}
 		},
+		"node_modules/@google/genai/node_modules/gaxios": {
+			"version": "6.7.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"extend": "^3.0.2",
+				"https-proxy-agent": "^7.0.1",
+				"is-stream": "^2.0.0",
+				"node-fetch": "^2.6.9",
+				"uuid": "^9.0.1"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google/genai/node_modules/gcp-metadata": {
+			"version": "6.1.1",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"gaxios": "^6.1.1",
+				"google-logging-utils": "^0.0.2",
+				"json-bigint": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google/genai/node_modules/google-auth-library": {
+			"version": "9.15.1",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"base64-js": "^1.3.0",
+				"ecdsa-sig-formatter": "^1.0.11",
+				"gaxios": "^6.1.1",
+				"gcp-metadata": "^6.1.0",
+				"gtoken": "^7.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google/genai/node_modules/google-logging-utils": {
+			"version": "0.0.2",
+			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
+			"license": "Apache-2.0",
+			"engines": {
+				"node": ">=14"
+			}
+		},
+		"node_modules/@google/genai/node_modules/gtoken": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+			"license": "MIT",
+			"dependencies": {
+				"gaxios": "^6.0.0",
+				"jws": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=14.0.0"
+			}
+		},
 		"node_modules/@grpc/grpc-js": {
 			"version": "1.9.15",
 			"resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.9.15.tgz",
@@ -9602,9 +9810,10 @@
 			}
 		},
 		"node_modules/bignumber.js": {
-			"version": "9.1.2",
-			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz",
-			"integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==",
+			"version": "9.3.0",
+			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.0.tgz",
+			"integrity": "sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA==",
+			"license": "MIT",
 			"engines": {
 				"node": "*"
 			}
@@ -9790,7 +9999,8 @@
 		"node_modules/buffer-equal-constant-time": {
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
-			"integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="
+			"integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+			"license": "BSD-3-Clause"
 		},
 		"node_modules/buffer-indexof-polyfill": {
 			"version": "1.0.2",
@@ -11448,6 +11658,7 @@
 			"version": "1.0.11",
 			"resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
 			"integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+			"license": "Apache-2.0",
 			"dependencies": {
 				"safe-buffer": "^5.0.1"
 			}
@@ -13086,6 +13297,29 @@
 				"pend": "~1.2.0"
 			}
 		},
+		"node_modules/fetch-blob": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+			"integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/jimmywarting"
+				},
+				{
+					"type": "paypal",
+					"url": "https://paypal.me/jimmywarting"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"node-domexception": "^1.0.0",
+				"web-streams-polyfill": "^3.0.3"
+			},
+			"engines": {
+				"node": "^12.20 || >= 14.13"
+			}
+		},
 		"node_modules/figures": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
@@ -13422,6 +13656,18 @@
 				"node": ">= 14"
 			}
 		},
+		"node_modules/formdata-polyfill": {
+			"version": "4.0.10",
+			"resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+			"integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+			"license": "MIT",
+			"dependencies": {
+				"fetch-blob": "^3.1.2"
+			},
+			"engines": {
+				"node": ">=12.20.0"
+			}
+		},
 		"node_modules/forwarded": {
 			"version": "0.2.0",
 			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -13688,18 +13934,44 @@
 			}
 		},
 		"node_modules/gaxios": {
-			"version": "6.7.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+			"version": "7.1.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.1.tgz",
+			"integrity": "sha512-Odju3uBUJyVCkW64nLD4wKLhbh93bh6vIg/ZIXkWiLPBrdgtc65+tls/qml+un3pr6JqYVFDZbbmLDQT68rTOQ==",
+			"license": "Apache-2.0",
 			"dependencies": {
 				"extend": "^3.0.2",
 				"https-proxy-agent": "^7.0.1",
-				"is-stream": "^2.0.0",
-				"node-fetch": "^2.6.9",
-				"uuid": "^9.0.1"
+				"node-fetch": "^3.3.2"
 			},
 			"engines": {
-				"node": ">=14"
+				"node": ">=18"
+			}
+		},
+		"node_modules/gaxios/node_modules/data-uri-to-buffer": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+			"integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/gaxios/node_modules/node-fetch": {
+			"version": "3.3.2",
+			"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+			"integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+			"license": "MIT",
+			"dependencies": {
+				"data-uri-to-buffer": "^4.0.0",
+				"fetch-blob": "^3.1.4",
+				"formdata-polyfill": "^4.0.10"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/node-fetch"
 			}
 		},
 		"node_modules/gcd": {
@@ -13709,15 +13981,17 @@
 			"dev": true
 		},
 		"node_modules/gcp-metadata": {
-			"version": "6.1.0",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.0.tgz",
-			"integrity": "sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==",
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-7.0.1.tgz",
+			"integrity": "sha512-UcO3kefx6dCcZkgcTGgVOTFb7b1LlQ02hY1omMjjrrBzkajRMCFgYOjs7J71WqnuG1k2b+9ppGL7FsOfhZMQKQ==",
+			"license": "Apache-2.0",
 			"dependencies": {
-				"gaxios": "^6.0.0",
+				"gaxios": "^7.0.0",
+				"google-logging-utils": "^1.0.0",
 				"json-bigint": "^1.0.0"
 			},
 			"engines": {
-				"node": ">=14"
+				"node": ">=18"
 			}
 		},
 		"node_modules/get-caller-file": {
@@ -13990,18 +14264,28 @@
 			}
 		},
 		"node_modules/google-auth-library": {
-			"version": "9.15.1",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+			"version": "10.1.0",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.1.0.tgz",
+			"integrity": "sha512-GspVjZj1RbyRWpQ9FbAXMKjFGzZwDKnUHi66JJ+tcjcu5/xYAP1pdlWotCuIkMwjfVsxxDvsGZXGLzRt72D0sQ==",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"base64-js": "^1.3.0",
 				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^6.1.1",
-				"gcp-metadata": "^6.1.0",
-				"gtoken": "^7.0.0",
+				"gaxios": "^7.0.0",
+				"gcp-metadata": "^7.0.0",
+				"google-logging-utils": "^1.0.0",
+				"gtoken": "^8.0.0",
 				"jws": "^4.0.0"
 			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/google-logging-utils": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.1.tgz",
+			"integrity": "sha512-rcX58I7nqpu4mbKztFeOAObbomBbHU2oIb/d3tJfF3dizGSApqtSwYJigGCooHdnMyQBIw8BrWyK96w3YXgr6A==",
+			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=14"
 			}
@@ -14138,15 +14422,16 @@
 			}
 		},
 		"node_modules/gtoken": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-8.0.0.tgz",
+			"integrity": "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==",
+			"license": "MIT",
 			"dependencies": {
-				"gaxios": "^6.0.0",
+				"gaxios": "^7.0.0",
 				"jws": "^4.0.0"
 			},
 			"engines": {
-				"node": ">=14.0.0"
+				"node": ">=18"
 			}
 		},
 		"node_modules/has-bigints": {
@@ -15745,6 +16030,7 @@
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
 			"integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
+			"license": "MIT",
 			"dependencies": {
 				"bignumber.js": "^9.0.0"
 			}
@@ -15858,11 +16144,12 @@
 			"license": "MIT"
 		},
 		"node_modules/jwa": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
-			"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+			"integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+			"license": "MIT",
 			"dependencies": {
-				"buffer-equal-constant-time": "1.0.1",
+				"buffer-equal-constant-time": "^1.0.1",
 				"ecdsa-sig-formatter": "1.0.11",
 				"safe-buffer": "^5.0.1"
 			}
@@ -15871,6 +16158,7 @@
 			"version": "4.0.0",
 			"resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
 			"integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+			"license": "MIT",
 			"dependencies": {
 				"jwa": "^2.0.0",
 				"safe-buffer": "^5.0.1"
@@ -23400,6 +23688,15 @@
 				"url": "https://github.com/sponsors/wooorm"
 			}
 		},
+		"node_modules/web-streams-polyfill": {
+			"version": "3.3.3",
+			"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+			"integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 8"
+			}
+		},
 		"node_modules/web-tree-sitter": {
 			"version": "0.22.6",
 			"resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.22.6.tgz",
@@ -24160,6 +24457,55 @@
 					"requires": {
 						"undici-types": "~5.26.4"
 					}
+				},
+				"gaxios": {
+					"version": "6.7.1",
+					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+					"requires": {
+						"extend": "^3.0.2",
+						"https-proxy-agent": "^7.0.1",
+						"is-stream": "^2.0.0",
+						"node-fetch": "^2.6.9",
+						"uuid": "^9.0.1"
+					}
+				},
+				"gcp-metadata": {
+					"version": "6.1.1",
+					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+					"requires": {
+						"gaxios": "^6.1.1",
+						"google-logging-utils": "^0.0.2",
+						"json-bigint": "^1.0.0"
+					}
+				},
+				"google-auth-library": {
+					"version": "9.15.1",
+					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+					"requires": {
+						"base64-js": "^1.3.0",
+						"ecdsa-sig-formatter": "^1.0.11",
+						"gaxios": "^6.1.1",
+						"gcp-metadata": "^6.1.0",
+						"gtoken": "^7.0.0",
+						"jws": "^4.0.0"
+					}
+				},
+				"google-logging-utils": {
+					"version": "0.0.2",
+					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
+				},
+				"gtoken": {
+					"version": "7.1.0",
+					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+					"requires": {
+						"gaxios": "^6.0.0",
+						"jws": "^4.0.0"
+					}
 				}
 			}
 		},
@@ -26416,6 +26762,57 @@
 			"integrity": "sha512-35o5tIEMLW3JeFJOaaMNR2e5sq+6rpnhrF97PuAxeOm0GlqVTESKhkGj7a5B5mmJSSSU3hUfIhcQCRRsw4Ipzg==",
 			"requires": {
 				"google-auth-library": "^9.1.0"
+			},
+			"dependencies": {
+				"gaxios": {
+					"version": "6.7.1",
+					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+					"requires": {
+						"extend": "^3.0.2",
+						"https-proxy-agent": "^7.0.1",
+						"is-stream": "^2.0.0",
+						"node-fetch": "^2.6.9",
+						"uuid": "^9.0.1"
+					}
+				},
+				"gcp-metadata": {
+					"version": "6.1.1",
+					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+					"requires": {
+						"gaxios": "^6.1.1",
+						"google-logging-utils": "^0.0.2",
+						"json-bigint": "^1.0.0"
+					}
+				},
+				"google-auth-library": {
+					"version": "9.15.1",
+					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+					"requires": {
+						"base64-js": "^1.3.0",
+						"ecdsa-sig-formatter": "^1.0.11",
+						"gaxios": "^6.1.1",
+						"gcp-metadata": "^6.1.0",
+						"gtoken": "^7.0.0",
+						"jws": "^4.0.0"
+					}
+				},
+				"google-logging-utils": {
+					"version": "0.0.2",
+					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
+				},
+				"gtoken": {
+					"version": "7.1.0",
+					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+					"requires": {
+						"gaxios": "^6.0.0",
+						"jws": "^4.0.0"
+					}
+				}
 			}
 		},
 		"@google/genai": {
@@ -26427,6 +26824,57 @@
 				"ws": "^8.18.0",
 				"zod": "^3.22.4",
 				"zod-to-json-schema": "^3.22.4"
+			},
+			"dependencies": {
+				"gaxios": {
+					"version": "6.7.1",
+					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+					"requires": {
+						"extend": "^3.0.2",
+						"https-proxy-agent": "^7.0.1",
+						"is-stream": "^2.0.0",
+						"node-fetch": "^2.6.9",
+						"uuid": "^9.0.1"
+					}
+				},
+				"gcp-metadata": {
+					"version": "6.1.1",
+					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
+					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
+					"requires": {
+						"gaxios": "^6.1.1",
+						"google-logging-utils": "^0.0.2",
+						"json-bigint": "^1.0.0"
+					}
+				},
+				"google-auth-library": {
+					"version": "9.15.1",
+					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+					"requires": {
+						"base64-js": "^1.3.0",
+						"ecdsa-sig-formatter": "^1.0.11",
+						"gaxios": "^6.1.1",
+						"gcp-metadata": "^6.1.0",
+						"gtoken": "^7.0.0",
+						"jws": "^4.0.0"
+					}
+				},
+				"google-logging-utils": {
+					"version": "0.0.2",
+					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
+					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
+				},
+				"gtoken": {
+					"version": "7.1.0",
+					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+					"requires": {
+						"gaxios": "^6.0.0",
+						"jws": "^4.0.0"
+					}
+				}
 			}
 		},
 		"@grpc/grpc-js": {
@@ -31210,9 +31658,9 @@
 			"integrity": "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="
 		},
 		"bignumber.js": {
-			"version": "9.1.2",
-			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz",
-			"integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug=="
+			"version": "9.3.0",
+			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.0.tgz",
+			"integrity": "sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA=="
 		},
 		"binary": {
 			"version": "0.3.0",
@@ -33564,6 +34012,15 @@
 				"pend": "~1.2.0"
 			}
 		},
+		"fetch-blob": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+			"integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+			"requires": {
+				"node-domexception": "^1.0.0",
+				"web-streams-polyfill": "^3.0.3"
+			}
+		},
 		"figures": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
@@ -33799,6 +34256,14 @@
 				}
 			}
 		},
+		"formdata-polyfill": {
+			"version": "4.0.10",
+			"resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+			"integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+			"requires": {
+				"fetch-blob": "^3.1.2"
+			}
+		},
 		"forwarded": {
 			"version": "0.2.0",
 			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -33984,15 +34449,30 @@
 			}
 		},
 		"gaxios": {
-			"version": "6.7.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
+			"version": "7.1.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.1.tgz",
+			"integrity": "sha512-Odju3uBUJyVCkW64nLD4wKLhbh93bh6vIg/ZIXkWiLPBrdgtc65+tls/qml+un3pr6JqYVFDZbbmLDQT68rTOQ==",
 			"requires": {
 				"extend": "^3.0.2",
 				"https-proxy-agent": "^7.0.1",
-				"is-stream": "^2.0.0",
-				"node-fetch": "^2.6.9",
-				"uuid": "^9.0.1"
+				"node-fetch": "^3.3.2"
+			},
+			"dependencies": {
+				"data-uri-to-buffer": {
+					"version": "4.0.1",
+					"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+					"integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="
+				},
+				"node-fetch": {
+					"version": "3.3.2",
+					"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+					"integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+					"requires": {
+						"data-uri-to-buffer": "^4.0.0",
+						"fetch-blob": "^3.1.4",
+						"formdata-polyfill": "^4.0.10"
+					}
+				}
 			}
 		},
 		"gcd": {
@@ -34002,11 +34482,12 @@
 			"dev": true
 		},
 		"gcp-metadata": {
-			"version": "6.1.0",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.0.tgz",
-			"integrity": "sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==",
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-7.0.1.tgz",
+			"integrity": "sha512-UcO3kefx6dCcZkgcTGgVOTFb7b1LlQ02hY1omMjjrrBzkajRMCFgYOjs7J71WqnuG1k2b+9ppGL7FsOfhZMQKQ==",
 			"requires": {
-				"gaxios": "^6.0.0",
+				"gaxios": "^7.0.0",
+				"google-logging-utils": "^1.0.0",
 				"json-bigint": "^1.0.0"
 			}
 		},
@@ -34180,18 +34661,24 @@
 			}
 		},
 		"google-auth-library": {
-			"version": "9.15.1",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
+			"version": "10.1.0",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.1.0.tgz",
+			"integrity": "sha512-GspVjZj1RbyRWpQ9FbAXMKjFGzZwDKnUHi66JJ+tcjcu5/xYAP1pdlWotCuIkMwjfVsxxDvsGZXGLzRt72D0sQ==",
 			"requires": {
 				"base64-js": "^1.3.0",
 				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^6.1.1",
-				"gcp-metadata": "^6.1.0",
-				"gtoken": "^7.0.0",
+				"gaxios": "^7.0.0",
+				"gcp-metadata": "^7.0.0",
+				"google-logging-utils": "^1.0.0",
+				"gtoken": "^8.0.0",
 				"jws": "^4.0.0"
 			}
 		},
+		"google-logging-utils": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.1.tgz",
+			"integrity": "sha512-rcX58I7nqpu4mbKztFeOAObbomBbHU2oIb/d3tJfF3dizGSApqtSwYJigGCooHdnMyQBIw8BrWyK96w3YXgr6A=="
+		},
 		"gopd": {
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
@@ -34292,11 +34779,11 @@
 			}
 		},
 		"gtoken": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
+			"version": "8.0.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-8.0.0.tgz",
+			"integrity": "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==",
 			"requires": {
-				"gaxios": "^6.0.0",
+				"gaxios": "^7.0.0",
 				"jws": "^4.0.0"
 			}
 		},
@@ -35436,11 +35923,11 @@
 			"dev": true
 		},
 		"jwa": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
-			"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+			"integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
 			"requires": {
-				"buffer-equal-constant-time": "1.0.1",
+				"buffer-equal-constant-time": "^1.0.1",
 				"ecdsa-sig-formatter": "1.0.11",
 				"safe-buffer": "^5.0.1"
 			}
@@ -40631,6 +41118,11 @@
 			"integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
 			"dev": true
 		},
+		"web-streams-polyfill": {
+			"version": "3.3.3",
+			"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+			"integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw=="
+		},
 		"web-tree-sitter": {
 			"version": "0.22.6",
 			"resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.22.6.tgz",

package.json

@@ -442,6 +442,7 @@
 		"fzf": "^0.5.2",
 		"get-folder-size": "^5.0.0",
 		"globby": "^14.0.2",
+		"google-auth-library": "^10.1.0",
 		"grpc-health-check": "^2.0.2",
 		"iconv-lite": "^0.6.3",
 		"ignore": "^7.0.3",

proto/build-proto.js

@@ -58,6 +58,7 @@ const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join(RO
 const hostServiceNameMap = {
 	uri: "host.UriService",
 	watch: "host.WatchService",
+	workspace: "host.WorkspaceService",
 	// Add new host services here
 }
 const hostServiceDirs = Object.keys(hostServiceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src/hosts/vscode", serviceKey))

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/models.proto

@@ -105,24 +105,25 @@ enum ApiProvider {
   OLLAMA = 5;
   LMSTUDIO = 6;
   GEMINI = 7;
-  OPENAI_NATIVE = 8;
-  REQUESTY = 9;
-  TOGETHER = 10;
-  DEEPSEEK = 11;
-  QWEN = 12;
-  DOUBAO = 13;
-  MISTRAL = 14;
-  VSCODE_LM = 15;
-  CLINE = 16;
-  LITELLM = 17;
-  NEBIUS = 18;
-  FIREWORKS = 19;
-  ASKSAGE = 20;
-  XAI = 21;
-  SAMBANOVA = 22;
-  CEREBRAS = 23;
-  SAPAICORE = 24;
-  CLAUDE_CODE = 25;
+  GEMINI_CLI = 8;
+  OPENAI_NATIVE = 9;
+  REQUESTY = 10;
+  TOGETHER = 11;
+  DEEPSEEK = 12;
+  QWEN = 13;
+  DOUBAO = 14;
+  MISTRAL = 15;
+  VSCODE_LM = 16;
+  CLINE = 17;
+  LITELLM = 18;
+  NEBIUS = 19;
+  FIREWORKS = 20;
+  ASKSAGE = 21;
+  XAI = 22;
+  SAMBANOVA = 23;
+  CEREBRAS = 24;
+  SAPAICORE = 25;
+  CLAUDE_CODE = 26;
 }
 
 // Model info for OpenAI-compatible models
@@ -236,4 +237,6 @@ 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 gemini_cli_oauth_path = 74;
+  optional string gemini_cli_project_id = 75;
+}

src/api/index.ts

@@ -8,6 +8,7 @@ import { OpenAiHandler } from "./providers/openai"
 import { OllamaHandler } from "./providers/ollama"
 import { LmStudioHandler } from "./providers/lmstudio"
 import { GeminiHandler } from "./providers/gemini"
+import { GeminiCliHandler } from "./providers/gemini-cli"
 import { OpenAiNativeHandler } from "./providers/openai-native"
 import { ApiStream, ApiStreamUsageChunk } from "./transform/stream"
 import { DeepSeekHandler } from "./providers/deepseek"
@@ -56,6 +57,8 @@ function createHandlerForProvider(apiProvider: string | undefined, options: any)
 			return new LmStudioHandler(options)
 		case "gemini":
 			return new GeminiHandler(options)
+		case "gemini-cli":
+			return new GeminiCliHandler(options)
 		case "openai-native":
 			return new OpenAiNativeHandler(options)
 		case "deepseek":

src/api/providers/cline.ts

@@ -56,7 +56,21 @@ export class ClineHandler implements ApiHandler {
 				this.lastGenerationId = chunk.id
 			}
 
-			const delta = chunk.choices[0]?.delta
+			// 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",
@@ -75,7 +89,7 @@ export class ClineHandler implements ApiHandler {
 
 			if (!didOutputUsage && chunk.usage) {
 				// @ts-ignore-next-line
-				let totalCost = chunk.usage.cost || 0
+				let totalCost = (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0)
 				const modelId = this.getModel().id
 				const provider = modelId.split("/")[0]
 

src/api/providers/gemini-cli.ts

@@ -0,0 +1,418 @@
+/**
+ * Gemini CLI Provider - OAuth-based API Handler
+ *
+ * This implementation provides access to Google's Gemini models through OAuth authentication,
+ * leveraging the same authentication mechanism as the official Gemini CLI tool.
+ *
+ * Attribution: This implementation is inspired by and uses concepts from the Google Gemini CLI,
+ * which is licensed under the Apache License 2.0.
+ * Original project: https://github.com/google-gemini/gemini-cli
+ *
+ * Copyright 2025 Google LLC
+ * Licensed under the Apache License, Version 2.0
+ *
+ * Key features:
+ * - OAuth2 authentication (no API keys required)
+ * - Auto-discovery of Google Cloud project IDs
+ * - Real-time streaming via Server-Sent Events
+ * - Free tier access through Google's Code Assist API
+ * - Compatible with personal Google accounts only
+ */
+
+import type { Anthropic } from "@anthropic-ai/sdk"
+import { OAuth2Client } from "google-auth-library"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+import * as readline from "readline"
+import { Readable } from "stream"
+import { ApiHandler } from "../"
+import { ApiHandlerOptions, GeminiCliModelId, geminiCliModels, ModelInfo, geminiCliDefaultModelId } from "@shared/api"
+import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
+import { ApiStream } from "../transform/stream"
+import { withRetry } from "../retry"
+
+const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com"
+const CODE_ASSIST_API_VERSION = "v1internal"
+
+// OAuth configuration
+const OAUTH_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
+// Change this line in setup.js:
+const OAUTH_CLIENT_SECRET = "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"
+
+const OAUTH_REDIRECT_URI = "http://localhost:45289"
+
+interface OAuthCredentials {
+	access_token: string
+	refresh_token: string
+	scope: string
+	token_type: string
+	expiry_date: number
+}
+
+interface GeminiCliHandlerOptions extends ApiHandlerOptions {
+	geminiCliOAuthPath?: string
+	geminiCliProjectId?: string
+}
+
+/**
+ * Handler for Google's Gemini API via OAuth (Gemini CLI style).
+ *
+ * This provider uses OAuth authentication instead of API keys, making it suitable
+ * for users who have already authenticated with the Gemini CLI tool.
+ * It automatically discovers project IDs and works with the free tier.
+ */
+export class GeminiCliHandler implements ApiHandler {
+	private options: GeminiCliHandlerOptions
+	private authClient: OAuth2Client
+	private projectId: string | null = null
+	private authInitialized: boolean = false
+
+	constructor(options: GeminiCliHandlerOptions) {
+		this.options = options
+		this.authClient = new OAuth2Client(OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_REDIRECT_URI)
+	}
+
+	/**
+	 * Load OAuth credentials from the file system
+	 */
+	private async loadOAuthCredentials(): Promise<OAuthCredentials> {
+		const credPath = this.options.geminiCliOAuthPath || path.join(os.homedir(), ".gemini", "oauth_creds.json")
+		try {
+			const data = await fs.readFile(credPath, "utf8")
+			return JSON.parse(data)
+		} catch (err) {
+			throw new Error(`Failed to load OAuth credentials from ${credPath}. Please authenticate with 'gemini auth' first.`)
+		}
+	}
+
+	/**
+	 * Call a Code Assist API endpoint
+	 */
+	private async callEndpoint(method: string, body: any, retryAuth: boolean = true): Promise<any> {
+		console.log(`[GeminiCLI] Calling endpoint: ${method}`)
+		console.log(`[GeminiCLI] Request body:`, JSON.stringify(body, null, 2))
+
+		try {
+			const res = await this.authClient.request({
+				url: `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:${method}`,
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				responseType: "json",
+				body: JSON.stringify(body),
+			})
+			console.log(`[GeminiCLI] Response status:`, res.status)
+			console.log(`[GeminiCLI] Response data:`, JSON.stringify(res.data, null, 2))
+			return res.data
+		} catch (error: any) {
+			console.error(`[GeminiCLI] Error calling ${method}:`, error)
+			console.error(`[GeminiCLI] Error response:`, error.response?.data)
+			console.error(`[GeminiCLI] Error status:`, error.response?.status)
+			console.error(`[GeminiCLI] Error message:`, error.message)
+
+			// If we get a 401 and haven't retried yet, try refreshing auth
+			if (error.response?.status === 401 && retryAuth) {
+				console.log(`[GeminiCLI] Got 401, attempting to refresh authentication...`)
+				await this.initializeAuth(true) // Force refresh
+				return this.callEndpoint(method, body, false) // Retry without further auth retries
+			}
+
+			throw error
+		}
+	}
+
+	/**
+	 * Discover or retrieve the project ID
+	 */
+	private async discoverProjectId(): Promise<string> {
+		// If we already have a project ID, use it
+		if (this.options.geminiCliProjectId) {
+			return this.options.geminiCliProjectId
+		}
+
+		// If we've already discovered it, return it
+		if (this.projectId) {
+			return this.projectId
+		}
+
+		// Start with a default project ID (can be anything for personal OAuth)
+		const initialProjectId = "default"
+
+		// Prepare client metadata
+		const clientMetadata = {
+			ideType: "IDE_UNSPECIFIED",
+			platform: "PLATFORM_UNSPECIFIED",
+			pluginType: "GEMINI",
+			duetProject: initialProjectId,
+		}
+
+		try {
+			// Call loadCodeAssist to discover the actual project ID
+			const loadRequest = {
+				cloudaicompanionProject: initialProjectId,
+				metadata: clientMetadata,
+			}
+
+			const loadResponse = await this.callEndpoint("loadCodeAssist", loadRequest)
+
+			// Check if we already have a project ID from the response
+			if (loadResponse.cloudaicompanionProject) {
+				this.projectId = loadResponse.cloudaicompanionProject
+				return this.projectId as string
+			}
+
+			// If no existing project, we need to onboard
+			const defaultTier = loadResponse.allowedTiers?.find((tier: any) => tier.isDefault)
+			const tierId = defaultTier?.id || "free-tier"
+
+			const onboardRequest = {
+				tierId: tierId,
+				cloudaicompanionProject: initialProjectId,
+				metadata: clientMetadata,
+			}
+
+			let lroResponse = await this.callEndpoint("onboardUser", onboardRequest)
+
+			// Poll until operation is complete
+			while (!lroResponse.done) {
+				await new Promise((resolve) => setTimeout(resolve, 2000))
+				lroResponse = await this.callEndpoint("onboardUser", onboardRequest)
+			}
+
+			const discoveredProjectId = lroResponse.response?.cloudaicompanionProject?.id || initialProjectId
+			this.projectId = discoveredProjectId
+			return this.projectId as string
+		} catch (error: any) {
+			console.error("Failed to discover project ID:", error.response?.data || error.message)
+			throw new Error("Could not discover project ID. Make sure you're authenticated with 'gemini auth'.")
+		}
+	}
+
+	/**
+	 * Initialize the OAuth client with credentials
+	 */
+	private async initializeAuth(forceRefresh: boolean = false): Promise<void> {
+		// Check if we need to initialize or refresh
+		if (this.authInitialized && !forceRefresh) {
+			// Check if token is still valid
+			const credentials = this.authClient.credentials
+			if (credentials && credentials.expiry_date && Date.now() < credentials.expiry_date) {
+				console.log(`[GeminiCLI] Auth already initialized and token still valid`)
+				return
+			}
+		}
+
+		console.log(`[GeminiCLI] Initializing OAuth authentication...`)
+		const credentials = await this.loadOAuthCredentials()
+		const isExpired = credentials.expiry_date ? Date.now() > credentials.expiry_date : false
+
+		console.log(`[GeminiCLI] Loaded credentials:`, {
+			hasAccessToken: !!credentials.access_token,
+			hasRefreshToken: !!credentials.refresh_token,
+			tokenType: credentials.token_type,
+			expiryDate: credentials.expiry_date,
+			isExpired: isExpired,
+		})
+
+		this.authClient.setCredentials(credentials)
+
+		// If token is expired and we have a refresh token, try to refresh
+		if (isExpired && credentials.refresh_token) {
+			console.log(`[GeminiCLI] Token expired, attempting to refresh...`)
+			try {
+				const { credentials: newCredentials } = await this.authClient.refreshAccessToken()
+				console.log(`[GeminiCLI] Token refreshed successfully`)
+				// Note: In a real implementation, you'd want to save the new credentials back to the file
+				// For now, we'll just use them in memory
+			} catch (error) {
+				console.error(`[GeminiCLI] Failed to refresh token:`, error)
+				// Continue with the expired token - the API might still accept it
+			}
+		}
+
+		this.authInitialized = true
+		console.log(`[GeminiCLI] OAuth client configured`)
+	}
+
+	/**
+	 * Parse Server-Sent Events from a stream
+	 */
+	private async *parseSSEStream(stream: Readable): AsyncGenerator<any> {
+		const rl = readline.createInterface({
+			input: stream,
+			crlfDelay: Infinity,
+		})
+
+		let bufferedLines: string[] = []
+
+		for await (const line of rl) {
+			// Blank lines separate JSON objects in the stream
+			if (line === "") {
+				if (bufferedLines.length === 0) {
+					continue
+				}
+
+				try {
+					const jsonData = JSON.parse(bufferedLines.join("\n"))
+					yield jsonData
+				} catch (parseError) {
+					console.error("Error parsing JSON chunk:", parseError)
+				}
+
+				bufferedLines = []
+			} else if (line.startsWith("data: ")) {
+				bufferedLines.push(line.slice(6).trim())
+			}
+		}
+
+		// Process any remaining buffered content
+		if (bufferedLines.length > 0) {
+			try {
+				const jsonData = JSON.parse(bufferedLines.join("\n"))
+				yield jsonData
+			} catch (parseError) {
+				console.error("Error parsing final buffered content:", parseError)
+			}
+		}
+	}
+
+	/**
+	 * Create a message using the Gemini CLI OAuth API
+	 */
+	@withRetry({
+		maxRetries: 2,
+		baseDelay: 2000,
+		maxDelay: 10000,
+	})
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		// Initialize auth if not already done
+		await this.initializeAuth()
+		// Discover project ID if needed
+		const projectId = await this.discoverProjectId()
+
+		// Convert messages to Gemini format
+		const contents = messages.map(convertAnthropicMessageToGemini)
+
+		// Get the selected model
+		const { id: modelId, info: modelInfo } = this.getModel()
+
+		// Build the request
+		const streamRequest = {
+			model: modelId,
+			project: projectId,
+			request: {
+				contents: [
+					{
+						role: "user",
+						parts: [{ text: systemPrompt }],
+					},
+					...contents,
+				],
+				generationConfig: {
+					temperature: 0.7,
+					maxOutputTokens: modelInfo.maxTokens || 8192,
+				},
+			},
+		}
+
+		let totalContent = ""
+		let promptTokens = 0
+		let outputTokens = 0
+		let lastUsageMetadata: any = null
+
+		try {
+			// Make the streaming request
+			const response = await this.authClient.request({
+				url: `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:streamGenerateContent`,
+				method: "POST",
+				params: { alt: "sse" },
+				headers: {
+					"Content-Type": "application/json",
+				},
+				responseType: "stream",
+				body: JSON.stringify(streamRequest),
+			})
+
+			// Process the SSE stream
+			for await (const jsonData of this.parseSSEStream(response.data as Readable)) {
+				// Extract content from the response
+				const candidate = jsonData.response?.candidates?.[0]
+				if (candidate?.content?.parts?.[0]?.text) {
+					const content = candidate.content.parts[0].text
+					totalContent += content
+
+					// Yield text chunk
+					yield {
+						type: "text",
+						text: content,
+					}
+				}
+
+				// Store usage metadata for final reporting
+				if (jsonData.response?.usageMetadata) {
+					lastUsageMetadata = jsonData.response.usageMetadata
+					promptTokens = lastUsageMetadata.promptTokenCount || promptTokens
+					outputTokens = lastUsageMetadata.candidatesTokenCount || outputTokens
+				}
+
+				// Check if this is the final chunk
+				if (candidate?.finishReason) {
+					break
+				}
+			}
+
+			// Yield usage information
+			if (lastUsageMetadata) {
+				yield {
+					type: "usage",
+					inputTokens: promptTokens,
+					outputTokens: outputTokens,
+					totalCost: 0, // Free tier
+				}
+			}
+		} catch (error) {
+			// Handle rate limit errors similar to the Gemini provider
+			if (error instanceof Error) {
+				// Check for rate limit patterns in the error message
+				const rateLimitPatterns = [
+					/got status: 429/i,
+					/429 Too Many Requests/i,
+					/rate limit exceeded/i,
+					/too many requests/i,
+					/quota exceeded/i,
+					/resource exhausted/i,
+					/code 429/i,
+				]
+
+				const isRateLimit = rateLimitPatterns.some((pattern) => pattern.test(error.message))
+
+				if (isRateLimit) {
+					const rateLimitError = Object.assign(new Error(error.message), {
+						...error,
+						status: 429,
+					})
+					throw rateLimitError
+				}
+			}
+
+			// Re-throw the original error if it's not a rate limit error
+			throw error
+		}
+	}
+
+	/**
+	 * Get the model ID and info
+	 */
+	getModel(): { id: GeminiCliModelId; info: ModelInfo } {
+		const modelId = this.options.apiModelId as GeminiCliModelId
+		if (modelId && modelId in geminiCliModels) {
+			return { id: modelId, info: geminiCliModels[modelId] }
+		}
+		return {
+			id: geminiCliDefaultModelId,
+			info: geminiCliModels[geminiCliDefaultModelId],
+		}
+	}
+}

src/api/providers/openrouter.ts

@@ -44,6 +44,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 +53,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
 			}
@@ -81,7 +105,7 @@ export class OpenRouterHandler implements ApiHandler {
 					inputTokens: chunk.usage.prompt_tokens || 0,
 					outputTokens: chunk.usage.completion_tokens || 0,
 					// @ts-ignore-next-line
-					totalCost: chunk.usage.cost || 0,
+					totalCost: (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0),
 				}
 				didOutputUsage = true
 			}

src/core/assistant-message/diff.ts

@@ -8,11 +8,13 @@ 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_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_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH$/
-const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE$/
+
+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 {

src/core/prompts/model_prompts/claude4.ts

@@ -268,7 +268,9 @@ Usage:
 </new_task>
 
 ## plan_mode_respond
-Description: Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should be used when you need to provide a response to a question or statement from the user about how you plan to accomplish the task. This tool is only available in PLAN MODE. The environment_details will specify the current mode, if it is not PLAN MODE then you should not use this tool. Depending on the user's message, you may ask questions to get clarification about the user's request, architect a solution to the task, and to brainstorm ideas with the user. For example, if the user's task is to create a website, you may start by asking some clarifying questions, then present a detailed plan for how you will accomplish the task given the context, and perhaps engage in a back and forth to finalize the details before the user switches you to ACT MODE to implement the solution. IMPORTANT NOTE: You should NOT ask for permission to read files or explore the repo. Just do that proactively. This tool should only be used when you've already gathered enough information to make a plan, or if you have a question for the user.
+Description: Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should ONLY be used when you have already explored the relevant files and are ready to present a concrete plan. DO NOT use this tool to announce what files you're going to read - just read them first. This tool is only available in PLAN MODE. The environment_details will specify the current mode, if it is not PLAN_MODE then you should not use this tool. For example, if the user's task is to create a website, you may start by asking some clarifying questions with the ask_followup_question tool if their message was vague, explore the codebase, read files, then present a detailed plan for how you will accomplish the task given the context, and perhaps engage in a back and forth to finalize the details before the user switches you to ACT_MODE to implement the solution. 
+CRITICAL: You must complete your information gathering (reading files, exploring the codebase) BEFORE using this tool. The user expects to see a well thought-out plan based on actual analysis, not intentions.
+
 Parameters:
 - response: (required) The response to provide to the user. Do not try to use tools in this parameter, this is simply a chat response. (You MUST use the response parameter, do not simply place the response text directly within <plan_mode_respond> tags.)
 Usage:
@@ -572,8 +574,8 @@ In each user message, the environment_details will specify the current mode. The
 ## What is PLAN MODE?
 
 - While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
-- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
-- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well.
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well. Present the plan to the user using the plan_mode_respond tool.
 - Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
 - If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
 - Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
@@ -621,6 +623,7 @@ RULES
 - When you want to modify a file, use the replace_in_file or write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
 - Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
 - You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
+- When the user is being vague, you should be proactive about asking clarifying questions using the ask_followup_question tool to ensure you understand their request. However, if you can infer the user's intent based on the context and available tools, you should proceed without asking unnecessary questions
 - When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
 - The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
 - Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${

src/core/prompts/system.ts

@@ -12,14 +12,14 @@ export const SYSTEM_PROMPT = async (
 	supportsBrowserUse: boolean,
 	mcpHub: McpHub,
 	browserSettings: BrowserSettings,
-	isClaude4ModelFamily: boolean = false,
+	isNextGenModel: boolean = false,
 ) => {
 
-	if (isClaude4ModelFamily && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
+	if (isNextGenModel && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
 		return SYSTEM_PROMPT_CLAUDE4_EXPERIMENTAL(cwd, supportsBrowserUse, mcpHub, browserSettings)
 	}
 
-  if (isClaude4ModelFamily) {
+  if (isNextGenModel) {
     return SYSTEM_PROMPT_CLAUDE4(cwd, supportsBrowserUse, mcpHub, browserSettings)
   }
 

src/core/storage/state-migrations.ts

@@ -0,0 +1,147 @@
+import * as vscode from "vscode"
+import { ensureRulesDirectoryExists } from "./disk"
+import fs from "fs/promises"
+import path from "path"
+import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceState } from "./state"
+import { GlobalStateKey } from "./state-keys"
+
+export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.ExtensionContext) {
+	// Keys that were migrated from global storage to workspace storage
+	const keysToMigrate = [
+		// Core settings
+		"apiProvider",
+		"apiModelId",
+		"thinkingBudgetTokens",
+		"reasoningEffort",
+		"chatSettings",
+		"vsCodeLmModelSelector",
+
+		// Provider-specific model keys
+		"awsBedrockCustomSelected",
+		"awsBedrockCustomModelBaseId",
+		"openRouterModelId",
+		"openRouterModelInfo",
+		"openAiModelId",
+		"openAiModelInfo",
+		"ollamaModelId",
+		"lmStudioModelId",
+		"liteLlmModelId",
+		"liteLlmModelInfo",
+		"requestyModelId",
+		"requestyModelInfo",
+		"togetherModelId",
+		"fireworksModelId",
+
+		// Previous mode settings
+		"previousModeApiProvider",
+		"previousModeModelId",
+		"previousModeModelInfo",
+		"previousModeVsCodeLmModelSelector",
+		"previousModeThinkingBudgetTokens",
+		"previousModeReasoningEffort",
+		"previousModeAwsBedrockCustomSelected",
+		"previousModeAwsBedrockCustomModelBaseId",
+	]
+
+	for (const key of keysToMigrate) {
+		const globalValue = await getGlobalState(context, key as GlobalStateKey)
+		if (globalValue !== undefined) {
+			const workspaceValue = await getWorkspaceState(context, key)
+			if (workspaceValue === undefined) {
+				await updateWorkspaceState(context, key, globalValue)
+			}
+			// Delete from global storage regardless of whether we copied it
+			await updateGlobalState(context, key as GlobalStateKey, undefined)
+		}
+	}
+}
+
+export async function migrateMcpMarketplaceEnableSetting(mcpMarketplaceEnabledRaw: boolean | undefined): Promise<boolean> {
+	const config = vscode.workspace.getConfiguration("cline")
+	const mcpMarketplaceEnabled = config.get<boolean>("mcpMarketplace.enabled")
+	if (mcpMarketplaceEnabled !== undefined) {
+		// Remove from VSCode configuration
+		await config.update("mcpMarketplace.enabled", undefined, true)
+
+		return !mcpMarketplaceEnabled
+	}
+	return mcpMarketplaceEnabledRaw ?? true
+}
+
+export async function migrateEnableCheckpointsSetting(enableCheckpointsSettingRaw: boolean | undefined): Promise<boolean> {
+	const config = vscode.workspace.getConfiguration("cline")
+	const enableCheckpoints = config.get<boolean>("enableCheckpoints")
+	if (enableCheckpoints !== undefined) {
+		// Remove from VSCode configuration
+		await config.update("enableCheckpoints", undefined, true)
+		return enableCheckpoints
+	}
+	return enableCheckpointsSettingRaw ?? true
+}
+
+export async function migrateCustomInstructionsToGlobalRules(context: vscode.ExtensionContext) {
+	try {
+		const customInstructions = (await context.globalState.get("customInstructions")) as string | undefined
+
+		if (customInstructions?.trim()) {
+			console.log("Migrating custom instructions to global Cline rules...")
+
+			// Create global .clinerules directory if it doesn't exist
+			const globalRulesDir = await ensureRulesDirectoryExists()
+
+			// Use a fixed filename for custom instructions
+			const migrationFileName = "custom_instructions.md"
+			const migrationFilePath = path.join(globalRulesDir, migrationFileName)
+
+			try {
+				// Check if file already exists to determine if we should append
+				let existingContent = ""
+				try {
+					existingContent = await fs.readFile(migrationFilePath, "utf8")
+				} catch (readError) {
+					// File doesn't exist, which is fine
+				}
+
+				// Append or create the file with custom instructions
+				const contentToWrite = existingContent
+					? `${existingContent}\n\n---\n\n${customInstructions.trim()}`
+					: customInstructions.trim()
+
+				await fs.writeFile(migrationFilePath, contentToWrite)
+				console.log(`Successfully ${existingContent ? "appended to" : "created"} migration file: ${migrationFilePath}`)
+			} catch (fileError) {
+				console.error("Failed to write migration file:", fileError)
+				return
+			}
+
+			// Remove customInstructions from global state only after successful file creation
+			await context.globalState.update("customInstructions", undefined)
+			console.log("Successfully migrated custom instructions to global Cline rules")
+		}
+	} catch (error) {
+		console.error("Failed to migrate custom instructions to global rules:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
+export async function migrateModeFromWorkspaceStorageToControllerState(context: vscode.ExtensionContext) {
+	try {
+		// Get current chatSettings from workspace storage
+		const chatSettings = (await getWorkspaceState(context, "chatSettings")) as any
+
+		if (chatSettings && typeof chatSettings === "object" && "mode" in chatSettings) {
+			console.log("Cleaning up mode from workspace storage...")
+
+			// Remove mode property from chatSettings
+			const { mode, ...cleanedChatSettings } = chatSettings
+
+			// Save cleaned chatSettings back to workspace storage
+			await updateWorkspaceState(context, "chatSettings", cleanedChatSettings)
+
+			console.log("Successfully removed mode from workspace storage chatSettings")
+		}
+	} catch (error) {
+		console.error("Failed to cleanup mode from workspace storage:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}

src/core/storage/state.ts

@@ -1,5 +1,5 @@
 import * as vscode from "vscode"
-import { DEFAULT_CHAT_SETTINGS, OpenAIReasoningEffort } from "@shared/ChatSettings"
+import { DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
 import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
 import { GlobalStateKey, SecretKey } from "./state-keys"
@@ -7,13 +7,11 @@ import { ApiConfiguration, ApiProvider, BedrockModelId, ModelInfo } from "@share
 import { HistoryItem } from "@shared/HistoryItem"
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
 import { BrowserSettings } from "@shared/BrowserSettings"
-import { ChatSettings, StoredChatSettings } from "@shared/ChatSettings"
+import { StoredChatSettings } from "@shared/ChatSettings"
 import { TelemetrySetting } from "@shared/TelemetrySetting"
 import { UserInfo } from "@shared/UserInfo"
 import { ClineRulesToggles } from "@shared/cline-rules"
-import { ensureRulesDirectoryExists } from "./disk"
-import fs from "fs/promises"
-import path from "path"
+import { migrateEnableCheckpointsSetting, migrateMcpMarketplaceEnableSetting } from "./state-migrations"
 /*
 	Storage
 	https://dev.to/kompotkot/how-to-use-secretstorage-in-your-vscode-extensions-2hco
@@ -54,147 +52,6 @@ export async function getWorkspaceState(context: vscode.ExtensionContext, key: s
 	return await context.workspaceState.get(key)
 }
 
-export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.ExtensionContext) {
-	// Keys that were migrated from global storage to workspace storage
-	const keysToMigrate = [
-		// Core settings
-		"apiProvider",
-		"apiModelId",
-		"thinkingBudgetTokens",
-		"reasoningEffort",
-		"chatSettings",
-		"vsCodeLmModelSelector",
-
-		// Provider-specific model keys
-		"awsBedrockCustomSelected",
-		"awsBedrockCustomModelBaseId",
-		"openRouterModelId",
-		"openRouterModelInfo",
-		"openAiModelId",
-		"openAiModelInfo",
-		"ollamaModelId",
-		"lmStudioModelId",
-		"liteLlmModelId",
-		"liteLlmModelInfo",
-		"requestyModelId",
-		"requestyModelInfo",
-		"togetherModelId",
-		"fireworksModelId",
-
-		// Previous mode settings
-		"previousModeApiProvider",
-		"previousModeModelId",
-		"previousModeModelInfo",
-		"previousModeVsCodeLmModelSelector",
-		"previousModeThinkingBudgetTokens",
-		"previousModeReasoningEffort",
-		"previousModeAwsBedrockCustomSelected",
-		"previousModeAwsBedrockCustomModelBaseId",
-	]
-
-	for (const key of keysToMigrate) {
-		const globalValue = await getGlobalState(context, key as GlobalStateKey)
-		if (globalValue !== undefined) {
-			const workspaceValue = await getWorkspaceState(context, key)
-			if (workspaceValue === undefined) {
-				await updateWorkspaceState(context, key, globalValue)
-			}
-			// Delete from global storage regardless of whether we copied it
-			await updateGlobalState(context, key as GlobalStateKey, undefined)
-		}
-	}
-}
-
-async function migrateMcpMarketplaceEnableSetting(mcpMarketplaceEnabledRaw: boolean | undefined): Promise<boolean> {
-	const config = vscode.workspace.getConfiguration("cline")
-	const mcpMarketplaceEnabled = config.get<boolean>("mcpMarketplace.enabled")
-	if (mcpMarketplaceEnabled !== undefined) {
-		// Remove from VSCode configuration
-		await config.update("mcpMarketplace.enabled", undefined, true)
-
-		return !mcpMarketplaceEnabled
-	}
-	return mcpMarketplaceEnabledRaw ?? true
-}
-
-async function migrateEnableCheckpointsSetting(enableCheckpointsSettingRaw: boolean | undefined): Promise<boolean> {
-	const config = vscode.workspace.getConfiguration("cline")
-	const enableCheckpoints = config.get<boolean>("enableCheckpoints")
-	if (enableCheckpoints !== undefined) {
-		// Remove from VSCode configuration
-		await config.update("enableCheckpoints", undefined, true)
-		return enableCheckpoints
-	}
-	return enableCheckpointsSettingRaw ?? true
-}
-
-export async function migrateCustomInstructionsToGlobalRules(context: vscode.ExtensionContext) {
-	try {
-		const customInstructions = (await context.globalState.get("customInstructions")) as string | undefined
-
-		if (customInstructions?.trim()) {
-			console.log("Migrating custom instructions to global Cline rules...")
-
-			// Create global .clinerules directory if it doesn't exist
-			const globalRulesDir = await ensureRulesDirectoryExists()
-
-			// Use a fixed filename for custom instructions
-			const migrationFileName = "custom_instructions.md"
-			const migrationFilePath = path.join(globalRulesDir, migrationFileName)
-
-			try {
-				// Check if file already exists to determine if we should append
-				let existingContent = ""
-				try {
-					existingContent = await fs.readFile(migrationFilePath, "utf8")
-				} catch (readError) {
-					// File doesn't exist, which is fine
-				}
-
-				// Append or create the file with custom instructions
-				const contentToWrite = existingContent
-					? `${existingContent}\n\n---\n\n${customInstructions.trim()}`
-					: customInstructions.trim()
-
-				await fs.writeFile(migrationFilePath, contentToWrite)
-				console.log(`Successfully ${existingContent ? "appended to" : "created"} migration file: ${migrationFilePath}`)
-			} catch (fileError) {
-				console.error("Failed to write migration file:", fileError)
-				return
-			}
-
-			// Remove customInstructions from global state only after successful file creation
-			await context.globalState.update("customInstructions", undefined)
-			console.log("Successfully migrated custom instructions to global Cline rules")
-		}
-	} catch (error) {
-		console.error("Failed to migrate custom instructions to global rules:", error)
-		// Continue execution - migration failure shouldn't break extension startup
-	}
-}
-
-export async function cleanupModeFromWorkspaceStorage(context: vscode.ExtensionContext) {
-	try {
-		// Get current chatSettings from workspace storage
-		const chatSettings = (await getWorkspaceState(context, "chatSettings")) as any
-
-		if (chatSettings && typeof chatSettings === "object" && "mode" in chatSettings) {
-			console.log("Cleaning up mode from workspace storage...")
-
-			// Remove mode property from chatSettings
-			const { mode, ...cleanedChatSettings } = chatSettings
-
-			// Save cleaned chatSettings back to workspace storage
-			await updateWorkspaceState(context, "chatSettings", cleanedChatSettings)
-
-			console.log("Successfully removed mode from workspace storage chatSettings")
-		}
-	} catch (error) {
-		console.error("Failed to cleanup mode from workspace storage:", error)
-		// Continue execution - migration failure shouldn't break extension startup
-	}
-}
-
 export async function getAllExtensionState(context: vscode.ExtensionContext) {
 	const [
 		isNewUser,

src/core/task/ToolExecutor.ts

@@ -30,7 +30,7 @@ import { ClineAskResponse } from "@shared/WebviewMessage"
 import { fixModelHtmlEscaping, removeInvalidChars } from "@utils/string"
 import { fileExistsAtPath } from "@utils/fs"
 import { formatResponse } from "../prompts/responses"
-import { isClaude4ModelFamily } from "@utils/model-utils"
+import { isClaude4ModelFamily, isGemini2dot5ModelFamily } from "@utils/model-utils"
 import { ToolResponse, USE_EXPERIMENTAL_CLAUDE4_FEATURES } from "."
 import { serializeError } from "serialize-error"
 import * as path from "path"
@@ -105,12 +105,12 @@ export class ToolExecutor {
 	) {}
 
 	private pushToolResult = (content: ToolResponse, block: ToolUse) => {
-		const isClaude4Model = isClaude4ModelFamily(this.api)
+		const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
 
 		if (typeof content === "string") {
 			const resultText = content || "(tool did not return anything)"
 
-			if (isClaude4Model && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
+			if (isNextGenModel && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
 				// Claude 4 family: Use function_results format
 				this.taskState.userMessageContent.push({
 					type: "text",
@@ -472,9 +472,9 @@ export class ToolExecutor {
 
 						const currentFullJson = block.params.diff
 						// Check if we should use streaming (e.g., for specific models)
-						const isClaude4Model = isClaude4ModelFamily(this.api)
+						const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
 						// Going through claude family of models
-						if (isClaude4Model && USE_EXPERIMENTAL_CLAUDE4_FEATURES && currentFullJson) {
+						if (isNextGenModel && USE_EXPERIMENTAL_CLAUDE4_FEATURES && currentFullJson) {
 							const streamingResult = await this.handleStreamingJsonReplacement(block, relPath, currentFullJson)
 
 							if (streamingResult.error) {
@@ -839,7 +839,6 @@ export class ToolExecutor {
 				}
 			}
 			case "list_files": {
-				const isClaude4Model = isClaude4ModelFamily(this.api)
 				const relDirPath: string | undefined = block.params.path
 				const recursiveRaw: string | undefined = block.params.recursive
 				const recursive = recursiveRaw?.toLowerCase() === "true"
@@ -989,7 +988,6 @@ export class ToolExecutor {
 				}
 			}
 			case "search_files": {
-				const isClaude4Model = isClaude4ModelFamily(this.api)
 				const relDirPath: string | undefined = block.params.path
 				const regex: string | undefined = block.params.regex
 				const filePattern: string | undefined = block.params.file_pattern

src/core/task/index.ts

@@ -90,7 +90,7 @@ import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
 import { McpHub } from "@services/mcp/McpHub"
 import { isInTestMode } from "../../services/test/TestMode"
 import { processFilesIntoText } from "@integrations/misc/extract-text"
-import { isClaude4ModelFamily } from "@utils/model-utils"
+import { isClaude4ModelFamily, isGemini2dot5ModelFamily } from "@utils/model-utils"
 import { MessageStateHandler } from "./message-state"
 import { formatErrorWithStatusCode, updateApiReqMsg } from "./utils"
 import { TaskState } from "./TaskState"
@@ -1654,8 +1654,8 @@ export class Task {
 
 		const supportsBrowserUse = modelSupportsBrowserUse && !disableBrowserTool // only enable browser use if the model supports it and the user hasn't disabled it
 
-		const isClaude4Model = isClaude4ModelFamily(this.api)
-		let systemPrompt = await SYSTEM_PROMPT(cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isClaude4Model)
+		const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
+		let systemPrompt = await SYSTEM_PROMPT(cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isNextGenModel)
 
 		await this.migratePreferredLanguageToolSetting()
 		const preferredLanguage = getLanguageKey(this.chatSettings.preferredLanguage as LanguageDisplay)
@@ -1965,7 +1965,7 @@ export class Task {
 				"mistake_limit_reached",
 				this.api.getModel().id.includes("claude")
 					? `This may indicate a failure in his thought process or inability to use a tool properly, which can be mitigated with some user guidance (e.g. "Try breaking down the task into smaller steps").`
-					: "Cline uses complex prompts and iterative task execution that may be challenging for less capable models. For best results, it's recommended to use Claude 3.7 Sonnet for its advanced agentic coding capabilities.",
+					: "Cline uses complex prompts and iterative task execution that may be challenging for less capable models. For best results, it's recommended to use Claude 4 Sonnet for its advanced agentic coding capabilities.",
 			)
 			if (response === "messageResponse") {
 				// This userContent is for the *next* API call.
@@ -2223,8 +2223,8 @@ export class Task {
 							assistantMessage += chunk.text
 							// parse raw assistant message into content blocks
 							const prevLength = this.taskState.assistantMessageContent.length
-							const isClaude4Model = isClaude4ModelFamily(this.api)
-							if (isClaude4Model && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
+							const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
+							if (isNextGenModel && USE_EXPERIMENTAL_CLAUDE4_FEATURES) {
 								this.taskState.assistantMessageContent = parseAssistantMessageV3(assistantMessage)
 							} else {
 								this.taskState.assistantMessageContent = parseAssistantMessageV2(assistantMessage)

src/extension.ts

@@ -25,8 +25,8 @@ import { sendAccountButtonClickedEvent } from "./core/controller/ui/subscribeToA
 import {
 	migratePlanActGlobalToWorkspaceStorage,
 	migrateCustomInstructionsToGlobalRules,
-	cleanupModeFromWorkspaceStorage,
-} from "./core/storage/state"
+	migrateModeFromWorkspaceStorageToControllerState,
+} from "./core/storage/state-migrations"
 
 import { sendFocusChatInputEvent } from "./core/controller/ui/subscribeToFocusChatInput"
 import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
@@ -64,8 +64,8 @@ export async function activate(context: vscode.ExtensionContext) {
 	// Migrate custom instructions to global Cline rules (one-time cleanup)
 	await migrateCustomInstructionsToGlobalRules(context)
 
-	// Clean up mode from workspace storage (one-time cleanup)
-	await cleanupModeFromWorkspaceStorage(context)
+	// Migrate mode from workspace storage to controller state (one-time cleanup)
+	await migrateModeFromWorkspaceStorageToControllerState(context)
 
 	// Clean up orphaned file context warnings (startup cleanup)
 	await FileContextTracker.cleanupOrphanedWarnings(context)

src/hosts/host-provider-types.ts

@@ -1,4 +1,8 @@
-import { UriServiceClientInterface, WatchServiceClientInterface } from "@generated/hosts/host-bridge-client-types"
+import {
+	UriServiceClientInterface,
+	WatchServiceClientInterface,
+	WorkspaceServiceClientInterface,
+} from "@generated/hosts/host-bridge-client-types"
 
 /**
  * Interface for host bridge client providers
@@ -6,6 +10,7 @@ import { UriServiceClientInterface, WatchServiceClientInterface } from "@generat
 export interface HostBridgeClientProvider {
 	uriServiceClient: UriServiceClientInterface
 	watchServiceClient: WatchServiceClientInterface
+	workspaceClient: WorkspaceServiceClientInterface
 }
 
 /**

src/hosts/vscode/client/host-grpc-client.ts

@@ -5,4 +5,5 @@ import * as host from "@shared/proto/index.host"
 export const vscodeHostBridgeClient: HostBridgeClientProvider = {
 	uriServiceClient: createGrpcClient(host.UriServiceDefinition),
 	watchServiceClient: createGrpcClient(host.WatchServiceDefinition),
+	workspaceClient: createGrpcClient(host.WorkspaceServiceDefinition),
 }

src/hosts/vscode/workspace/getWorkspacePaths.ts

@@ -0,0 +1,6 @@
+import { GetWorkspacePathsRequest, GetWorkspacePathsResponse } from "@/shared/proto/index.host"
+import * as vscode from "vscode"
+export async function getWorkspacePaths(_: GetWorkspacePathsRequest): Promise<GetWorkspacePathsResponse> {
+	const paths = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath) ?? []
+	return GetWorkspacePathsResponse.create({ paths: paths })
+}

src/shared/api.ts

@@ -10,6 +10,7 @@ export type ApiProvider =
 	| "ollama"
 	| "lmstudio"
 	| "gemini"
+	| "gemini-cli"
 	| "openai-native"
 	| "requesty"
 	| "together"
@@ -69,6 +70,8 @@ export interface ApiHandlerOptions {
 	lmStudioBaseUrl?: string
 	geminiApiKey?: string
 	geminiBaseUrl?: string
+	geminiCliOAuthPath?: string
+	geminiCliProjectId?: string
 	openAiNativeApiKey?: string
 	deepSeekApiKey?: string
 	requestyApiKey?: string
@@ -400,7 +403,7 @@ export const bedrockModels = {
 
 // OpenRouter
 // https://openrouter.ai/models?order=newest&supported_parameters=tools
-export const openRouterDefaultModelId = "anthropic/claude-3.7-sonnet" // will always exist in openRouterModels
+export const openRouterDefaultModelId = "anthropic/claude-sonnet-4" // will always exist in openRouterModels
 export const openRouterDefaultModelInfo: ModelInfo = {
 	maxTokens: 8192,
 	contextWindow: 200_000,
@@ -412,7 +415,7 @@ export const openRouterDefaultModelInfo: ModelInfo = {
 	cacheWritesPrice: 3.75,
 	cacheReadsPrice: 0.3,
 	description:
-		"Claude 3.7 Sonnet is an advanced large language model with improved reasoning, coding, and problem-solving capabilities. It introduces a hybrid reasoning approach, allowing users to choose between rapid responses and extended, step-by-step processing for complex tasks. The model demonstrates notable improvements in coding, particularly in front-end development and full-stack updates, and excels in agentic workflows, where it can autonomously navigate multi-step processes. \n\nClaude 3.7 Sonnet maintains performance parity with its predecessor in standard mode while offering an extended reasoning mode for enhanced accuracy in math, coding, and instruction-following tasks.\n\nRead more at the [blog post here](https://www.anthropic.com/news/claude-3-7-sonnet)",
+		"Claude Sonnet 4 delivers superior intelligence across coding, agentic search, and AI agent capabilities. It's a powerful choice for agentic coding, and can complete tasks across the entire software development lifecycle—from initial planning to bug fixes, maintenance to large refactors. It offers strong performance in both planning and solving for complex coding tasks, making it an ideal choice to power end-to-end software development processes.\n\nRead more in the [blog post here](https://www.anthropic.com/claude/sonnet)",
 }
 // Vertex AI
 // https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude
@@ -721,7 +724,7 @@ export const openAiModelInfoSaneDefaults: OpenAiCompatibleModelInfo = {
 // Gemini
 // https://ai.google.dev/gemini-api/docs/models/gemini
 export type GeminiModelId = keyof typeof geminiModels
-export const geminiDefaultModelId: GeminiModelId = "gemini-2.0-flash-001"
+export const geminiDefaultModelId: GeminiModelId = "gemini-2.5-pro"
 export const geminiModels = {
 	"gemini-2.5-pro": {
 		maxTokens: 65536,
@@ -875,6 +878,138 @@ export const geminiModels = {
 	},
 } as const satisfies Record<string, ModelInfo>
 
+// Gemini CLI (OAuth-based)
+export type GeminiCliModelId = keyof typeof geminiCliModels
+export const geminiCliDefaultModelId: GeminiCliModelId = "gemini-2.5-flash"
+export const geminiCliModels = {
+	"gemini-2.5-pro": {
+		maxTokens: 65536,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0, // Free tier via OAuth
+		outputPrice: 0, // Free tier via OAuth
+		description: "Google's Gemini 2.5 Pro model via OAuth (free tier)",
+	},
+	"gemini-2.5-flash": {
+		maxTokens: 65536,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0, // Free tier via OAuth
+		outputPrice: 0, // Free tier via OAuth
+		description: "Google's Gemini 2.5 Flash model via OAuth (free tier)",
+	},
+	"gemini-2.0-flash-001": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0, // Free tier via OAuth
+		outputPrice: 0, // Free tier via OAuth
+		description: "Google's Gemini 2.0 Flash model via OAuth (free tier)",
+	},
+	"gemini-2.0-flash-lite-preview-02-05": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 2.0 Flash Lite Preview model via OAuth",
+	},
+	"gemini-2.0-pro-exp-02-05": {
+		maxTokens: 8192,
+		contextWindow: 2_097_152,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 2.0 Pro Experimental model via OAuth",
+	},
+	"gemini-2.0-flash-thinking-exp-01-21": {
+		maxTokens: 65_536,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 2.0 Flash Thinking Experimental model via OAuth",
+	},
+	"gemini-2.0-flash-thinking-exp-1219": {
+		maxTokens: 8192,
+		contextWindow: 32_767,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 2.0 Flash Thinking Experimental (1219) model via OAuth",
+	},
+	"gemini-2.0-flash-exp": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 2.0 Flash Experimental model via OAuth",
+	},
+	"gemini-1.5-flash-002": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0, // Free tier via OAuth
+		outputPrice: 0, // Free tier via OAuth
+		description: "Google's Gemini 1.5 Flash 002 model via OAuth (free tier)",
+	},
+	"gemini-1.5-flash-exp-0827": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 1.5 Flash Experimental (0827) model via OAuth",
+	},
+	"gemini-1.5-flash-8b-exp-0827": {
+		maxTokens: 8192,
+		contextWindow: 1_048_576,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 1.5 Flash 8B Experimental model via OAuth",
+	},
+	"gemini-1.5-pro-002": {
+		maxTokens: 8192,
+		contextWindow: 2_097_152,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 1.5 Pro 002 model via OAuth",
+	},
+	"gemini-1.5-pro-exp-0827": {
+		maxTokens: 8192,
+		contextWindow: 2_097_152,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini 1.5 Pro Experimental model via OAuth",
+	},
+	"gemini-exp-1206": {
+		maxTokens: 8192,
+		contextWindow: 2_097_152,
+		supportsImages: true,
+		supportsPromptCache: false,
+		inputPrice: 0,
+		outputPrice: 0,
+		description: "Google's Gemini Experimental (1206) model via OAuth",
+	},
+} as const satisfies Record<string, ModelInfo>
+
 // OpenAI Native
 // https://openai.com/api/pricing/
 export type OpenAiNativeModelId = keyof typeof openAiNativeModels
@@ -1876,7 +2011,7 @@ export const liteLlmModelInfoSaneDefaults: LiteLLMModelInfo = {
 // AskSage Models
 // https://docs.asksage.ai/
 export type AskSageModelId = keyof typeof askSageModels
-export const askSageDefaultModelId: AskSageModelId = "claude-35-sonnet"
+export const askSageDefaultModelId: AskSageModelId = "claude-4-sonnet"
 export const askSageDefaultURL: string = "https://api.asksage.ai/server"
 export const askSageModels = {
 	"gpt-4o": {

src/shared/proto-conversions/models/api-configuration-conversion.ts

@@ -202,6 +202,8 @@ function convertApiProviderToProto(provider: string | undefined): ProtoApiProvid
 			return ProtoApiProvider.LMSTUDIO
 		case "gemini":
 			return ProtoApiProvider.GEMINI
+		case "gemini-cli":
+			return ProtoApiProvider.GEMINI_CLI
 		case "openai-native":
 			return ProtoApiProvider.OPENAI_NATIVE
 		case "requesty":
@@ -262,6 +264,8 @@ function convertProtoToApiProvider(provider: ProtoApiProvider): ApiProvider {
 			return "lmstudio"
 		case ProtoApiProvider.GEMINI:
 			return "gemini"
+		case ProtoApiProvider.GEMINI_CLI:
+			return "gemini-cli"
 		case ProtoApiProvider.OPENAI_NATIVE:
 			return "openai-native"
 		case ProtoApiProvider.REQUESTY:
@@ -379,6 +383,8 @@ export function convertApiConfigurationToProto(config: ApiConfiguration): ProtoA
 		sapAiCoreTokenUrl: config.sapAiCoreTokenUrl,
 		sapAiCoreBaseUrl: config.sapAiCoreBaseUrl,
 		claudeCodePath: config.claudeCodePath,
+		geminiCliOauthPath: config.geminiCliOAuthPath,
+		geminiCliProjectId: config.geminiCliProjectId,
 	}
 }
 
@@ -458,5 +464,7 @@ export function convertProtoToApiConfiguration(protoConfig: ProtoApiConfiguratio
 		sapAiCoreTokenUrl: protoConfig.sapAiCoreTokenUrl,
 		sapAiCoreBaseUrl: protoConfig.sapAiCoreBaseUrl,
 		claudeCodePath: protoConfig.claudeCodePath,
+		geminiCliOAuthPath: protoConfig.geminiCliOauthPath,
+		geminiCliProjectId: protoConfig.geminiCliProjectId,
 	}
 }

src/standalone/host-bridge-client-manager.ts

@@ -1,16 +1,25 @@
 import { Channel, createChannel } from "nice-grpc"
-import { UriServiceClientImpl, WatchServiceClientImpl } from "@generated/standalone/host-bridge-clients"
-import { UriServiceClientInterface, WatchServiceClientInterface } from "@generated/hosts/host-bridge-client-types"
+import {
+	UriServiceClientImpl,
+	WatchServiceClientImpl,
+	WorkspaceServiceClientImpl,
+} from "@generated/standalone/host-bridge-clients"
+import {
+	UriServiceClientInterface,
+	WatchServiceClientInterface,
+	WorkspaceServiceClientInterface,
+} from "@generated/hosts/host-bridge-client-types"
 import { HostBridgeClientProvider } from "@/hosts/host-provider-types"
 
 /**
- * Singleton class to hold the gRPC clients for the host bridge. The clients should be re-used to avoid
+ * Manager to hold the gRPC clients for the host bridge. The clients should be re-used to avoid
  * creating a new TCP connection every time a rpc is made.
  */
 export class ExternalHostBridgeClientManager implements HostBridgeClientProvider {
 	private channel: Channel
 	uriServiceClient: UriServiceClientInterface
 	watchServiceClient: WatchServiceClientInterface
+	workspaceClient: WorkspaceServiceClientInterface
 
 	constructor() {
 		const address = process.env.HOST_BRIDGE_ADDRESS || "localhost:50052"
@@ -18,6 +27,7 @@ export class ExternalHostBridgeClientManager implements HostBridgeClientProvider
 
 		this.uriServiceClient = new UriServiceClientImpl(this.channel)
 		this.watchServiceClient = new WatchServiceClientImpl(this.channel)
+		this.workspaceClient = new WorkspaceServiceClientImpl(this.channel)
 	}
 
 	public close(): void {

src/utils/model-utils.ts

@@ -3,5 +3,13 @@ import { ApiHandler } from "@api/index"
 export function isClaude4ModelFamily(api: ApiHandler): boolean {
 	const model = api.getModel()
 	const modelId = model.id
-	return modelId.includes("sonnet-4") || modelId.includes("opus-4")
+	return (
+		modelId.includes("sonnet-4") || modelId.includes("opus-4") || modelId.includes("4-sonnet") || modelId.includes("4-opus")
+	)
+}
+
+export function isGemini2dot5ModelFamily(api: ApiHandler): boolean {
+	const model = api.getModel()
+	const modelId = model.id
+	return modelId.includes("gemini-2.5")
 }

standalone/runtime-files/vscode/vscode-impls.js

@@ -54,6 +54,7 @@ vscode.window = {
 		all: [],
 		close: async () => {},
 		onDidChangeTabs: createStub("vscode.env.tabGroups.onDidChangeTabs"),
+		activeTabGroup: { tabs: [] },
 	},
 	withProgress: async (_options, task) => {
 		console.log("Stubbed withProgress")

webview-ui/src/components/chat/ChatRow.tsx

@@ -184,7 +184,7 @@ export const ChatRowContent = ({
 	sendMessageFromChatRow,
 	onSetQuote,
 }: ChatRowContentProps) => {
-	const { mcpServers, mcpMarketplaceCatalog, onRelinquishControl } = useExtensionState()
+	const { mcpServers, mcpMarketplaceCatalog, onRelinquishControl, apiConfiguration } = useExtensionState()
 	const [seeNewChangesDisabled, setSeeNewChangesDisabled] = useState(false)
 	const [quoteButtonState, setQuoteButtonState] = useState<QuoteButtonState>({
 		visible: false,
@@ -953,6 +953,88 @@ export const ChatRowContent = ({
 											}
 										}
 
+										// Check for rate limit errors (status code 429)
+										const isRateLimitError =
+											apiRequestFailedMessage?.includes("status code 429") ||
+											apiRequestFailedMessage?.toLowerCase().includes("rate limit") ||
+											apiRequestFailedMessage?.toLowerCase().includes("too many requests") ||
+											apiRequestFailedMessage?.toLowerCase().includes("quota exceeded") ||
+											apiRequestFailedMessage?.toLowerCase().includes("resource exhausted")
+
+										if (isRateLimitError) {
+											// Check if current provider is Gemini CLI to show specific message
+											const isGeminiCliProvider = apiConfiguration?.apiProvider === "gemini-cli"
+
+											if (isGeminiCliProvider) {
+												return (
+													<div
+														style={{
+															backgroundColor: "rgba(255, 191, 0, 0.1)",
+															padding: "12px",
+															borderRadius: "4px",
+															border: "1px solid rgba(255, 191, 0, 0.3)",
+														}}>
+														<div
+															style={{
+																display: "flex",
+																alignItems: "center",
+																marginBottom: "8px",
+															}}>
+															<i
+																className="codicon codicon-warning"
+																style={{
+																	marginRight: "8px",
+																	fontSize: "16px",
+																	color: "#FFA500",
+																}}></i>
+															<span
+																style={{
+																	fontWeight: "bold",
+																	color: "#FFA500",
+																}}>
+																Rate Limit Exceeded
+															</span>
+														</div>
+														<p style={{ margin: 0, fontSize: "14px", lineHeight: "1.4" }}>
+															You've hit the API rate limit. This is likely due to free tier limits.
+														</p>
+														<p style={{ margin: "8px 0 0 0", fontSize: "12px", lineHeight: "1.4" }}>
+															You can read about the tier limits{" "}
+															<a
+																href="https://codeassist.google/"
+																style={{
+																	color: "inherit",
+																	textDecoration: "underline",
+																}}
+																onClick={(e) => {
+																	e.preventDefault()
+																	UiServiceClient.openUrl(
+																		StringRequest.create({
+																			value: "https://codeassist.google/",
+																		}),
+																	).catch((err) => console.error("Failed to open URL:", err))
+																}}>
+																here
+															</a>
+															, or alternatively, you can use the Gemini Flash Model that will give
+															you better limits.
+														</p>
+													</div>
+												)
+											} else {
+												// Generic rate limit error for other providers
+												return (
+													<p
+														style={{
+															...pStyle,
+															color: "var(--vscode-errorForeground)",
+														}}>
+														{apiRequestFailedMessage || apiReqStreamingFailedMessage}
+													</p>
+												)
+											}
+										}
+
 										// Default error display
 										return (
 											<p

webview-ui/src/components/chat/ChatView.tsx

@@ -414,8 +414,28 @@ const ChatView = ({ isHidden, showAnnouncement, hideAnnouncement, showHistoryVie
 	}, [task?.ts])
 
 	const isStreaming = useMemo(() => {
-		return modifiedMessages.at(-1)?.partial === true
-	}, [modifiedMessages])
+		const isLastAsk = !!modifiedMessages.at(-1)?.ask // checking clineAsk isn't enough since messages effect may be called again for a tool for example, set clineAsk to its value, and if the next message is not an ask then it doesn't reset. This is likely due to how much more often we're updating messages as compared to before, and should be resolved with optimizations as it's likely a rendering bug. but as a final guard for now, the cancel button will show if the last message is not an ask
+		const isToolCurrentlyAsking = isLastAsk && clineAsk !== undefined && enableButtons && primaryButtonText !== undefined
+		if (isToolCurrentlyAsking) {
+			return false
+		}
+
+		const isLastMessagePartial = modifiedMessages.at(-1)?.partial === true
+		if (isLastMessagePartial) {
+			return true
+		} else {
+			const lastApiReqStarted = findLast(modifiedMessages, (message) => message.say === "api_req_started")
+			if (lastApiReqStarted && lastApiReqStarted.text != null && lastApiReqStarted.say === "api_req_started") {
+				const cost = JSON.parse(lastApiReqStarted.text).cost
+				if (cost === undefined) {
+					// api request has not finished yet
+					return true
+				}
+			}
+		}
+
+		return false
+	}, [modifiedMessages, clineAsk, enableButtons, primaryButtonText])
 
 	const handleSendMessage = useCallback(
 		async (text: string, images: string[], files: string[]) => {

webview-ui/src/components/settings/ApiOptions.tsx

@@ -2,10 +2,7 @@ import { useExtensionState } from "@/context/ExtensionStateContext"
 import { ModelsServiceClient } from "@/services/grpc-client"
 import { getAsVar, VSC_DESCRIPTION_FOREGROUND } from "@/utils/vscStyles"
 import {
-	anthropicModels,
 	ApiConfiguration,
-	askSageDefaultURL,
-	askSageModels,
 	bedrockDefaultModelId,
 	bedrockModels,
 	cerebrasModels,
@@ -17,7 +14,6 @@ import {
 	mainlandQwenModels,
 	ModelInfo,
 	nebiusModels,
-	openAiNativeModels,
 	vertexGlobalModels,
 	vertexModels,
 	xaiModels,
@@ -56,6 +52,9 @@ import { OpenAICompatibleProvider } from "./providers/OpenAICompatible"
 import { SambanovaProvider } from "./providers/SambanovaProvider"
 import { AnthropicProvider } from "./providers/AnthropicProvider"
 import { AskSageProvider } from "./providers/AskSageProvider"
+import { OpenAINativeProvider } from "./providers/OpenAINative"
+import { GeminiProvider } from "./providers/GeminiProvider"
+import GeminiCliProvider from "./providers/GeminiCliProvider"
 
 interface ApiOptionsProps {
 	showModelOptions: boolean
@@ -86,7 +85,6 @@ const SUPPORTED_THINKING_MODELS: Record<string, string[]> = {
 		"qwen-plus-latest",
 		"qwen-turbo-latest",
 	],
-	gemini: ["gemini-2.5-pro", "gemini-2.5-flash"],
 }
 
 // This is necessary to ensure dropdown opens downward, important for when this is used in popup
@@ -126,8 +124,6 @@ const ApiOptions = ({
 	const [ollamaModels, setOllamaModels] = useState<string[]>([])
 	const [lmStudioModels, setLmStudioModels] = useState<string[]>([])
 	const [vsCodeLmModels, setVsCodeLmModels] = useState<vscodemodels.LanguageModelChatSelector[]>([])
-	const [anthropicBaseUrlSelected, setAnthropicBaseUrlSelected] = useState(!!apiConfiguration?.anthropicBaseUrl)
-	const [geminiBaseUrlSelected, setGeminiBaseUrlSelected] = useState(!!apiConfiguration?.geminiBaseUrl)
 	const [awsEndpointSelected, setAwsEndpointSelected] = useState(!!apiConfiguration?.awsBedrockEndpoint)
 	const [modelConfigurationSelected, setModelConfigurationSelected] = useState(false)
 	const [isDescriptionExpanded, setIsDescriptionExpanded] = useState(false)
@@ -274,6 +270,7 @@ const ApiOptions = ({
 					<VSCodeOption value="openai">OpenAI Compatible</VSCodeOption>
 					<VSCodeOption value="vertex">GCP Vertex AI</VSCodeOption>
 					<VSCodeOption value="gemini">Google Gemini</VSCodeOption>
+					<VSCodeOption value="gemini-cli">Gemini CLI Provider</VSCodeOption>
 					<VSCodeOption value="deepseek">DeepSeek</VSCodeOption>
 					<VSCodeOption value="mistral">Mistral</VSCodeOption>
 					<VSCodeOption value="openai-native">OpenAI</VSCodeOption>
@@ -341,35 +338,13 @@ const ApiOptions = ({
 				</div>
 			)}
 
-			{selectedProvider === "openai-native" && (
-				<div>
-					<VSCodeTextField
-						value={apiConfiguration?.openAiNativeApiKey || ""}
-						style={{ width: "100%" }}
-						type="password"
-						onInput={handleInputChange("openAiNativeApiKey")}
-						placeholder="Enter API Key...">
-						<span style={{ fontWeight: 500 }}>OpenAI API Key</span>
-					</VSCodeTextField>
-					<p
-						style={{
-							fontSize: "12px",
-							marginTop: 3,
-							color: "var(--vscode-descriptionForeground)",
-						}}>
-						This key is stored locally and only used to make API requests from this extension.
-						{!apiConfiguration?.openAiNativeApiKey && (
-							<VSCodeLink
-								href="https://platform.openai.com/api-keys"
-								style={{
-									display: "inline",
-									fontSize: "inherit",
-								}}>
-								You can get an OpenAI API key by signing up here.
-							</VSCodeLink>
-						)}
-					</p>
-				</div>
+			{apiConfiguration && selectedProvider === "openai-native" && (
+				<OpenAINativeProvider
+					apiConfiguration={apiConfiguration}
+					handleInputChange={handleInputChange}
+					showModelOptions={showModelOptions}
+					isPopup={isPopup}
+				/>
 			)}
 
 			{selectedProvider === "qwen" && (
@@ -838,61 +813,23 @@ const ApiOptions = ({
 				</div>
 			)}
 
-			{selectedProvider === "gemini" && (
-				<div>
-					<VSCodeTextField
-						value={apiConfiguration?.geminiApiKey || ""}
-						style={{ width: "100%" }}
-						type="password"
-						onInput={handleInputChange("geminiApiKey")}
-						placeholder="Enter API Key...">
-						<span style={{ fontWeight: 500 }}>Gemini API Key</span>
-					</VSCodeTextField>
+			{apiConfiguration && selectedProvider === "gemini" && (
+				<GeminiProvider
+					apiConfiguration={apiConfiguration}
+					handleInputChange={handleInputChange}
+					showModelOptions={showModelOptions}
+					isPopup={isPopup}
+					setApiConfiguration={setApiConfiguration}
+				/>
+			)}
 
-					<VSCodeCheckbox
-						checked={geminiBaseUrlSelected}
-						onChange={(e: any) => {
-							const isChecked = e.target.checked === true
-							setGeminiBaseUrlSelected(isChecked)
-							if (!isChecked) {
-								setApiConfiguration({
-									...apiConfiguration,
-									geminiBaseUrl: "",
-								})
-							}
-						}}>
-						Use custom base URL
-					</VSCodeCheckbox>
-
-					{geminiBaseUrlSelected && (
-						<VSCodeTextField
-							value={apiConfiguration?.geminiBaseUrl || ""}
-							style={{ width: "100%", marginTop: 3 }}
-							type="url"
-							onInput={handleInputChange("geminiBaseUrl")}
-							placeholder="Default: https://generativelanguage.googleapis.com"
-						/>
-					)}
-
-					<p
-						style={{
-							fontSize: "12px",
-							marginTop: 3,
-							color: "var(--vscode-descriptionForeground)",
-						}}>
-						This key is stored locally and only used to make API requests from this extension.
-						{!apiConfiguration?.geminiApiKey && (
-							<VSCodeLink
-								href="https://aistudio.google.com/apikey"
-								style={{
-									display: "inline",
-									fontSize: "inherit",
-								}}>
-								You can get a Gemini API key by signing up here.
-							</VSCodeLink>
-						)}
-					</p>
-				</div>
+			{apiConfiguration && selectedProvider === "gemini-cli" && (
+				<GeminiCliProvider
+					apiConfiguration={apiConfiguration}
+					handleInputChange={handleInputChange}
+					showModelOptions={showModelOptions}
+					isPopup={isPopup}
+				/>
 			)}
 
 			{selectedProvider === "requesty" && (
@@ -1045,7 +982,7 @@ const ApiOptions = ({
 								}}>
 								The VS Code Language Model API allows you to run models provided by other VS Code extensions
 								(including but not limited to GitHub Copilot). The easiest way to get started is to install the
-								Copilot extension from the VS Marketplace and enabling Claude 3.7 Sonnet.
+								Copilot extension from the VS Marketplace and enabling Claude 4 Sonnet.
 							</p>
 						)}
 
@@ -1663,6 +1600,9 @@ const ApiOptions = ({
 				selectedProvider !== "mistral" &&
 				selectedProvider !== "deepseek" &&
 				selectedProvider !== "sambanova" &&
+				selectedProvider !== "openai-native" &&
+				selectedProvider !== "gemini" &&
+				selectedProvider !== "gemini-cli" &&
 				showModelOptions && (
 					<>
 						<DropdownContainer zIndex={DROPDOWN_Z_INDEX - 2} className="dropdown-container">
@@ -1672,8 +1612,6 @@ const ApiOptions = ({
 							{selectedProvider === "claude-code" && createDropdown(claudeCodeModels)}
 							{selectedProvider === "vertex" &&
 								createDropdown(apiConfiguration?.vertexRegion === "global" ? vertexGlobalModels : vertexModels)}
-							{selectedProvider === "gemini" && createDropdown(geminiModels)}
-							{selectedProvider === "openai-native" && createDropdown(openAiNativeModels)}
 							{selectedProvider === "qwen" &&
 								createDropdown(
 									apiConfiguration?.qwenApiLine === "china" ? mainlandQwenModels : internationalQwenModels,

webview-ui/src/components/settings/BrowserSettingsSection.tsx

@@ -1,5 +1,3 @@
-import { UpdateBrowserSettingsRequest } from "@shared/proto/browser"
-import { EmptyRequest, StringRequest } from "@shared/proto/common"
 import { VSCodeButton, VSCodeCheckbox, VSCodeDropdown, VSCodeOption, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
 import debounce from "debounce"
 import React, { useCallback, useEffect, useState } from "react"
@@ -7,6 +5,13 @@ import styled from "styled-components"
 import { BROWSER_VIEWPORT_PRESETS } from "../../../../src/shared/BrowserSettings"
 import { useExtensionState } from "../../context/ExtensionStateContext"
 import { BrowserServiceClient } from "../../services/grpc-client"
+import { EmptyRequest, StringRequest } from "@shared/proto/common"
+import { BrowserSettings } from "@shared/BrowserSettings"
+
+interface BrowserSettingsSectionProps {
+	localBrowserSettings: BrowserSettings
+	onBrowserSettingsChange: (settings: BrowserSettings) => void
+}
 
 const ConnectionStatusIndicator = ({
 	isChecking,
@@ -51,9 +56,12 @@ const CollapsibleContent = styled.div<{ isOpen: boolean }>`
 	visibility: ${({ isOpen }) => (isOpen ? "visible" : "hidden")};
 `
 
-export const BrowserSettingsSection: React.FC = () => {
+export const BrowserSettingsSection: React.FC<BrowserSettingsSectionProps> = ({
+	localBrowserSettings,
+	onBrowserSettingsChange,
+}) => {
 	const { browserSettings } = useExtensionState()
-	const [localChromePath, setLocalChromePath] = useState(browserSettings.chromeExecutablePath || "")
+	const [localChromePath, setLocalChromePath] = useState(localBrowserSettings.chromeExecutablePath || "")
 	const [isCheckingConnection, setIsCheckingConnection] = useState(false)
 	const [connectionStatus, setConnectionStatus] = useState<boolean | null>(null)
 	const [relaunchResult, setRelaunchResult] = useState<{ success: boolean; message: string } | null>(null)
@@ -86,23 +94,24 @@ export const BrowserSettingsSection: React.FC = () => {
 			})
 	}, [])
 
-	// Sync localChromePath with global state
+	// Sync localChromePath with prop changes
 	useEffect(() => {
-		if (browserSettings.chromeExecutablePath !== localChromePath) {
-			setLocalChromePath(browserSettings.chromeExecutablePath || "")
+		if (localBrowserSettings.chromeExecutablePath !== localChromePath) {
+			setLocalChromePath(localBrowserSettings.chromeExecutablePath || "")
 		}
-		// Removed sync for local disableToolUse state
-	}, [browserSettings.chromeExecutablePath, browserSettings.disableToolUse])
+	}, [localBrowserSettings.chromeExecutablePath])
 
 	// Debounced connection check function
 	const debouncedCheckConnection = useCallback(
 		debounce(() => {
-			if (browserSettings.remoteBrowserEnabled) {
+			if (localBrowserSettings.remoteBrowserEnabled) {
 				setIsCheckingConnection(true)
 				setConnectionStatus(null)
-				if (browserSettings.remoteBrowserHost) {
+				if (localBrowserSettings.remoteBrowserHost) {
 					// Use gRPC for testBrowserConnection
-					BrowserServiceClient.testBrowserConnection(StringRequest.create({ value: browserSettings.remoteBrowserHost }))
+					BrowserServiceClient.testBrowserConnection(
+						StringRequest.create({ value: localBrowserSettings.remoteBrowserHost }),
+					)
 						.then((result) => {
 							setConnectionStatus(result.success)
 							setIsCheckingConnection(false)
@@ -126,153 +135,70 @@ export const BrowserSettingsSection: React.FC = () => {
 				}
 			}
 		}, 1000),
-		[browserSettings.remoteBrowserEnabled, browserSettings.remoteBrowserHost],
+		[localBrowserSettings.remoteBrowserEnabled, localBrowserSettings.remoteBrowserHost],
 	)
 
 	// Check connection when component mounts or when remote settings change
 	useEffect(() => {
-		if (browserSettings.remoteBrowserEnabled) {
+		if (localBrowserSettings.remoteBrowserEnabled) {
 			debouncedCheckConnection()
 		} else {
 			setConnectionStatus(null)
 		}
-	}, [browserSettings.remoteBrowserEnabled, browserSettings.remoteBrowserHost, debouncedCheckConnection])
+	}, [localBrowserSettings.remoteBrowserEnabled, localBrowserSettings.remoteBrowserHost, debouncedCheckConnection])
 
 	const handleViewportChange = (event: Event) => {
 		const target = event.target as HTMLSelectElement
 		const selectedSize = BROWSER_VIEWPORT_PRESETS[target.value as keyof typeof BROWSER_VIEWPORT_PRESETS]
 		if (selectedSize) {
-			BrowserServiceClient.updateBrowserSettings(
-				UpdateBrowserSettingsRequest.create({
-					metadata: {},
-					viewport: {
-						width: selectedSize.width,
-						height: selectedSize.height,
-					},
-					remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-					remoteBrowserHost: browserSettings.remoteBrowserHost,
-					chromeExecutablePath: browserSettings.chromeExecutablePath,
-					disableToolUse: browserSettings.disableToolUse,
-				}),
-			)
-				.then((response) => {
-					if (!response.value) {
-						console.error("Failed to update browser settings")
-					}
-				})
-				.catch((error) => {
-					console.error("Error updating browser settings:", error)
-				})
+			onBrowserSettingsChange({
+				...localBrowserSettings,
+				viewport: {
+					width: selectedSize.width,
+					height: selectedSize.height,
+				},
+			})
 		}
 	}
 
 	const updateRemoteBrowserEnabled = (enabled: boolean) => {
-		BrowserServiceClient.updateBrowserSettings(
-			UpdateBrowserSettingsRequest.create({
-				metadata: {},
-				viewport: {
-					width: browserSettings.viewport.width,
-					height: browserSettings.viewport.height,
-				},
-				remoteBrowserEnabled: enabled,
-				// If disabling, also clear the host
-				remoteBrowserHost: enabled ? browserSettings.remoteBrowserHost : undefined,
-				chromeExecutablePath: browserSettings.chromeExecutablePath,
-				disableToolUse: browserSettings.disableToolUse,
-			}),
-		)
-			.then((response) => {
-				if (!response.value) {
-					console.error("Failed to update browser settings")
-				}
-			})
-			.catch((error) => {
-				console.error("Error updating browser settings:", error)
-			})
+		onBrowserSettingsChange({
+			...localBrowserSettings,
+			remoteBrowserEnabled: enabled,
+			// If disabling, also clear the host
+			remoteBrowserHost: enabled ? localBrowserSettings.remoteBrowserHost : undefined,
+		})
 	}
 
 	const updateRemoteBrowserHost = (host: string | undefined) => {
-		BrowserServiceClient.updateBrowserSettings(
-			UpdateBrowserSettingsRequest.create({
-				metadata: {},
-				viewport: {
-					width: browserSettings.viewport.width,
-					height: browserSettings.viewport.height,
-				},
-				remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-				remoteBrowserHost: host,
-				chromeExecutablePath: browserSettings.chromeExecutablePath,
-				disableToolUse: browserSettings.disableToolUse,
-			}),
-		)
-			.then((response) => {
-				if (!response.value) {
-					console.error("Failed to update browser settings")
-				}
-			})
-			.catch((error) => {
-				console.error("Error updating browser settings:", error)
-			})
+		onBrowserSettingsChange({
+			...localBrowserSettings,
+			remoteBrowserHost: host,
+		})
 	}
 
 	const debouncedUpdateChromePath = useCallback(
 		debounce((newPath: string | undefined) => {
-			BrowserServiceClient.updateBrowserSettings(
-				UpdateBrowserSettingsRequest.create({
-					metadata: {},
-					viewport: {
-						width: browserSettings.viewport.width,
-						height: browserSettings.viewport.height,
-					},
-					remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-					remoteBrowserHost: browserSettings.remoteBrowserHost,
-					chromeExecutablePath: newPath,
-					disableToolUse: browserSettings.disableToolUse,
-				}),
-			)
-				.then((response) => {
-					if (!response.value) {
-						console.error("Failed to update browser settings for chromeExecutablePath")
-					}
-				})
-				.catch((error) => {
-					console.error("Error updating browser settings for chromeExecutablePath:", error)
-				})
+			onBrowserSettingsChange({
+				...localBrowserSettings,
+				chromeExecutablePath: newPath,
+			})
 		}, 500),
-		[browserSettings],
+		[localBrowserSettings, onBrowserSettingsChange],
 	)
 
 	const updateChromeExecutablePath = (path: string | undefined) => {
-		BrowserServiceClient.updateBrowserSettings(
-			UpdateBrowserSettingsRequest.create({
-				metadata: {},
-				viewport: {
-					width: browserSettings.viewport.width,
-					height: browserSettings.viewport.height,
-				},
-				remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-				remoteBrowserHost: browserSettings.remoteBrowserHost,
-				chromeExecutablePath: path,
-				disableToolUse: browserSettings.disableToolUse,
-			}),
-		)
-			.then((response) => {
-				if (!response.value) {
-					console.error("Failed to update browser settings")
-				}
-			})
-			.catch((error) => {
-				console.error("Error updating browser settings:", error)
-			})
+		setLocalChromePath(path || "")
+		debouncedUpdateChromePath(path)
 	}
 
 	// Function to check connection once without changing UI state immediately
 	const checkConnectionOnce = useCallback(() => {
 		// Don't show the spinner for every check to avoid UI flicker
 		// We'll rely on the response to update the connectionStatus
-		if (browserSettings.remoteBrowserHost) {
+		if (localBrowserSettings.remoteBrowserHost) {
 			// Use gRPC for testBrowserConnection
-			BrowserServiceClient.testBrowserConnection(StringRequest.create({ value: browserSettings.remoteBrowserHost }))
+			BrowserServiceClient.testBrowserConnection(StringRequest.create({ value: localBrowserSettings.remoteBrowserHost }))
 				.then((result) => {
 					setConnectionStatus(result.success)
 				})
@@ -290,12 +216,12 @@ export const BrowserSettingsSection: React.FC = () => {
 					setConnectionStatus(false)
 				})
 		}
-	}, [browserSettings.remoteBrowserHost])
+	}, [localBrowserSettings.remoteBrowserHost])
 
 	// Setup continuous polling for connection status when remote browser is enabled
 	useEffect(() => {
 		// Only poll if remote browser mode is enabled
-		if (!browserSettings.remoteBrowserEnabled) {
+		if (!localBrowserSettings.remoteBrowserEnabled) {
 			// Make sure we're not showing checking state when disabled
 			setIsCheckingConnection(false)
 			return
@@ -311,30 +237,13 @@ export const BrowserSettingsSection: React.FC = () => {
 
 		// Cleanup the interval if the component unmounts or remote browser is disabled
 		return () => clearInterval(pollInterval)
-	}, [browserSettings.remoteBrowserEnabled, checkConnectionOnce])
+	}, [localBrowserSettings.remoteBrowserEnabled, checkConnectionOnce])
 
 	const updateDisableToolUse = (disabled: boolean) => {
-		BrowserServiceClient.updateBrowserSettings(
-			UpdateBrowserSettingsRequest.create({
-				metadata: {},
-				viewport: {
-					width: browserSettings.viewport.width,
-					height: browserSettings.viewport.height,
-				},
-				remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-				remoteBrowserHost: browserSettings.remoteBrowserHost,
-				chromeExecutablePath: browserSettings.chromeExecutablePath,
-				disableToolUse: disabled,
-			}),
-		)
-			.then((response) => {
-				if (!response.value) {
-					console.error("Failed to update disableToolUse setting")
-				}
-			})
-			.catch((error) => {
-				console.error("Error updating disableToolUse setting:", error)
-			})
+		onBrowserSettingsChange({
+			...localBrowserSettings,
+			disableToolUse: disabled,
+		})
 	}
 
 	const relaunchChromeDebugMode = () => {
@@ -361,16 +270,16 @@ export const BrowserSettingsSection: React.FC = () => {
 	}
 
 	// Determine if we should show the relaunch button
-	const isRemoteEnabled = Boolean(browserSettings.remoteBrowserEnabled)
+	const isRemoteEnabled = Boolean(localBrowserSettings.remoteBrowserEnabled)
 	const shouldShowRelaunchButton = isRemoteEnabled && connectionStatus === false
-	const isSubSettingsOpen = !(browserSettings.disableToolUse || false)
+	const isSubSettingsOpen = !(localBrowserSettings.disableToolUse || false)
 
 	return (
 		<div id="browser-settings-section" style={{ marginBottom: 20 }}>
 			{/* Master Toggle */}
 			<div style={{ marginBottom: isSubSettingsOpen ? 0 : 10 }}>
 				<VSCodeCheckbox
-					checked={browserSettings.disableToolUse || false}
+					checked={localBrowserSettings.disableToolUse || false}
 					onChange={(e) => updateDisableToolUse((e.target as HTMLInputElement).checked)}>
 					Disable browser tool usage
 				</VSCodeCheckbox>
@@ -394,8 +303,8 @@ export const BrowserSettingsSection: React.FC = () => {
 								Object.entries(BROWSER_VIEWPORT_PRESETS).find(([_, size]) => {
 									const typedSize = size as { width: number; height: number }
 									return (
-										typedSize.width === browserSettings.viewport.width &&
-										typedSize.height === browserSettings.viewport.height
+										typedSize.width === localBrowserSettings.viewport.width &&
+										typedSize.height === localBrowserSettings.viewport.height
 									)
 								})?.[0]
 							}
@@ -422,14 +331,14 @@ export const BrowserSettingsSection: React.FC = () => {
 					{/* This div now contains Remote Connection & Chrome Path */}
 					<div style={{ marginBottom: 4, display: "flex", alignItems: "center", justifyContent: "space-between" }}>
 						<VSCodeCheckbox
-							checked={browserSettings.remoteBrowserEnabled}
+							checked={localBrowserSettings.remoteBrowserEnabled}
 							onChange={(e) => updateRemoteBrowserEnabled((e.target as HTMLInputElement).checked)}>
 							Use remote browser connection
 						</VSCodeCheckbox>
 						<ConnectionStatusIndicator
 							isChecking={isCheckingConnection}
 							isConnected={connectionStatus}
-							remoteBrowserEnabled={browserSettings.remoteBrowserEnabled}
+							remoteBrowserEnabled={localBrowserSettings.remoteBrowserEnabled}
 						/>
 					</div>
 					<p
@@ -441,7 +350,7 @@ export const BrowserSettingsSection: React.FC = () => {
 						Enable Cline to use your Chrome
 						{isBundled ? "(not detected on your machine)" : detectedChromePath ? ` (${detectedChromePath})` : ""}. You
 						can specify a custom path below. Using a remote browser connection requires starting Chrome in debug mode
-						{browserSettings.remoteBrowserEnabled ? (
+						{localBrowserSettings.remoteBrowserEnabled ? (
 							<>
 								{" "}
 								manually (<code>--remote-debugging-port=9222</code>) or using the button below. Enter the host
@@ -452,10 +361,10 @@ export const BrowserSettingsSection: React.FC = () => {
 						)}
 					</p>
 					{/* Moved remote-specific settings to appear directly after enabling remote connection */}
-					{browserSettings.remoteBrowserEnabled && (
+					{localBrowserSettings.remoteBrowserEnabled && (
 						<div style={{ marginLeft: 0, marginTop: 8 }}>
 							<VSCodeTextField
-								value={browserSettings.remoteBrowserHost || ""}
+								value={localBrowserSettings.remoteBrowserHost || ""}
 								placeholder="http://localhost:9222"
 								style={{ width: "100%", marginBottom: 8 }}
 								onChange={(e: any) => updateRemoteBrowserHost(e.target.value || undefined)}
@@ -507,8 +416,7 @@ export const BrowserSettingsSection: React.FC = () => {
 							style={{ width: "100%" }}
 							onChange={(e: any) => {
 								const newValue = e.target.value || ""
-								setLocalChromePath(newValue)
-								debouncedUpdateChromePath(newValue) // Send "" if empty, not undefined
+								updateChromeExecutablePath(newValue)
 							}}
 						/>
 						<p

webview-ui/src/components/settings/OpenRouterModelPicker.tsx

@@ -43,7 +43,7 @@ export interface OpenRouterModelPickerProps {
 // Featured models for Cline provider
 const featuredModels = [
 	{
-		id: "anthropic/claude-3.7-sonnet",
+		id: "anthropic/claude-sonnet-4",
 		description: "Recommended for agentic coding in Cline",
 		label: "Best",
 	},
@@ -334,8 +334,8 @@ const OpenRouterModelPicker: React.FC<OpenRouterModelPickerProps> = ({ isPopup }
 						If you're unsure which model to choose, Cline works best with{" "}
 						<VSCodeLink
 							style={{ display: "inline", fontSize: "inherit" }}
-							onClick={() => handleModelChange("anthropic/claude-3.7-sonnet")}>
-							anthropic/claude-3.7-sonnet.
+							onClick={() => handleModelChange("anthropic/claude-sonnet-4")}>
+							anthropic/claude-sonnet-4.
 						</VSCodeLink>
 						You can also try searching "free" for no-cost options currently available.
 					</>

webview-ui/src/components/settings/SettingsView.tsx

@@ -15,6 +15,7 @@ import { Tab, TabContent, TabHeader, TabList, TabTrigger } from "../common/Tab"
 import { TabButton } from "../mcp/configuration/McpConfigurationView"
 import ApiOptions from "./ApiOptions"
 import BrowserSettingsSection from "./BrowserSettingsSection"
+import { BrowserSettings } from "@shared/BrowserSettings"
 import FeatureSettingsSection from "./FeatureSettingsSection"
 import PreferredLanguageSetting from "./PreferredLanguageSetting" // Added import
 import Section from "./Section"
@@ -138,8 +139,12 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 		mcpResponsesCollapsed,
 		setMcpResponsesCollapsed,
 		setApiConfiguration,
+		browserSettings,
 	} = useExtensionState()
 
+	// Local state for browser settings
+	const [localBrowserSettings, setLocalBrowserSettings] = useState<BrowserSettings>(browserSettings)
+
 	// Store the original state to detect changes
 	const originalState = useRef({
 		apiConfiguration,
@@ -154,6 +159,7 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 		terminalReuseEnabled,
 		terminalOutputLineLimit,
 		defaultTerminalProfile,
+		browserSettings,
 	})
 	const [apiErrorMessage, setApiErrorMessage] = useState<string | undefined>(undefined)
 	const [modelIdErrorMessage, setModelIdErrorMessage] = useState<string | undefined>(undefined)
@@ -207,6 +213,23 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 				} as StringRequest)
 			}
 
+			// Update browser settings if they have changed
+			if (JSON.stringify(localBrowserSettings) !== JSON.stringify(originalState.current.browserSettings)) {
+				const { BrowserServiceClient } = await import("@/services/grpc-client")
+				const { UpdateBrowserSettingsRequest } = await import("@shared/proto/browser")
+
+				await BrowserServiceClient.updateBrowserSettings(
+					UpdateBrowserSettingsRequest.create({
+						metadata: {},
+						viewport: localBrowserSettings.viewport,
+						remoteBrowserEnabled: localBrowserSettings.remoteBrowserEnabled,
+						remoteBrowserHost: localBrowserSettings.remoteBrowserHost,
+						chromeExecutablePath: localBrowserSettings.chromeExecutablePath,
+						disableToolUse: localBrowserSettings.disableToolUse,
+					}),
+				)
+			}
+
 			// Update the original state to reflect the saved changes
 			originalState.current = {
 				apiConfiguration,
@@ -221,6 +244,7 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 				terminalReuseEnabled,
 				terminalOutputLineLimit,
 				defaultTerminalProfile,
+				browserSettings: localBrowserSettings,
 			}
 		} catch (error) {
 			console.error("Failed to update settings:", error)
@@ -251,7 +275,8 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 			shellIntegrationTimeout !== originalState.current.shellIntegrationTimeout ||
 			terminalOutputLineLimit !== originalState.current.terminalOutputLineLimit ||
 			terminalReuseEnabled !== originalState.current.terminalReuseEnabled ||
-			defaultTerminalProfile !== originalState.current.defaultTerminalProfile
+			defaultTerminalProfile !== originalState.current.defaultTerminalProfile ||
+			JSON.stringify(localBrowserSettings) !== JSON.stringify(originalState.current.browserSettings)
 
 		setHasUnsavedChanges(hasChanges)
 	}, [
@@ -267,6 +292,7 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 		terminalReuseEnabled,
 		terminalOutputLineLimit,
 		defaultTerminalProfile,
+		localBrowserSettings,
 	])
 
 	// Handle cancel button click
@@ -319,6 +345,8 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 				if (typeof setMcpResponsesCollapsed === "function") {
 					setMcpResponsesCollapsed(originalState.current.mcpResponsesCollapsed ?? false)
 				}
+				// Reset browser settings
+				setLocalBrowserSettings(originalState.current.browserSettings)
 				// Close settings view
 				onDone()
 			}
@@ -689,7 +717,10 @@ const SettingsView = ({ onDone, targetSection }: SettingsViewProps) => {
 								<div>
 									{renderSectionHeader("browser")}
 									<Section>
-										<BrowserSettingsSection />
+										<BrowserSettingsSection
+											localBrowserSettings={localBrowserSettings}
+											onBrowserSettingsChange={setLocalBrowserSettings}
+										/>
 									</Section>
 								</div>
 							)}

webview-ui/src/components/settings/common/ModelInfoView.tsx

@@ -99,7 +99,7 @@ export const ModelInfoView = ({ selectedModelId, modelInfo, isPopup }: ModelInfo
 	// Internal state management for description expansion
 	const [isDescriptionExpanded, setIsDescriptionExpanded] = useState(false)
 
-	const isGemini = Object.keys(geminiModels).includes(selectedModelId)
+	const isGeminiProvider = Object.keys(geminiModels).includes(selectedModelId)
 	const hasThinkingConfig = hasThinkingBudget(modelInfo)
 	const hasTiers = !!modelInfo.tiers && modelInfo.tiers.length > 0
 
@@ -170,7 +170,7 @@ export const ModelInfoView = ({ selectedModelId, modelInfo, isPopup }: ModelInfo
 			supportsLabel="Supports browser use"
 			doesNotSupportLabel="Does not support browser use"
 		/>,
-		!isGemini && (
+		!isGeminiProvider && (
 			<ModelInfoSupportsItem
 				key="supportsPromptCache"
 				isSupported={supportsPromptCache(modelInfo)}
@@ -195,10 +195,8 @@ export const ModelInfoView = ({ selectedModelId, modelInfo, isPopup }: ModelInfo
 			</span>
 		),
 		outputPriceElement, // Add the generated output price block
-		isGemini && (
-			<span key="geminiInfo" style={{ fontStyle: "italic" }}>
-				* Free up to {selectedModelId && selectedModelId.includes("flash") ? "15" : "2"} requests per minute. After that,
-				billing depends on prompt size.{" "}
+		isGeminiProvider && (
+			<span key="geminiPricing" style={{ fontStyle: "italic" }}>
 				<VSCodeLink href="https://ai.google.dev/pricing" style={{ display: "inline", fontSize: "inherit" }}>
 					For more info, see pricing details.
 				</VSCodeLink>

webview-ui/src/components/settings/providers/GeminiCliProvider.tsx

@@ -0,0 +1,169 @@
+/**
+ * Gemini CLI Provider Component
+ *
+ * This component integrates with Google's Gemini CLI tool for OAuth authentication.
+ *
+ * Attribution: This implementation is inspired by and uses concepts from the Google Gemini CLI,
+ * which is licensed under the Apache License 2.0.
+ * Original project: https://github.com/google-gemini/gemini-cli
+ *
+ * Copyright 2025 Google LLC
+ * Licensed under the Apache License, Version 2.0
+ */
+
+import { ApiConfiguration, geminiCliModels } from "@shared/api"
+import { VSCodeLink, VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
+import { memo } from "react"
+import { ModelSelector } from "../common/ModelSelector"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { normalizeApiConfiguration } from "../utils/providerUtils"
+
+interface GeminiCliProviderProps {
+	apiConfiguration: ApiConfiguration
+	handleInputChange: (field: keyof ApiConfiguration) => (event: any) => void
+	showModelOptions: boolean
+	isPopup?: boolean
+}
+
+const GeminiCliProvider = ({ apiConfiguration, handleInputChange, showModelOptions, isPopup }: GeminiCliProviderProps) => {
+	// Get the normalized configuration
+	const { selectedModelId, selectedModelInfo } = normalizeApiConfiguration(apiConfiguration)
+	return (
+		<div>
+			<VSCodeTextField
+				value={apiConfiguration?.geminiCliOAuthPath || ""}
+				style={{ width: "100%", marginTop: 3 }}
+				type="text"
+				onInput={handleInputChange("geminiCliOAuthPath")}
+				placeholder="Default: ~/.gemini/oauth_creds.json">
+				<span style={{ fontWeight: 500 }}>OAuth Credentials Path (optional)</span>
+			</VSCodeTextField>
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 3,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				Path to the OAuth credentials file. Leave empty to use the default location (~/.gemini/oauth_creds.json).
+			</p>
+
+			{apiConfiguration?.geminiCliProjectId && (
+				<>
+					<VSCodeTextField
+						value={apiConfiguration.geminiCliProjectId}
+						style={{ width: "100%", marginTop: 3 }}
+						type="text"
+						disabled>
+						<span style={{ fontWeight: 500 }}>Discovered Project ID</span>
+					</VSCodeTextField>
+					<p
+						style={{
+							fontSize: "12px",
+							marginTop: 3,
+							color: "var(--vscode-descriptionForeground)",
+						}}>
+						This project ID was automatically discovered from your OAuth credentials.
+					</p>
+				</>
+			)}
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 5,
+					color: "var(--vscode-descriptionForeground)",
+				}}>
+				This provider uses OAuth authentication from the Gemini CLI tool and does not require API keys. If you haven't
+				authenticated yet, please run{" "}
+				<code
+					style={{
+						backgroundColor: "var(--vscode-textCodeBlock-background)",
+						padding: "2px 4px",
+						borderRadius: "3px",
+					}}>
+					gemini
+				</code>{" "}
+				in your terminal first.
+				<br />
+				<VSCodeLink
+					href="https://github.com/google-gemini/gemini-cli?tab=readme-ov-file#quickstart"
+					style={{ display: "inline", fontSize: "inherit" }}>
+					Gemini CLI Setup Instructions
+				</VSCodeLink>
+			</p>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						models={geminiCliModels}
+						selectedModelId={selectedModelId}
+						onChange={handleInputChange("apiModelId")}
+						label="Model"
+					/>
+
+					<ModelInfoView selectedModelId={selectedModelId} modelInfo={selectedModelInfo} isPopup={isPopup} />
+				</>
+			)}
+
+			<div
+				style={{
+					backgroundColor: "var(--vscode-editorWarning-background, rgba(255, 191, 0, 0.1))",
+					padding: "8px",
+					borderRadius: "4px",
+					border: "1px solid var(--vscode-editorWarning-border, rgba(255, 191, 0, 0.3))",
+					marginTop: "8px",
+					marginBottom: "16px",
+				}}>
+				<div
+					style={{
+						display: "flex",
+						alignItems: "center",
+						marginBottom: "4px",
+					}}>
+					<i
+						className="codicon codicon-info"
+						style={{
+							marginRight: "6px",
+							fontSize: "14px",
+							color: "#FFA500",
+						}}></i>
+					<span
+						style={{
+							fontWeight: "bold",
+							color: "#FFA500",
+							fontSize: "12px",
+						}}>
+						Important Requirements
+					</span>
+				</div>
+				<p
+					style={{
+						margin: 0,
+						fontSize: "11px",
+						lineHeight: "1.4",
+						color: "var(--vscode-foreground)",
+					}}>
+					• First, you need to install the <strong>Gemini CLI tool</strong>
+					<br />• Then, run <strong>gemini</strong> in your terminal and make sure you{" "}
+					<strong>Log in with Google</strong>
+					<br />• Only works with <strong>personal Google accounts</strong> (not Google Workspace accounts)
+					<br />
+					• Does not use API keys - authentication is handled via OAuth
+					<br />• Requires the Gemini CLI tool to be installed and authenticated first
+				</p>
+			</div>
+
+			<p
+				style={{
+					fontSize: "12px",
+					marginTop: 5,
+					color: "var(--vscode-charts-green)",
+					fontWeight: 500,
+				}}>
+				✓ Free tier access via OAuth authentication
+			</p>
+		</div>
+	)
+}
+
+export default memo(GeminiCliProvider)

webview-ui/src/components/settings/providers/GeminiProvider.tsx

@@ -0,0 +1,79 @@
+import { ApiConfiguration, geminiModels } from "@shared/api"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { BaseUrlField } from "../common/BaseUrlField"
+import { ModelSelector } from "../common/ModelSelector"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { normalizeApiConfiguration } from "../utils/providerUtils"
+import ThinkingBudgetSlider from "../ThinkingBudgetSlider"
+
+// Gemini models that support thinking/reasoning mode
+const SUPPORTED_THINKING_MODELS = ["gemini-2.5-pro", "gemini-2.5-flash"]
+
+/**
+ * Props for the GeminiProvider component
+ */
+interface GeminiProviderProps {
+	apiConfiguration: ApiConfiguration
+	handleInputChange: (field: keyof ApiConfiguration) => (event: any) => void
+	showModelOptions: boolean
+	isPopup?: boolean
+	setApiConfiguration?: (config: ApiConfiguration) => void
+}
+
+/**
+ * The Gemini provider configuration component
+ */
+export const GeminiProvider = ({
+	apiConfiguration,
+	handleInputChange,
+	showModelOptions,
+	isPopup,
+	setApiConfiguration,
+}: GeminiProviderProps) => {
+	// Get the normalized configuration
+	const { selectedModelId, selectedModelInfo } = normalizeApiConfiguration(apiConfiguration)
+
+	// Create a wrapper for handling field changes more directly
+	const handleFieldChange = (field: keyof ApiConfiguration) => (value: string) => {
+		handleInputChange(field)({ target: { value } })
+	}
+
+	return (
+		<div>
+			<ApiKeyField
+				value={apiConfiguration?.geminiApiKey || ""}
+				onChange={handleInputChange("geminiApiKey")}
+				providerName="Gemini"
+				signupUrl="https://aistudio.google.com/apikey"
+			/>
+
+			<BaseUrlField
+				value={apiConfiguration?.geminiBaseUrl}
+				onChange={handleFieldChange("geminiBaseUrl")}
+				placeholder="Default: https://generativelanguage.googleapis.com"
+				label="Use custom base URL"
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						models={geminiModels}
+						selectedModelId={selectedModelId}
+						onChange={handleInputChange("apiModelId")}
+						label="Model"
+					/>
+
+					{SUPPORTED_THINKING_MODELS.includes(selectedModelId) && setApiConfiguration && (
+						<ThinkingBudgetSlider
+							apiConfiguration={apiConfiguration}
+							setApiConfiguration={setApiConfiguration}
+							maxBudget={selectedModelInfo.thinkingConfig?.maxBudget}
+						/>
+					)}
+
+					<ModelInfoView selectedModelId={selectedModelId} modelInfo={selectedModelInfo} isPopup={isPopup} />
+				</>
+			)}
+		</div>
+	)
+}

webview-ui/src/components/settings/providers/OpenAINative.tsx

@@ -0,0 +1,52 @@
+import { ApiConfiguration, openAiNativeModels } from "@shared/api"
+import { ApiKeyField } from "../common/ApiKeyField"
+import { ModelSelector } from "../common/ModelSelector"
+import { ModelInfoView } from "../common/ModelInfoView"
+import { normalizeApiConfiguration } from "../utils/providerUtils"
+
+/**
+ * Props for the OpenAINativeProvider component
+ */
+interface OpenAINativeProviderProps {
+	apiConfiguration: ApiConfiguration
+	handleInputChange: (field: keyof ApiConfiguration) => (event: any) => void
+	showModelOptions: boolean
+	isPopup?: boolean
+}
+
+/**
+ * The OpenAI (native) provider configuration component
+ */
+export const OpenAINativeProvider = ({
+	apiConfiguration,
+	handleInputChange,
+	showModelOptions,
+	isPopup,
+}: OpenAINativeProviderProps) => {
+	// Get the normalized configuration
+	const { selectedModelId, selectedModelInfo } = normalizeApiConfiguration(apiConfiguration)
+
+	return (
+		<div>
+			<ApiKeyField
+				value={apiConfiguration?.openAiNativeApiKey || ""}
+				onChange={handleInputChange("openAiNativeApiKey")}
+				providerName="OpenAI"
+				signupUrl="https://platform.openai.com/api-keys"
+			/>
+
+			{showModelOptions && (
+				<>
+					<ModelSelector
+						models={openAiNativeModels}
+						selectedModelId={selectedModelId}
+						onChange={handleInputChange("apiModelId")}
+						label="Model"
+					/>
+
+					<ModelInfoView selectedModelId={selectedModelId} modelInfo={selectedModelInfo} isPopup={isPopup} />
+				</>
+			)}
+		</div>
+	)
+}

webview-ui/src/components/settings/utils/providerUtils.ts

@@ -10,6 +10,8 @@ import {
 	deepSeekModels,
 	geminiDefaultModelId,
 	geminiModels,
+	geminiCliDefaultModelId,
+	geminiCliModels,
 	mistralDefaultModelId,
 	mistralModels,
 	openAiModelInfoSaneDefaults,
@@ -96,6 +98,8 @@ export function normalizeApiConfiguration(apiConfiguration?: ApiConfiguration):
 			return getProviderData(vertexModels, vertexDefaultModelId)
 		case "gemini":
 			return getProviderData(geminiModels, geminiDefaultModelId)
+		case "gemini-cli":
+			return getProviderData(geminiCliModels, geminiCliDefaultModelId)
 		case "openai-native":
 			return getProviderData(openAiNativeModels, openAiNativeDefaultModelId)
 		case "deepseek":

webview-ui/src/components/welcome/WelcomeView.tsx

@@ -50,8 +50,8 @@ const WelcomeView = memo(() => {
 				</div>
 				<p>
 					I can do all kinds of tasks thanks to breakthroughs in{" "}
-					<VSCodeLink href="https://www.anthropic.com/news/claude-3-7-sonnet" className="inline">
-						Claude 3.7 Sonnet's
+					<VSCodeLink href="https://www.anthropic.com/claude/sonnet" className="inline">
+						Claude 4 Sonnet's
 					</VSCodeLink>
 					agentic coding capabilities and access to tools that let me create & edit files, explore complex projects, use
 					a browser, and execute terminal commands <i>(with your permission, of course)</i>. I can even use MCP to

webview-ui/src/context/ExtensionStateContext.tsx

@@ -14,7 +14,7 @@ import { TerminalProfile } from "@shared/proto/state"
 import { convertProtoToClineMessage } from "@shared/proto-conversions/cline-message"
 import { convertProtoMcpServersToMcpServers } from "@shared/proto-conversions/mcp/mcp-server-conversion"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
-import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
+import { DEFAULT_BROWSER_SETTINGS, BrowserSettings } from "@shared/BrowserSettings"
 import { ChatSettings, DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
 import { DEFAULT_PLATFORM, ExtensionMessage, ExtensionState } from "@shared/ExtensionMessage"
 import { TelemetrySetting } from "@shared/TelemetrySetting"
@@ -79,6 +79,7 @@ interface ExtensionStateContextType extends ExtensionState {
 	setMcpMarketplaceCatalog: (value: McpMarketplaceCatalog) => void
 	setTotalTasksSize: (value: number | null) => void
 	setAvailableTerminalProfiles: (profiles: TerminalProfile[]) => void // Setter for profiles
+	setBrowserSettings: (value: BrowserSettings) => void
 
 	// Refresh functions
 	refreshOpenRouterModels: () => void
@@ -838,6 +839,11 @@ export const ExtensionStateContextProvider: React.FC<{
 		refreshOpenRouterModels,
 		onRelinquishControl,
 		setUserInfo: (userInfo?: UserInfo) => setState((prevState) => ({ ...prevState, userInfo })),
+		setBrowserSettings: (value: BrowserSettings) =>
+			setState((prevState) => ({
+				...prevState,
+				browserSettings: value,
+			})),
 	}
 
 	return <ExtensionStateContext.Provider value={contextValue}>{children}</ExtensionStateContext.Provider>