reset default topP to 0.95 as claude modes does not allow topP smaller than 0.95

pump version to 0.6.0

.github/workflows/release-sdk.yml

@@ -121,6 +121,11 @@ jobs:
           IS_PREVIEW: '${{ steps.vars.outputs.is_preview }}'
           MANUAL_VERSION: '${{ inputs.version }}'
 
+      - name: 'Build CLI Bundle'
+        run: |
+          npm run build
+          npm run bundle
+
       - name: 'Run Tests'
         if: |-
           ${{ github.event.inputs.force_skip_tests != 'true' }}
@@ -132,13 +137,6 @@ jobs:
           OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
           OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
 
-      - name: 'Build CLI for Integration Tests'
-        if: |-
-          ${{ github.event.inputs.force_skip_tests != 'true' }}
-        run: |
-          npm run build
-          npm run bundle
-
       - name: 'Run SDK Integration Tests'
         if: |-
           ${{ github.event.inputs.force_skip_tests != 'true' }}

.github/workflows/release.yml

@@ -133,8 +133,8 @@ jobs:
           ${{ github.event.inputs.force_skip_tests != 'true' }}
         run: |
           npm run preflight
-          npm run test:integration:sandbox:none
-          npm run test:integration:sandbox:docker
+          npm run test:integration:cli:sandbox:none
+          npm run test:integration:cli:sandbox:docker
         env:
           OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
           OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-![](https://gw.alicdn.com/imgextra/i1/O1CN01D2DviS1wwtEtMwIzJ_!!6000000006373-2-tps-1600-900.png)
+![Qwen Code Screenshot](./docs/assets/qwen-screenshot.png)
 
 [![npm version](https://img.shields.io/npm/v/@qwen-code/qwen-code.svg)](https://www.npmjs.com/package/@qwen-code/qwen-code)
 [![License](https://img.shields.io/github/license/QwenLM/qwen-code.svg)](./LICENSE)
@@ -11,36 +11,52 @@
 
 **AI-powered command-line workflow tool for developers**
 
-  <a href="https://qwenlm.github.io/qwen-code-docs/zh/">中文</a> |
+[Installation](#installation) • [Quick Start](#quick-start) • [Features](#key-features) • [Documentation](./docs/) • [Contributing](./CONTRIBUTING.md)
+
+</div>
+
+<div align="center">
+  
   <a href="https://qwenlm.github.io/qwen-code-docs/de/">Deutsch</a> | 
   <a href="https://qwenlm.github.io/qwen-code-docs/fr">français</a> | 
   <a href="https://qwenlm.github.io/qwen-code-docs/ja/">日本語</a> | 
-  <a href="https://qwenlm.github.io/qwen-code-docs/ru">Русский</a> 
-
-[Installation](#install-from-npm) • [Quick Start](#-quick-start) • [Features](#-why-qwen-code) • [Documentation](https://qwenlm.github.io/qwen-code-docs/en/users/overview/) • [Contributing](https://qwenlm.github.io/qwen-code-docs/en/developers/contributing/)
-
-
+  <a href="https://qwenlm.github.io/qwen-code-docs/ru">Русский</a> | 
+  <a href="https://qwenlm.github.io/qwen-code-docs/zh/">中文</a>
+  
 </div>
 
 Qwen Code is a powerful command-line AI workflow tool adapted from [**Gemini CLI**](https://github.com/google-gemini/gemini-cli), specifically optimized for [Qwen3-Coder](https://github.com/QwenLM/Qwen3-Coder) models. It enhances your development workflow with advanced code understanding, automated tasks, and intelligent assistance.
 
+## 💡 Free Options Available
 
+Get started with Qwen Code at no cost using any of these free options:
 
-## 📌 Why Qwen Code？
+### 🔥 Qwen OAuth (Recommended)
 
-- 🎯 Free Access Available: Get started with 2,000 free requests per day via Qwen OAuth.
-- 🧠 Code Understanding & Editing - Query and edit large codebases beyond traditional context window limits
-- 🤖 Workflow Automation - Automate operational tasks like handling pull requests and complex rebases
-- 💻 Terminal-first: Designed for developers who live in the command line.
-- 🧰 VS Code: Install the VS Code extension to seamlessly integrate into your existing workflow.
-- 📦 Simple Setup: Easy installation with npm, Homebrew, or source for quick deployment.
+- **2,000 requests per day** with no token limits
+- **60 requests per minute** rate limit
+- Simply run `qwen` and authenticate with your qwen.ai account
+- Automatic credential management and refresh
+- Use `/auth` command to switch to Qwen OAuth if you have initialized with OpenAI compatible mode
 
->👉 Know more [workflows](https://qwenlm.github.io/qwen-code-docs/en/users/common-workflow/)
->
-> 📦 The extension is currently in development. For installation, features, and development guide, see the [VS Code Extension README](./packages/vscode-ide-companion/README.md).
+### 🌏 Regional Free Tiers
 
+- **Mainland China**: ModelScope offers **2,000 free API calls per day**
+- **International**: OpenRouter provides **up to 1,000 free API calls per day** worldwide
 
-## ❓ How to use Qwen Code?
+For detailed setup instructions, see [Authorization](#authorization).
+
+> [!WARNING]
+> **Token Usage Notice**: Qwen Code may issue multiple API calls per cycle, resulting in higher token usage (similar to Claude Code). We're actively optimizing API efficiency.
+
+## Key Features
+
+- **Code Understanding & Editing** - Query and edit large codebases beyond traditional context window limits
+- **Workflow Automation** - Automate operational tasks like handling pull requests and complex rebases
+- **Enhanced Parser** - Adapted parser specifically optimized for Qwen-Coder models
+- **Vision Model Support** - Automatically detect images in your input and seamlessly switch to vision-capable models for multimodal analysis
+
+## Installation
 
 ### Prerequisites
 
@@ -54,57 +70,313 @@ curl -qL https://www.npmjs.com/install.sh | sh
 
 ```bash
 npm install -g @qwen-code/qwen-code@latest
+qwen --version
 ```
 
-## 🚀 Quick Start
+### Install from source
+
+```bash
+git clone https://github.com/QwenLM/qwen-code.git
+cd qwen-code
+npm install
+npm install -g .
+```
+
+### Install globally with Homebrew (macOS/Linux)
+
+```bash
+brew install qwen-code
+```
+
+## VS Code Extension
+
+In addition to the CLI tool, Qwen Code also provides a **VS Code extension** that brings AI-powered coding assistance directly into your editor with features like file system operations, native diffing, interactive chat, and more.
+
+> 📦 The extension is currently in development. For installation, features, and development guide, see the [VS Code Extension README](./packages/vscode-ide-companion/README.md).
+
+## Quick Start
 
 ```bash
 # Start Qwen Code
 qwen
 
 # Example commands
-> What does this project do?
 > Explain this codebase structure
 > Help me refactor this function
 > Generate unit tests for this module
 ```
 
-👇 Click to play video
+### Session Management
 
-[![qwencode-start](https://img.alicdn.com/imgextra/i3/6000000004682/O1CN01cSWkqj1kSPUZPj68h_!!6000000004682-0-tbvideo.jpg)](https://cloud.video.taobao.com/vod/HLfyppnCHplRV9Qhz2xSqeazHeRzYtG-EYJnHAqtzkQ.mp4)
+Control your token usage with configurable session limits to optimize costs and performance.
 
+#### Configure Session Token Limit
+
+Create or edit `.qwen/settings.json` in your home directory:
+
+```json
+{
+  "sessionTokenLimit": 32000
+}
+```
+
+#### Session Commands
+
+- **`/compress`** - Compress conversation history to continue within token limits
+- **`/clear`** - Clear all conversation history and start fresh
+- **`/stats`** - Check current token usage and limits
+
+> 📝 **Note**: Session token limit applies to a single conversation, not cumulative API calls.
+
+### Vision Model Configuration
+
+Qwen Code includes intelligent vision model auto-switching that detects images in your input and can automatically switch to vision-capable models for multimodal analysis. **This feature is enabled by default** - when you include images in your queries, you'll see a dialog asking how you'd like to handle the vision model switch.
+
+#### Skip the Switch Dialog (Optional)
+
+If you don't want to see the interactive dialog each time, configure the default behavior in your `.qwen/settings.json`:
+
+```json
+{
+  "experimental": {
+    "vlmSwitchMode": "once"
+  }
+}
+```
+
+**Available modes:**
+
+- **`"once"`** - Switch to vision model for this query only, then revert
+- **`"session"`** - Switch to vision model for the entire session
+- **`"persist"`** - Continue with current model (no switching)
+- **Not set** - Show interactive dialog each time (default)
+
+#### Command Line Override
+
+You can also set the behavior via command line:
+
+```bash
+# Switch once per query
+qwen --vlm-switch-mode once
+
+# Switch for entire session
+qwen --vlm-switch-mode session
+
+# Never switch automatically
+qwen --vlm-switch-mode persist
+```
+
+#### Disable Vision Models (Optional)
+
+To completely disable vision model support, add to your `.qwen/settings.json`:
+
+```json
+{
+  "experimental": {
+    "visionModelPreview": false
+  }
+}
+```
+
+> 💡 **Tip**: In YOLO mode (`--yolo`), vision switching happens automatically without prompts when images are detected.
+
+### Authorization
+
+Choose your preferred authentication method based on your needs:
+
+#### 1. Qwen OAuth (🚀 Recommended - Start in 30 seconds)
+
+The easiest way to get started - completely free with generous quotas:
+
+```bash
+# Just run this command and follow the browser authentication
+qwen
+```
+
+**What happens:**
+
+1. **Instant Setup**: CLI opens your browser automatically
+2. **One-Click Login**: Authenticate with your qwen.ai account
+3. **Automatic Management**: Credentials cached locally for future use
+4. **No Configuration**: Zero setup required - just start coding!
+
+**Free Tier Benefits:**
+
+- ✅ **2,000 requests/day** (no token counting needed)
+- ✅ **60 requests/minute** rate limit
+- ✅ **Automatic credential refresh**
+- ✅ **Zero cost** for individual users
+- ℹ️ **Note**: Model fallback may occur to maintain service quality
+
+#### 2. OpenAI-Compatible API
+
+Use API keys for OpenAI or other compatible providers:
+
+**Configuration Methods:**
+
+1. **Environment Variables**
+
+   ```bash
+   export OPENAI_API_KEY="your_api_key_here"
+   export OPENAI_BASE_URL="your_api_endpoint"
+   export OPENAI_MODEL="your_model_choice"
+   ```
+
+2. **Project `.env` File**
+   Create a `.env` file in your project root:
+   ```env
+   OPENAI_API_KEY=your_api_key_here
+   OPENAI_BASE_URL=your_api_endpoint
+   OPENAI_MODEL=your_model_choice
+   ```
+
+**API Provider Options**
+
+> ⚠️ **Regional Notice:**
+>
+> - **Mainland China**: Use Alibaba Cloud Bailian or ModelScope
+> - **International**: Use Alibaba Cloud ModelStudio or OpenRouter
+
+<details>
+<summary><b>🇨🇳 For Users in Mainland China</b></summary>
+
+**Option 1: Alibaba Cloud Bailian** ([Apply for API Key](https://bailian.console.aliyun.com/))
+
+```bash
+export OPENAI_API_KEY="your_api_key_here"
+export OPENAI_BASE_URL="https://dashscope.aliyuncs.com/compatible-mode/v1"
+export OPENAI_MODEL="qwen3-coder-plus"
+```
+
+**Option 2: ModelScope (Free Tier)** ([Apply for API Key](https://modelscope.cn/docs/model-service/API-Inference/intro))
+
+- ✅ **2,000 free API calls per day**
+- ⚠️ Connect your Aliyun account to avoid authentication errors
+
+```bash
+export OPENAI_API_KEY="your_api_key_here"
+export OPENAI_BASE_URL="https://api-inference.modelscope.cn/v1"
+export OPENAI_MODEL="Qwen/Qwen3-Coder-480B-A35B-Instruct"
+```
+
+</details>
+
+<details>
+<summary><b>🌍 For International Users</b></summary>
+
+**Option 1: Alibaba Cloud ModelStudio** ([Apply for API Key](https://modelstudio.console.alibabacloud.com/))
+
+```bash
+export OPENAI_API_KEY="your_api_key_here"
+export OPENAI_BASE_URL="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+export OPENAI_MODEL="qwen3-coder-plus"
+```
+
+**Option 2: OpenRouter (Free Tier Available)** ([Apply for API Key](https://openrouter.ai/))
+
+```bash
+export OPENAI_API_KEY="your_api_key_here"
+export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
+export OPENAI_MODEL="qwen/qwen3-coder:free"
+```
+
+</details>
 
 ## Usage Examples
 
-### 1️⃣ Interactive Mode
+### 🔍 Explore Codebases
 
 ```bash
 cd your-project/
 qwen
+
+# Architecture analysis
+> Describe the main pieces of this system's architecture
+> What are the key dependencies and how do they interact?
+> Find all API endpoints and their authentication methods
 ```
 
-Navigate to your project folder and type `qwen` to launch Qwen Code. Start a conversation and use `@` to reference files within the folder.
-
-If you want to learn more about common workflows, click [Common Workflows](https://qwenlm.github.io/qwen-code-docs/en/users/common-workflow/) to view.
-
-### 2️⃣ Headless Mode
+### 💻 Code Development
 
 ```bash
-cd your-project/
-qwen -p "your question"
+# Refactoring
+> Refactor this function to improve readability and performance
+> Convert this class to use dependency injection
+> Split this large module into smaller, focused components
+
+# Code generation
+> Create a REST API endpoint for user management
+> Generate unit tests for the authentication module
+> Add error handling to all database operations
 ```
-[Headless mode](https://qwenlm.github.io/qwen-code-docs/en/users/features/headless) allows you to run Qwen Code programmatically from command line scripts and automation tools without any interactive UI. This is ideal for scripting, automation, CI/CD pipelines, and building AI-powered tools.
 
-### 3️⃣ Use in IDE
-If you prefer to integrate Qwen Code into your current editor, we now support VS Code and Zed. For details, please refer to:
+### 🔄 Automate Workflows
 
-- [Use in VS Code](https://qwenlm.github.io/qwen-code-docs/en/users/integration-vscode/)
-- [Use in Zed](https://qwenlm.github.io/qwen-code-docs/en/users/integration-zed/)
+```bash
+# Git automation
+> Analyze git commits from the last 7 days, grouped by feature
+> Create a changelog from recent commits
+> Find all TODO comments and create GitHub issues
 
-### 4️⃣ SDK
-Qwen Code now supports an SDK designed to simplify integration with the Qwen Code platform. It provides a set of easy-to-use APIs and tools enabling developers to efficiently build, test, and deploy applications. For details, please refer to:
+# File operations
+> Convert all images in this directory to PNG format
+> Rename all test files to follow the *.test.ts pattern
+> Find and remove all console.log statements
+```
 
-- [Use the Qwen Code SDK](./packages/sdk-typescript/README.md)
+### 🐛 Debugging & Analysis
+
+```bash
+# Performance analysis
+> Identify performance bottlenecks in this React component
+> Find all N+1 query problems in the codebase
+
+# Security audit
+> Check for potential SQL injection vulnerabilities
+> Find all hardcoded credentials or API keys
+```
+
+## Popular Tasks
+
+### 📚 Understand New Codebases
+
+```text
+> What are the core business logic components?
+> What security mechanisms are in place?
+> How does the data flow through the system?
+> What are the main design patterns used?
+> Generate a dependency graph for this module
+```
+
+### 🔨 Code Refactoring & Optimization
+
+```text
+> What parts of this module can be optimized?
+> Help me refactor this class to follow SOLID principles
+> Add proper error handling and logging
+> Convert callbacks to async/await pattern
+> Implement caching for expensive operations
+```
+
+### 📝 Documentation & Testing
+
+```text
+> Generate comprehensive JSDoc comments for all public APIs
+> Write unit tests with edge cases for this component
+> Create API documentation in OpenAPI format
+> Add inline comments explaining complex algorithms
+> Generate a README for this module
+```
+
+### 🚀 Development Acceleration
+
+```text
+> Set up a new Express server with authentication
+> Create a React component with TypeScript and tests
+> Implement a rate limiter middleware
+> Add database migrations for new schema
+> Configure CI/CD pipeline for this project
+```
 
 ## Commands & Shortcuts
 
@@ -122,11 +394,6 @@ Qwen Code now supports an SDK designed to simplify integration with the Qwen Cod
 - `Ctrl+D` - Exit (on empty line)
 - `Up/Down` - Navigate command history
 
-
-> 👉 Know more about [Commands](https://qwenlm.github.io/qwen-code-docs/en/users/features/commands/)
->
-> 💡 **Tip**: In YOLO mode (`--yolo`), vision switching happens automatically without prompts when images are detected. Know more about [Approval Mode](https://qwenlm.github.io/qwen-code-docs/en/users/features/approval-mode/)
-
 ## Benchmark Results
 
 ### Terminal-Bench Performance
@@ -138,13 +405,13 @@ Qwen Code now supports an SDK designed to simplify integration with the Qwen Cod
 
 ## Development & Contributing
 
-See [CONTRIBUTING.md](https://qwenlm.github.io/qwen-code-docs/en/developers/contributing/) to learn how to contribute to the project.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) to learn how to contribute to the project.
 
-For detailed authentication setup, see the [authentication guide](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/).
+For detailed authentication setup, see the [authentication guide](./docs/cli/authentication.md).
 
 ## Troubleshooting
 
-If you encounter issues, check the [troubleshooting guide](https://qwenlm.github.io/qwen-code-docs/en/users/support/troubleshooting/).
+If you encounter issues, check the [troubleshooting guide](docs/troubleshooting.md).
 
 ## Acknowledgments
 

docs/developers/tools/mcp-server.md

@@ -627,7 +627,12 @@ The MCP integration tracks several states:
 
 ### Schema Compatibility
 
-- **Property stripping:** The system automatically removes certain schema properties (`$schema`, `additionalProperties`) for Qwen API compatibility
+- **Schema compliance mode:** By default (`schemaCompliance: "auto"`), tool schemas are passed through as-is. Set `"model": { "generationConfig": { "schemaCompliance": "openapi_30" } }` in your `settings.json` to convert models to Strict OpenAPI 3.0 format.
+- **OpenAPI 3.0 transformations:** When `openapi_30` mode is enabled, the system handles:
+  - Nullable types: `["string", "null"]` -> `type: "string", nullable: true`
+  - Const values: `const: "foo"` -> `enum: ["foo"]`
+  - Exclusive limits: numeric `exclusiveMinimum` -> boolean form with `minimum`
+  - Keyword removal: `$schema`, `$id`, `dependencies`, `patternProperties`
 - **Name sanitization:** Tool names are automatically sanitized to meet API requirements
 - **Conflict resolution:** Tool name conflicts between servers are resolved through automatic prefixing
 

docs/index.md

@@ -5,6 +5,7 @@ Welcome to the Qwen Code documentation. Qwen Code is an agentic coding tool that
 ## Documentation Sections
 
 ### [User Guide](./users/overview)
+
 Learn how to use Qwen Code as an end user. This section covers:
 
 - Basic installation and setup

docs/users/configuration/qwen-ignore.md

@@ -20,9 +20,9 @@ You can update your `.qwenignore` file at any time. To apply the changes, you mu
 
 ## How to use `.qwenignore`
 
-| Step                   | Description                                                  |
-| ---------------------- | ------------------------------------------------------------ |
-| **Enable .qwenignore** | Create a file named `.qwenignore` in your project root directory |
+| Step                   | Description                                                                            |
+| ---------------------- | -------------------------------------------------------------------------------------- |
+| **Enable .qwenignore** | Create a file named `.qwenignore` in your project root directory                       |
 | **Add ignore rules**   | Open `.qwenignore` file and add paths to ignore, example: `/archive/` or `apikeys.txt` |
 
 ### `.qwenignore` examples

docs/users/configuration/settings.md

@@ -50,13 +50,14 @@ Settings are organized into categories. All settings should be placed within the
 
 #### general
 
-| Setting                         | Type    | Description                                | Default     |
-| ------------------------------- | ------- | ------------------------------------------ | ----------- |
-| `general.preferredEditor`       | string  | The preferred editor to open files in.     | `undefined` |
-| `general.vimMode`               | boolean | Enable Vim keybindings.                    | `false`     |
-| `general.disableAutoUpdate`     | boolean | Disable automatic updates.                 | `false`     |
-| `general.disableUpdateNag`      | boolean | Disable update notification prompts.       | `false`     |
-| `general.checkpointing.enabled` | boolean | Enable session checkpointing for recovery. | `false`     |
+| Setting                         | Type    | Description                                                                                                | Default     |
+| ------------------------------- | ------- | ---------------------------------------------------------------------------------------------------------- | ----------- |
+| `general.preferredEditor`       | string  | The preferred editor to open files in.                                                                     | `undefined` |
+| `general.vimMode`               | boolean | Enable Vim keybindings.                                                                                    | `false`     |
+| `general.disableAutoUpdate`     | boolean | Disable automatic updates.                                                                                 | `false`     |
+| `general.disableUpdateNag`      | boolean | Disable update notification prompts.                                                                       | `false`     |
+| `general.gitCoAuthor`           | boolean | Automatically add a Co-authored-by trailer to git commit messages when commits are made through Qwen Code. | `true`      |
+| `general.checkpointing.enabled` | boolean | Enable session checkpointing for recovery.                                                                 | `false`     |
 
 #### output
 
@@ -68,7 +69,7 @@ Settings are organized into categories. All settings should be placed within the
 
 | Setting                                  | Type             | Description                                                                                                                                                                                                                                                                                                                                                                                                         | Default     |
 | ---------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| `ui.theme`                               | string           | The color theme for the UI. See [Themes](../configuration/themes) for available options.                                                                                                                                                                                                                                                                                                                        | `undefined` |
+| `ui.theme`                               | string           | The color theme for the UI. See [Themes](../configuration/themes) for available options.                                                                                                                                                                                                                                                                                                                            | `undefined` |
 | `ui.customThemes`                        | object           | Custom theme definitions.                                                                                                                                                                                                                                                                                                                                                                                           | `{}`        |
 | `ui.hideWindowTitle`                     | boolean          | Hide the window title bar.                                                                                                                                                                                                                                                                                                                                                                                          | `false`     |
 | `ui.hideTips`                            | boolean          | Hide helpful tips in the UI.                                                                                                                                                                                                                                                                                                                                                                                        | `false`     |
@@ -356,38 +357,38 @@ Arguments passed directly when running the CLI can override other configurations
 
 ### Command-Line Arguments Table
 
-| Argument                     | Alias | Description                                                                                                                                                                             | Possible Values                        | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ---------------------------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--model`                    | `-m`  | Specifies the Qwen model to use for this session.                                                                                                                                       | Model name                             | Example: `npm start -- --model qwen3-coder-plus`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `--prompt`                   | `-p`  | Used to pass a prompt directly to the command. This invokes Qwen Code in a non-interactive mode.                                                                                        | Your prompt text                       | For scripting examples, use the `--output-format json` flag to get structured output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `--prompt-interactive`       | `-i`  | Starts an interactive session with the provided prompt as the initial input.                                                                                                            | Your prompt text                       | The prompt is processed within the interactive session, not before it. Cannot be used when piping input from stdin. Example: `qwen -i "explain this code"`                                                                                                                                                                                                                                                                                                                                                                                                          |
+| Argument                     | Alias | Description                                                                                                                                                                             | Possible Values                        | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ---------------------------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--model`                    | `-m`  | Specifies the Qwen model to use for this session.                                                                                                                                       | Model name                             | Example: `npm start -- --model qwen3-coder-plus`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `--prompt`                   | `-p`  | Used to pass a prompt directly to the command. This invokes Qwen Code in a non-interactive mode.                                                                                        | Your prompt text                       | For scripting examples, use the `--output-format json` flag to get structured output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `--prompt-interactive`       | `-i`  | Starts an interactive session with the provided prompt as the initial input.                                                                                                            | Your prompt text                       | The prompt is processed within the interactive session, not before it. Cannot be used when piping input from stdin. Example: `qwen -i "explain this code"`                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `--output-format`            | `-o`  | Specifies the format of the CLI output for non-interactive mode.                                                                                                                        | `text`, `json`, `stream-json`          | `text`: (Default) The standard human-readable output. `json`: A machine-readable JSON output emitted at the end of execution. `stream-json`: Streaming JSON messages emitted as they occur during execution. For structured output and scripting, use the `--output-format json` or `--output-format stream-json` flag. See [Headless Mode](../features/headless) for detailed information.                                                                                                                                                                     |
 | `--input-format`             |       | Specifies the format consumed from standard input.                                                                                                                                      | `text`, `stream-json`                  | `text`: (Default) Standard text input from stdin or command-line arguments. `stream-json`: JSON message protocol via stdin for bidirectional communication. Requirement: `--input-format stream-json` requires `--output-format stream-json` to be set. When using `stream-json`, stdin is reserved for protocol messages. See [Headless Mode](../features/headless) for detailed information.                                                                                                                                                                  |
 | `--include-partial-messages` |       | Include partial assistant messages when using `stream-json` output format. When enabled, emits stream events (message_start, content_block_delta, etc.) as they occur during streaming. |                                        | Default: `false`. Requirement: Requires `--output-format stream-json` to be set. See [Headless Mode](../features/headless) for detailed information about stream events.                                                                                                                                                                                                                                                                                                                                                                                        |
-| `--sandbox`                  | `-s`  | Enables sandbox mode for this session.                                                                                                                                                  |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--sandbox-image`            |       | Sets the sandbox image URI.                                                                                                                                                             |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--debug`                    | `-d`  | Enables debug mode for this session, providing more verbose output.                                                                                                                     |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--all-files`                | `-a`  | If set, recursively includes all files within the current directory as context for the prompt.                                                                                          |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--help`                     | `-h`  | Displays help information about command-line arguments.                                                                                                                                 |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--show-memory-usage`        |       | Displays the current memory usage.                                                                                                                                                      |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--yolo`                     |       | Enables YOLO mode, which automatically approves all tool calls.                                                                                                                         |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `--sandbox`                  | `-s`  | Enables sandbox mode for this session.                                                                                                                                                  |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--sandbox-image`            |       | Sets the sandbox image URI.                                                                                                                                                             |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--debug`                    | `-d`  | Enables debug mode for this session, providing more verbose output.                                                                                                                     |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--all-files`                | `-a`  | If set, recursively includes all files within the current directory as context for the prompt.                                                                                          |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--help`                     | `-h`  | Displays help information about command-line arguments.                                                                                                                                 |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--show-memory-usage`        |       | Displays the current memory usage.                                                                                                                                                      |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--yolo`                     |       | Enables YOLO mode, which automatically approves all tool calls.                                                                                                                         |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `--approval-mode`            |       | Sets the approval mode for tool calls.                                                                                                                                                  | `plan`, `default`, `auto-edit`, `yolo` | Supported modes: `plan`: Analyze only—do not modify files or execute commands. `default`: Require approval for file edits or shell commands (default behavior). `auto-edit`: Automatically approve edit tools (edit, write_file) while prompting for others. `yolo`: Automatically approve all tool calls (equivalent to `--yolo`). Cannot be used together with `--yolo`. Use `--approval-mode=yolo` instead of `--yolo` for the new unified approach. Example: `qwen --approval-mode auto-edit`<br>See more about [Approval Mode](../features/approval-mode). |
-| `--allowed-tools`            |       | A comma-separated list of tool names that will bypass the confirmation dialog.                                                                                                          | Tool names                             | Example: `qwen --allowed-tools "Shell(git status)"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `--telemetry`                |       | Enables [telemetry](/developers/development/telemetry).                                                                                                                                 |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--telemetry-target`         |       | Sets the telemetry target.                                                                                                                                                              |                                        | See [telemetry](/developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `--telemetry-otlp-endpoint`  |       | Sets the OTLP endpoint for telemetry.                                                                                                                                                   |                                        | See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `--telemetry-otlp-protocol`  |       | Sets the OTLP protocol for telemetry (`grpc` or `http`).                                                                                                                                |                                        | Defaults to `grpc`. See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `--telemetry-log-prompts`    |       | Enables logging of prompts for telemetry.                                                                                                                                               |                                        | See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `--checkpointing`            |       | Enables [checkpointing](../features/checkpointing).                                                                                                                                 |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--extensions`               | `-e`  | Specifies a list of extensions to use for the session.                                                                                                                                  | Extension names                        | If not provided, all available extensions are used. Use the special term `qwen -e none` to disable all extensions. Example: `qwen -e my-extension -e my-other-extension`                                                                                                                                                                                                                                                                                                                                                                                            |
-| `--list-extensions`          | `-l`  | Lists all available extensions and exits.                                                                                                                                               |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--proxy`                    |       | Sets the proxy for the CLI.                                                                                                                                                             | Proxy URL                              | Example: `--proxy http://localhost:7890`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `--include-directories`      |       | Includes additional directories in the workspace for multi-directory support.                                                                                                           | Directory paths                        | Can be specified multiple times or as comma-separated values. 5 directories can be added at maximum. Example: `--include-directories /path/to/project1,/path/to/project2` or `--include-directories /path/to/project1 --include-directories /path/to/project2`                                                                                                                                                                                                                                                                                                      |
-| `--screen-reader`            |       | Enables screen reader mode, which adjusts the TUI for better compatibility with screen readers.                                                                                         |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--version`                  |       | Displays the version of the CLI.                                                                                                                                                        |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--openai-logging`           |       | Enables logging of OpenAI API calls for debugging and analysis.                                                                                                                         |                                        | This flag overrides the `enableOpenAILogging` setting in `settings.json`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `--openai-logging-dir`       |       | Sets a custom directory path for OpenAI API logs.                                                                                                                                       | Directory path                         | This flag overrides the `openAILoggingDir` setting in `settings.json`. Supports absolute paths, relative paths, and `~` expansion. Example: `qwen --openai-logging-dir "~/qwen-logs" --openai-logging`                                                                                                                                                                                                                                                                                                                                                              |
-| `--tavily-api-key`           |       | Sets the Tavily API key for web search functionality for this session.                                                                                                                  | API key                                | Example: `qwen --tavily-api-key tvly-your-api-key-here`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `--allowed-tools`            |       | A comma-separated list of tool names that will bypass the confirmation dialog.                                                                                                          | Tool names                             | Example: `qwen --allowed-tools "Shell(git status)"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `--telemetry`                |       | Enables [telemetry](/developers/development/telemetry).                                                                                                                                 |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--telemetry-target`         |       | Sets the telemetry target.                                                                                                                                                              |                                        | See [telemetry](/developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `--telemetry-otlp-endpoint`  |       | Sets the OTLP endpoint for telemetry.                                                                                                                                                   |                                        | See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `--telemetry-otlp-protocol`  |       | Sets the OTLP protocol for telemetry (`grpc` or `http`).                                                                                                                                |                                        | Defaults to `grpc`. See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `--telemetry-log-prompts`    |       | Enables logging of prompts for telemetry.                                                                                                                                               |                                        | See [telemetry](../../developers/development/telemetry) for more information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `--checkpointing`            |       | Enables [checkpointing](../features/checkpointing).                                                                                                                                     |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--extensions`               | `-e`  | Specifies a list of extensions to use for the session.                                                                                                                                  | Extension names                        | If not provided, all available extensions are used. Use the special term `qwen -e none` to disable all extensions. Example: `qwen -e my-extension -e my-other-extension`                                                                                                                                                                                                                                                                                                                                                                                        |
+| `--list-extensions`          | `-l`  | Lists all available extensions and exits.                                                                                                                                               |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--proxy`                    |       | Sets the proxy for the CLI.                                                                                                                                                             | Proxy URL                              | Example: `--proxy http://localhost:7890`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `--include-directories`      |       | Includes additional directories in the workspace for multi-directory support.                                                                                                           | Directory paths                        | Can be specified multiple times or as comma-separated values. 5 directories can be added at maximum. Example: `--include-directories /path/to/project1,/path/to/project2` or `--include-directories /path/to/project1 --include-directories /path/to/project2`                                                                                                                                                                                                                                                                                                  |
+| `--screen-reader`            |       | Enables screen reader mode, which adjusts the TUI for better compatibility with screen readers.                                                                                         |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--version`                  |       | Displays the version of the CLI.                                                                                                                                                        |                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `--openai-logging`           |       | Enables logging of OpenAI API calls for debugging and analysis.                                                                                                                         |                                        | This flag overrides the `enableOpenAILogging` setting in `settings.json`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `--openai-logging-dir`       |       | Sets a custom directory path for OpenAI API logs.                                                                                                                                       | Directory path                         | This flag overrides the `openAILoggingDir` setting in `settings.json`. Supports absolute paths, relative paths, and `~` expansion. Example: `qwen --openai-logging-dir "~/qwen-logs" --openai-logging`                                                                                                                                                                                                                                                                                                                                                          |
+| `--tavily-api-key`           |       | Sets the Tavily API key for web search functionality for this session.                                                                                                                  | API key                                | Example: `qwen --tavily-api-key tvly-your-api-key-here`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 
 ## Context Files (Hierarchical Instructional Context)
 

docs/users/configuration/themes.md

@@ -140,8 +140,6 @@ The theme file must be a valid JSON file that follows the same structure as a cu
 
 ### Example Custom Theme
 
-
-
 <img src="https://gw.alicdn.com/imgextra/i1/O1CN01Em30Hc1jYXAdIgls3_!!6000000004560-2-tps-1009-629.png" alt=" " style="zoom:100%;text-align:center;margin: 0 auto;" />
 
 ### Using Your Custom Theme
@@ -150,15 +148,13 @@ The theme file must be a valid JSON file that follows the same structure as a cu
 - Or, set it as the default by adding `"theme": "MyCustomTheme"` to the `ui` object in your `settings.json`.
 - Custom themes can be set at the user, project, or system level, and follow the same [configuration precedence](../configuration/settings) as other settings.
 
-
-
 ## Themes Preview
 
-| Dark Theme | Preview | Light Theme | Preview |
-| :-: | :-: | :-: | :-: |
-| ANSI | <img src="https://gw.alicdn.com/imgextra/i2/O1CN01ZInJiq1GdSZc9gHsI_!!6000000000645-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" /> | ANSI Light | <img src="https://gw.alicdn.com/imgextra/i2/O1CN01IiJQFC1h9E3MXQj6W_!!6000000004234-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" /> |
-| Atom OneDark | <img src="https://gw.alicdn.com/imgextra/i2/O1CN01Zlx1SO1Sw21SkTKV3_!!6000000002310-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" /> | Ayu Light | <img src="https://gw.alicdn.com/imgextra/i3/O1CN01zEUc1V1jeUJsnCgQb_!!6000000004573-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
-| Ayu | <img src="https://gw.alicdn.com/imgextra/i3/O1CN019upo6v1SmPhmRjzfN_!!6000000002289-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> | Default Light | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01RHjrEs1u7TXq3M6l3_!!6000000005990-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
-| Default | <img src="https://gw.alicdn.com/imgextra/i4/O1CN016pIeXz1pFC8owmR4Q_!!6000000005330-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" /> | GitHub Light | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01US2b0g1VETCPAVWLA_!!6000000002621-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
-| Dracula | <img src="https://gw.alicdn.com/imgextra/i4/O1CN016htnWH20c3gd2LpUR_!!6000000006869-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" /> | Google Code | <img src="https://gw.alicdn.com/imgextra/i1/O1CN01Ng29ab23iQ2BuYKz8_!!6000000007289-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
-| GitHub | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01fFCRda1IQIQ9qDNqv_!!6000000000887-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> | Xcode | <img src="https://gw.alicdn.com/imgextra/i1/O1CN010E3QAi1Huh5o1E9LN_!!6000000000818-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
+|  Dark Theme  |                                                                                Preview                                                                                |  Light Theme  |                                                                                Preview                                                                                |
+| :----------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|     ANSI     |     <img src="https://gw.alicdn.com/imgextra/i2/O1CN01ZInJiq1GdSZc9gHsI_!!6000000000645-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" />     |  ANSI Light   |     <img src="https://gw.alicdn.com/imgextra/i2/O1CN01IiJQFC1h9E3MXQj6W_!!6000000004234-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" />     |
+| Atom OneDark |     <img src="https://gw.alicdn.com/imgextra/i2/O1CN01Zlx1SO1Sw21SkTKV3_!!6000000002310-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" />     |   Ayu Light   | <img src="https://gw.alicdn.com/imgextra/i3/O1CN01zEUc1V1jeUJsnCgQb_!!6000000004573-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
+|     Ayu      | <img src="https://gw.alicdn.com/imgextra/i3/O1CN019upo6v1SmPhmRjzfN_!!6000000002289-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> | Default Light | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01RHjrEs1u7TXq3M6l3_!!6000000005990-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
+|   Default    |     <img src="https://gw.alicdn.com/imgextra/i4/O1CN016pIeXz1pFC8owmR4Q_!!6000000005330-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" />     | GitHub Light  | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01US2b0g1VETCPAVWLA_!!6000000002621-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
+|   Dracula    |     <img src="https://gw.alicdn.com/imgextra/i4/O1CN016htnWH20c3gd2LpUR_!!6000000006869-2-tps-1140-934.png" style="zoom:30%;text-align:center;margin: 0 auto;" />     |  Google Code  | <img src="https://gw.alicdn.com/imgextra/i1/O1CN01Ng29ab23iQ2BuYKz8_!!6000000007289-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |
+|    GitHub    | <img src="https://gw.alicdn.com/imgextra/i4/O1CN01fFCRda1IQIQ9qDNqv_!!6000000000887-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |     Xcode     | <img src="https://gw.alicdn.com/imgextra/i1/O1CN010E3QAi1Huh5o1E9LN_!!6000000000818-2-tps-1140-934.png" alt=" " style="zoom:30%;text-align:center;margin: 0 auto;" /> |

docs/users/features/commands.md

@@ -20,10 +20,11 @@ These commands help you save, restore, and summarize work progress.
 
 | Command     | Description                                               | Usage Examples                       |
 | ----------- | --------------------------------------------------------- | ------------------------------------ |
+| `/init`     | Analyze current directory and create initial context file | `/init`                              |
 | `/summary`  | Generate project summary based on conversation history    | `/summary`                           |
 | `/compress` | Replace chat history with summary to save Tokens          | `/compress`                          |
+| `/resume`   | Resume a previous conversation session                    | `/resume`                            |
 | `/restore`  | Restore files to state before tool execution              | `/restore` (list) or `/restore <ID>` |
-| `/init`     | Analyze current directory and create initial context file | `/init`                              |
 
 ### 1.2 Interface and Workspace Control
 

docs/users/ide-integration/ide-companion-spec.md

@@ -16,16 +16,15 @@ The plugin **MUST** run a local HTTP server that implements the **Model Context
 - **Endpoint:** The server should expose a single endpoint (e.g., `/mcp`) for all MCP communication.
 - **Port:** The server **MUST** listen on a dynamically assigned port (i.e., listen on port `0`).
 
-### 2. Discovery Mechanism: The Port File
+### 2. Discovery Mechanism: The Lock File
 
-For Qwen Code to connect, it needs to discover which IDE instance it's running in and what port your server is using. The plugin **MUST** facilitate this by creating a "discovery file."
+For Qwen Code to connect, it needs to discover what port your server is using. The plugin **MUST** facilitate this by creating a "lock file" and setting the port environment variable.
 
-- **How the CLI Finds the File:** The CLI determines the Process ID (PID) of the IDE it's running in by traversing the process tree. It then looks for a discovery file that contains this PID in its name.
-- **File Location:** The file must be created in a specific directory: `os.tmpdir()/qwen/ide/`. Your plugin must create this directory if it doesn't exist.
+- **How the CLI Finds the File:** The CLI reads the port from `QWEN_CODE_IDE_SERVER_PORT`, then reads `~/.qwen/ide/<PORT>.lock`. (Legacy fallbacks exist for older extensions; see note below.)
+- **File Location:** The file must be created in a specific directory: `~/.qwen/ide/`. Your plugin must create this directory if it doesn't exist.
 - **File Naming Convention:** The filename is critical and **MUST** follow the pattern:
-  `qwen-code-ide-server-${PID}-${PORT}.json`
-  - `${PID}`: The process ID of the parent IDE process. Your plugin must determine this PID and include it in the filename.
-  - `${PORT}`: The port your MCP server is listening on.
+  `<PORT>.lock`
+  - `<PORT>`: The port your MCP server is listening on.
 - **File Content & Workspace Validation:** The file **MUST** contain a JSON object with the following structure:
 
   ```json
@@ -33,21 +32,20 @@ For Qwen Code to connect, it needs to discover which IDE instance it's running i
     "port": 12345,
     "workspacePath": "/path/to/project1:/path/to/project2",
     "authToken": "a-very-secret-token",
-    "ideInfo": {
-      "name": "vscode",
-      "displayName": "VS Code"
-    }
+    "ppid": 1234,
+    "ideName": "VS Code"
   }
   ```
   - `port` (number, required): The port of the MCP server.
   - `workspacePath` (string, required): A list of all open workspace root paths, delimited by the OS-specific path separator (`:` for Linux/macOS, `;` for Windows). The CLI uses this path to ensure it's running in the same project folder that's open in the IDE. If the CLI's current working directory is not a sub-directory of `workspacePath`, the connection will be rejected. Your plugin **MUST** provide the correct, absolute path(s) to the root of the open workspace(s).
   - `authToken` (string, required): A secret token for securing the connection. The CLI will include this token in an `Authorization: Bearer <token>` header on all requests.
-  - `ideInfo` (object, required): Information about the IDE.
-    - `name` (string, required): A short, lowercase identifier for the IDE (e.g., `vscode`, `jetbrains`).
-    - `displayName` (string, required): A user-friendly name for the IDE (e.g., `VS Code`, `JetBrains IDE`).
+  - `ppid` (number, required): The parent process ID of the IDE process.
+  - `ideName` (string, required): A user-friendly name for the IDE (e.g., `VS Code`, `JetBrains IDE`).
 
 - **Authentication:** To secure the connection, the plugin **MUST** generate a unique, secret token and include it in the discovery file. The CLI will then include this token in the `Authorization` header for all requests to the MCP server (e.g., `Authorization: Bearer a-very-secret-token`). Your server **MUST** validate this token on every request and reject any that are unauthorized.
-- **Tie-Breaking with Environment Variables (Recommended):** For the most reliable experience, your plugin **SHOULD** both create the discovery file and set the `QWEN_CODE_IDE_SERVER_PORT` environment variable in the integrated terminal. The file serves as the primary discovery mechanism, but the environment variable is crucial for tie-breaking. If a user has multiple IDE windows open for the same workspace, the CLI uses the `QWEN_CODE_IDE_SERVER_PORT` variable to identify and connect to the correct window's server.
+- **Environment Variables (Required):** Your plugin **MUST** set `QWEN_CODE_IDE_SERVER_PORT` in the integrated terminal so the CLI can locate the correct `<PORT>.lock` file.
+
+**Legacy note:** For extensions older than v0.5.1, Qwen Code may fall back to reading JSON files in the system temp directory named `qwen-code-ide-server-<PID>.json` or `qwen-code-ide-server-<PORT>.json`. New integrations should not rely on these legacy files.
 
 ## II. The Context Interface
 

docs/users/support/troubleshooting.md

@@ -84,12 +84,12 @@ This guide provides solutions to common issues and debugging tips, including top
 
 The Qwen Code uses specific exit codes to indicate the reason for termination. This is especially useful for scripting and automation.
 
-| Exit Code | Error Type                 | Description                                                  |
-| --------- | -------------------------- | ------------------------------------------------------------ |
-| 41        | `FatalAuthenticationError` | An error occurred during the authentication process.         |
-| 42        | `FatalInputError`          | Invalid or missing input was provided to the CLI. (non-interactive mode only) |
-| 44        | `FatalSandboxError`        | An error occurred with the sandboxing environment (e.g. Docker, Podman, or Seatbelt). |
-| 52        | `FatalConfigError`         | A configuration file (`settings.json`) is invalid or contains errors. |
+| Exit Code | Error Type                 | Description                                                                                         |
+| --------- | -------------------------- | --------------------------------------------------------------------------------------------------- |
+| 41        | `FatalAuthenticationError` | An error occurred during the authentication process.                                                |
+| 42        | `FatalInputError`          | Invalid or missing input was provided to the CLI. (non-interactive mode only)                       |
+| 44        | `FatalSandboxError`        | An error occurred with the sandboxing environment (e.g. Docker, Podman, or Seatbelt).               |
+| 52        | `FatalConfigError`         | A configuration file (`settings.json`) is invalid or contains errors.                               |
 | 53        | `FatalTurnLimitedError`    | The maximum number of conversational turns for the session was reached. (non-interactive mode only) |
 
 ## Debugging Tips

integration-tests/utf-bom-encoding.test.ts

@@ -5,8 +5,8 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { writeFileSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { TestRig } from './test-helper.js';
 
 // Windows skip (Option A: avoid infra scope)
@@ -121,21 +121,4 @@ d('BOM end-to-end integration', () => {
       'BOM_OK UTF-32BE',
     );
   });
-
-  it('Can describe a PNG file', async () => {
-    const imagePath = resolve(
-      process.cwd(),
-      'docs/assets/gemini-screenshot.png',
-    );
-    const imageContent = readFileSync(imagePath);
-    const filename = 'gemini-screenshot.png';
-    writeFileSync(join(dir, filename), imageContent);
-    const prompt = `What is shown in the image ${filename}?`;
-    const output = await rig.run(prompt);
-    await rig.waitForToolCall('read_file');
-    const lower = output.toLowerCase();
-    // The response is non-deterministic, so we just check for some
-    // keywords that are very likely to be in the response.
-    expect(lower.includes('gemini')).toBeTruthy();
-  });
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -13,14 +13,11 @@
     "url": "git+https://github.com/QwenLM/qwen-code.git"
   },
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.5.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.6.0"
   },
   "scripts": {
     "start": "cross-env node scripts/start.js",
     "debug": "cross-env DEBUG=1 node --inspect-brk scripts/start.js",
-    "auth:npm": "npx google-artifactregistry-auth",
-    "auth:docker": "gcloud auth configure-docker us-west1-docker.pkg.dev",
-    "auth": "npm run auth:npm && npm run auth:docker",
     "generate": "node scripts/generate-git-commit-info.js",
     "build": "node scripts/build.js",
     "build-and-start": "npm run build && npm run start",
@@ -95,7 +92,6 @@
     "eslint-plugin-react-hooks": "^5.2.0",
     "glob": "^10.5.0",
     "globals": "^16.0.0",
-    "google-artifactregistry-auth": "^3.4.0",
     "husky": "^9.1.7",
     "json": "^11.0.0",
     "lint-staged": "^16.1.6",

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Qwen Code",
   "repository": {
     "type": "git",
@@ -33,13 +33,13 @@
     "dist"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.5.1"
+    "sandboxImageUri": "ghcr.io/qwenlm/qwen-code:0.6.0"
   },
   "dependencies": {
-    "@google/genai": "1.16.0",
+    "@google/genai": "1.30.0",
     "@iarna/toml": "^2.2.5",
     "@qwen-code/qwen-code-core": "file:../core",
-    "@modelcontextprotocol/sdk": "^1.15.1",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "@types/update-notifier": "^6.0.8",
     "ansi-regex": "^6.2.2",
     "command-exists": "^1.2.9",
@@ -64,7 +64,7 @@
     "strip-ansi": "^7.1.0",
     "strip-json-comments": "^3.1.1",
     "tar": "^7.5.2",
-    "undici": "^7.10.0",
+    "undici": "^6.22.0",
     "extract-zip": "^2.0.1",
     "update-notifier": "^7.3.1",
     "wrap-ansi": "9.0.2",

packages/cli/src/config/auth.ts

@@ -26,5 +26,23 @@ export function validateAuthMethod(authMethod: string): string | null {
     return null;
   }
 
+  if (authMethod === AuthType.USE_GEMINI) {
+    const hasApiKey = process.env['GEMINI_API_KEY'];
+    if (!hasApiKey) {
+      return 'GEMINI_API_KEY environment variable not found. Please set it in your .env file or environment variables.';
+    }
+    return null;
+  }
+
+  if (authMethod === AuthType.USE_VERTEX_AI) {
+    const hasApiKey = process.env['GOOGLE_API_KEY'];
+    if (!hasApiKey) {
+      return 'GOOGLE_API_KEY environment variable not found. Please set it in your .env file or environment variables.';
+    }
+
+    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
+    return null;
+  }
+
   return 'Invalid auth method selected.';
 }

packages/cli/src/config/config.test.ts

@@ -206,6 +206,18 @@ describe('parseArguments', () => {
     expect(argv.prompt).toBeUndefined();
   });
 
+  it('should allow -r flag as alias for --resume', async () => {
+    process.argv = ['node', 'script.js', '-r', 'session-123'];
+    const argv = await parseArguments({} as Settings);
+    expect(argv.resume).toBe('session-123');
+  });
+
+  it('should allow -c flag as alias for --continue', async () => {
+    process.argv = ['node', 'script.js', '-c'];
+    const argv = await parseArguments({} as Settings);
+    expect(argv.continue).toBe(true);
+  });
+
   it('should convert positional query argument to prompt by default', async () => {
     process.argv = ['node', 'script.js', 'Hi Gemini'];
     const argv = await parseArguments({} as Settings);

packages/cli/src/config/config.ts

@@ -299,7 +299,6 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
             'Set the approval mode: plan (plan only), default (prompt for approval), auto-edit (auto-approve edit tools), yolo (auto-approve all tools)',
         })
         .option('checkpointing', {
-          alias: 'c',
           type: 'boolean',
           description: 'Enables checkpointing of file edits',
           default: false,
@@ -422,12 +421,14 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
           default: false,
         })
         .option('continue', {
+          alias: 'c',
           type: 'boolean',
           description:
             'Resume the most recent session for the current project.',
           default: false,
         })
         .option('resume', {
+          alias: 'r',
           type: 'string',
           description:
             'Resume a specific session by its ID. Use without an ID to show session picker.',
@@ -459,7 +460,12 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
         })
         .option('auth-type', {
           type: 'string',
-          choices: [AuthType.USE_OPENAI, AuthType.QWEN_OAUTH],
+          choices: [
+            AuthType.USE_OPENAI,
+            AuthType.QWEN_OAUTH,
+            AuthType.USE_GEMINI,
+            AuthType.USE_VERTEX_AI,
+          ],
           description: 'Authentication type',
         })
         .deprecateOption(
@@ -1002,6 +1008,7 @@ export async function loadCliConfig(
     enableToolOutputTruncation: settings.tools?.enableToolOutputTruncation,
     eventEmitter: appEvents,
     useSmartEdit: argv.useSmartEdit ?? settings.useSmartEdit,
+    gitCoAuthor: settings.general?.gitCoAuthor,
     output: {
       format: outputSettingsFormat,
     },

packages/cli/src/config/extension.test.ts

@@ -56,6 +56,17 @@ vi.mock('simple-git', () => ({
   }),
 }));
 
+vi.mock('./extensions/github.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('./extensions/github.js')>();
+  return {
+    ...actual,
+    downloadFromGitHubRelease: vi
+      .fn()
+      .mockRejectedValue(new Error('Mocked GitHub release download failure')),
+  };
+});
+
 vi.mock('os', async (importOriginal) => {
   const mockedOs = await importOriginal<typeof os>();
   return {

packages/cli/src/config/extension.ts

@@ -581,7 +581,7 @@ function extensionConsentString(extensionConfig: ExtensionConfig): string {
   }
   if (extensionConfig.contextFileName) {
     output.push(
-      `This extension will append info to your gemini.md context using ${extensionConfig.contextFileName}`,
+      `This extension will append info to your QWEN.md context using ${extensionConfig.contextFileName}`,
     );
   }
   if (extensionConfig.excludeTools) {

packages/cli/src/config/extensions/update.test.ts

@@ -41,6 +41,17 @@ vi.mock('simple-git', () => ({
   }),
 }));
 
+vi.mock('../extensions/github.js', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../extensions/github.js')>();
+  return {
+    ...actual,
+    downloadFromGitHubRelease: vi
+      .fn()
+      .mockRejectedValue(new Error('Mocked GitHub release download failure')),
+  };
+});
+
 vi.mock('os', async (importOriginal) => {
   const mockedOs = await importOriginal<typeof os>();
   return {

packages/cli/src/config/settingsSchema.ts

@@ -147,6 +147,16 @@ const SETTINGS_SCHEMA = {
         description: 'Disable update notification prompts.',
         showInDialog: false,
       },
+      gitCoAuthor: {
+        type: 'boolean',
+        label: 'Git Co-Author',
+        category: 'General',
+        requiresRestart: false,
+        default: true,
+        description:
+          'Automatically add a Co-authored-by trailer to git commit messages when commits are made through Qwen Code.',
+        showInDialog: false,
+      },
       checkpointing: {
         type: 'object',
         label: 'Checkpointing',
@@ -284,7 +294,7 @@ const SETTINGS_SCHEMA = {
         requiresRestart: false,
         default: false,
         description:
-          'Show Gemini CLI status and thoughts in the terminal window title',
+          'Show Qwen Code status and thoughts in the terminal window title',
         showInDialog: true,
       },
       hideTips: {
@@ -312,7 +322,7 @@ const SETTINGS_SCHEMA = {
         requiresRestart: false,
         default: false,
         description:
-          'Hide the context summary (GEMINI.md, MCP servers) above the input.',
+          'Hide the context summary (QWEN.md, MCP servers) above the input.',
         showInDialog: true,
       },
       footer: {
@@ -518,7 +528,7 @@ const SETTINGS_SCHEMA = {
         category: 'Model',
         requiresRestart: false,
         default: undefined as string | undefined,
-        description: 'The Gemini model to use for conversations.',
+        description: 'The model to use for conversations.',
         showInDialog: false,
       },
       maxSessionTurns: {
@@ -649,6 +659,22 @@ const SETTINGS_SCHEMA = {
             childKey: 'disableCacheControl',
             showInDialog: true,
           },
+          schemaCompliance: {
+            type: 'enum',
+            label: 'Tool Schema Compliance',
+            category: 'Generation Configuration',
+            requiresRestart: false,
+            default: 'auto',
+            description:
+              'The compliance mode for tool schemas sent to the model. Use "openapi_30" for strict OpenAPI 3.0 compatibility (e.g., for Gemini).',
+            parentKey: 'generationConfig',
+            childKey: 'schemaCompliance',
+            showInDialog: true,
+            options: [
+              { value: 'auto', label: 'Auto (Default)' },
+              { value: 'openapi_30', label: 'OpenAPI 3.0 Strict' },
+            ],
+          },
         },
       },
     },

packages/cli/src/gemini.test.tsx

@@ -379,8 +379,8 @@ describe('gemini.tsx main function kitty protocol', () => {
 
   beforeEach(() => {
     // Set no relaunch in tests since process spawning causing issues in tests
-    originalEnvNoRelaunch = process.env['GEMINI_CLI_NO_RELAUNCH'];
-    process.env['GEMINI_CLI_NO_RELAUNCH'] = 'true';
+    originalEnvNoRelaunch = process.env['QWEN_CODE_NO_RELAUNCH'];
+    process.env['QWEN_CODE_NO_RELAUNCH'] = 'true';
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     if (!(process.stdin as any).setRawMode) {
@@ -402,9 +402,9 @@ describe('gemini.tsx main function kitty protocol', () => {
   afterEach(() => {
     // Restore original env variables
     if (originalEnvNoRelaunch !== undefined) {
-      process.env['GEMINI_CLI_NO_RELAUNCH'] = originalEnvNoRelaunch;
+      process.env['QWEN_CODE_NO_RELAUNCH'] = originalEnvNoRelaunch;
     } else {
-      delete process.env['GEMINI_CLI_NO_RELAUNCH'];
+      delete process.env['QWEN_CODE_NO_RELAUNCH'];
     }
   });
 

packages/cli/src/gemini.tsx

@@ -4,13 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Config } from '@qwen-code/qwen-code-core';
-import {
-  AuthType,
-  getOauthClient,
-  InputFormat,
-  logUserPrompt,
-} from '@qwen-code/qwen-code-core';
+import type { Config, AuthType } from '@qwen-code/qwen-code-core';
+import { InputFormat, logUserPrompt } from '@qwen-code/qwen-code-core';
 import { render } from 'ink';
 import dns from 'node:dns';
 import os from 'node:os';
@@ -58,7 +53,7 @@ import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
 import { getCliVersion } from './utils/version.js';
 import { computeWindowTitle } from './utils/windowTitle.js';
 import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
-import { showResumeSessionPicker } from './ui/components/ResumeSessionPicker.js';
+import { showResumeSessionPicker } from './ui/components/StandaloneSessionPicker.js';
 
 export function validateDnsResolutionOrder(
   order: string | undefined,
@@ -92,7 +87,7 @@ function getNodeMemoryArgs(isDebugMode: boolean): string[] {
     );
   }
 
-  if (process.env['GEMINI_CLI_NO_RELAUNCH']) {
+  if (process.env['QWEN_CODE_NO_RELAUNCH']) {
     return [];
   }
 
@@ -399,15 +394,6 @@ export async function main() {
       initializationResult = await initializeApp(config, settings);
     }
 
-    if (
-      settings.merged.security?.auth?.selectedType ===
-        AuthType.LOGIN_WITH_GOOGLE &&
-      config.isBrowserLaunchSuppressed()
-    ) {
-      // Do oauth before app renders to make copying the link possible.
-      await getOauthClient(settings.merged.security.auth.selectedType, config);
-    }
-
     if (config.getExperimentalZedIntegration()) {
       return runAcpAgent(config, settings, extensions, argv);
     }

packages/cli/src/i18n/locales/en.js

@@ -310,6 +310,7 @@ export default {
   'Tool Output Truncation Lines': 'Tool Output Truncation Lines',
   'Folder Trust': 'Folder Trust',
   'Vision Model Preview': 'Vision Model Preview',
+  'Tool Schema Compliance': 'Tool Schema Compliance',
   // Settings enum options
   'Auto (detect from system)': 'Auto (detect from system)',
   Text: 'Text',
@@ -635,8 +636,8 @@ export default {
   'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.':
     'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.',
   "Error adding '{{path}}': {{error}}": "Error adding '{{path}}': {{error}}",
-  'Successfully added GEMINI.md files from the following directories if there are:\n- {{directories}}':
-    'Successfully added GEMINI.md files from the following directories if there are:\n- {{directories}}',
+  'Successfully added QWEN.md files from the following directories if there are:\n- {{directories}}':
+    'Successfully added QWEN.md files from the following directories if there are:\n- {{directories}}',
   'Error refreshing memory: {{error}}': 'Error refreshing memory: {{error}}',
   'Successfully added directories:\n- {{directories}}':
     'Successfully added directories:\n- {{directories}}',

packages/cli/src/i18n/locales/zh.js

@@ -300,6 +300,7 @@ export default {
   'Tool Output Truncation Lines': '工具输出截断行数',
   'Folder Trust': '文件夹信任',
   'Vision Model Preview': '视觉模型预览',
+  'Tool Schema Compliance': '工具 Schema 兼容性',
   // Settings enum options
   'Auto (detect from system)': '自动（从系统检测）',
   Text: '文本',
@@ -601,8 +602,8 @@ export default {
   'The /directory add command is not supported in restrictive sandbox profiles. Please use --include-directories when starting the session instead.':
     '/directory add 命令在限制性沙箱配置文件中不受支持。请改为在启动会话时使用 --include-directories。',
   "Error adding '{{path}}': {{error}}": "添加 '{{path}}' 时出错：{{error}}",
-  'Successfully added GEMINI.md files from the following directories if there are:\n- {{directories}}':
-    '如果存在，已成功从以下目录添加 GEMINI.md 文件：\n- {{directories}}',
+  'Successfully added QWEN.md files from the following directories if there are:\n- {{directories}}':
+    '如果存在，已成功从以下目录添加 QWEN.md 文件：\n- {{directories}}',
   'Error refreshing memory: {{error}}': '刷新内存时出错：{{error}}',
   'Successfully added directories:\n- {{directories}}':
     '成功添加目录：\n- {{directories}}',

packages/cli/src/nonInteractive/io/BaseJsonOutputAdapter.ts

@@ -610,8 +610,6 @@ export abstract class BaseJsonOutputAdapter {
         const errorText = parseAndFormatApiError(
           event.value.error,
           this.config.getContentGeneratorConfig()?.authType,
-          undefined,
-          this.config.getModel(),
         );
         this.appendText(state, errorText, null);
         break;

packages/cli/src/nonInteractiveCli.ts

@@ -221,8 +221,6 @@ export async function runNonInteractive(
               const errorText = parseAndFormatApiError(
                 event.value.error,
                 config.getContentGeneratorConfig()?.authType,
-                undefined,
-                config.getModel(),
               );
               process.stderr.write(`${errorText}\n`);
             }

packages/cli/src/services/BuiltinCommandLoader.ts

@@ -29,6 +29,7 @@ import { modelCommand } from '../ui/commands/modelCommand.js';
 import { permissionsCommand } from '../ui/commands/permissionsCommand.js';
 import { quitCommand } from '../ui/commands/quitCommand.js';
 import { restoreCommand } from '../ui/commands/restoreCommand.js';
+import { resumeCommand } from '../ui/commands/resumeCommand.js';
 import { settingsCommand } from '../ui/commands/settingsCommand.js';
 import { statsCommand } from '../ui/commands/statsCommand.js';
 import { summaryCommand } from '../ui/commands/summaryCommand.js';
@@ -76,6 +77,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       ...(this.config?.getFolderTrust() ? [permissionsCommand] : []),
       quitCommand,
       restoreCommand(this.config),
+      resumeCommand,
       statsCommand,
       summaryCommand,
       themeCommand,

packages/cli/src/services/McpPromptLoader.test.ts

@@ -28,7 +28,7 @@ const mockPrompt = {
     { name: 'trail', required: false, description: "The animal's trail." },
   ],
   invoke: vi.fn().mockResolvedValue({
-    messages: [{ content: { text: 'Hello, world!' } }],
+    messages: [{ content: { type: 'text', text: 'Hello, world!' } }],
   }),
 };
 

packages/cli/src/services/McpPromptLoader.ts

@@ -123,7 +123,10 @@ export class McpPromptLoader implements ICommandLoader {
                 };
               }
 
-              if (!result.messages?.[0]?.content?.['text']) {
+              const firstMessage = result.messages?.[0];
+              const content = firstMessage?.content;
+
+              if (content?.type !== 'text') {
                 return {
                   type: 'message',
                   messageType: 'error',
@@ -134,7 +137,7 @@ export class McpPromptLoader implements ICommandLoader {
 
               return {
                 type: 'submit_prompt',
-                content: JSON.stringify(result.messages[0].content.text),
+                content: JSON.stringify(content.text),
               };
             } catch (error) {
               return {

packages/cli/src/ui/AppContainer.test.tsx

@@ -23,7 +23,6 @@ import {
 } from '@qwen-code/qwen-code-core';
 import type { LoadedSettings } from '../config/settings.js';
 import type { InitializationResult } from '../core/initializer.js';
-import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { UIStateContext, type UIState } from './contexts/UIStateContext.js';
 import {
   UIActionsContext,
@@ -56,7 +55,6 @@ vi.mock('./App.js', () => ({
   App: TestContextConsumer,
 }));
 
-vi.mock('./hooks/useQuotaAndFallback.js');
 vi.mock('./hooks/useHistoryManager.js');
 vi.mock('./hooks/useThemeCommand.js');
 vi.mock('./auth/useAuth.js');
@@ -122,7 +120,6 @@ describe('AppContainer State Management', () => {
   let mockInitResult: InitializationResult;
 
   // Create typed mocks for all hooks
-  const mockedUseQuotaAndFallback = useQuotaAndFallback as Mock;
   const mockedUseHistory = useHistory as Mock;
   const mockedUseThemeCommand = useThemeCommand as Mock;
   const mockedUseAuthCommand = useAuthCommand as Mock;
@@ -164,10 +161,6 @@ describe('AppContainer State Management', () => {
     capturedUIActions = null!;
 
     // **Provide a default return value for EVERY mocked hook.**
-    mockedUseQuotaAndFallback.mockReturnValue({
-      proQuotaRequest: null,
-      handleProQuotaChoice: vi.fn(),
-    });
     mockedUseHistory.mockReturnValue({
       history: [],
       addItem: vi.fn(),
@@ -567,75 +560,6 @@ describe('AppContainer State Management', () => {
     });
   });
 
-  describe('Quota and Fallback Integration', () => {
-    it('passes a null proQuotaRequest to UIStateContext by default', () => {
-      // The default mock from beforeEach already sets proQuotaRequest to null
-      render(
-        <AppContainer
-          config={mockConfig}
-          settings={mockSettings}
-          version="1.0.0"
-          initializationResult={mockInitResult}
-        />,
-      );
-
-      // Assert that the context value is as expected
-      expect(capturedUIState.proQuotaRequest).toBeNull();
-    });
-
-    it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', () => {
-      // Arrange: Create a mock request object that a UI dialog would receive
-      const mockRequest = {
-        failedModel: 'gemini-pro',
-        fallbackModel: 'gemini-flash',
-        resolve: vi.fn(),
-      };
-      mockedUseQuotaAndFallback.mockReturnValue({
-        proQuotaRequest: mockRequest,
-        handleProQuotaChoice: vi.fn(),
-      });
-
-      // Act: Render the container
-      render(
-        <AppContainer
-          config={mockConfig}
-          settings={mockSettings}
-          version="1.0.0"
-          initializationResult={mockInitResult}
-        />,
-      );
-
-      // Assert: The mock request is correctly passed through the context
-      expect(capturedUIState.proQuotaRequest).toEqual(mockRequest);
-    });
-
-    it('passes the handleProQuotaChoice function to UIActionsContext', () => {
-      // Arrange: Create a mock handler function
-      const mockHandler = vi.fn();
-      mockedUseQuotaAndFallback.mockReturnValue({
-        proQuotaRequest: null,
-        handleProQuotaChoice: mockHandler,
-      });
-
-      // Act: Render the container
-      render(
-        <AppContainer
-          config={mockConfig}
-          settings={mockSettings}
-          version="1.0.0"
-          initializationResult={mockInitResult}
-        />,
-      );
-
-      // Assert: The action in the context is the mock handler we provided
-      expect(capturedUIActions.handleProQuotaChoice).toBe(mockHandler);
-
-      // You can even verify that the plumbed function is callable
-      capturedUIActions.handleProQuotaChoice('auth');
-      expect(mockHandler).toHaveBeenCalledWith('auth');
-    });
-  });
-
   describe('Terminal Title Update Feature', () => {
     beforeEach(() => {
       // Reset mock stdout for each test

packages/cli/src/ui/AppContainer.tsx

@@ -32,7 +32,6 @@ import {
   type Config,
   type IdeInfo,
   type IdeContext,
-  type UserTierId,
   DEFAULT_GEMINI_FLASH_MODEL,
   IdeClient,
   ideContextStore,
@@ -48,11 +47,11 @@ import { useHistory } from './hooks/useHistoryManager.js';
 import { useMemoryMonitor } from './hooks/useMemoryMonitor.js';
 import { useThemeCommand } from './hooks/useThemeCommand.js';
 import { useAuthCommand } from './auth/useAuth.js';
-import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { useEditorSettings } from './hooks/useEditorSettings.js';
 import { useSettingsCommand } from './hooks/useSettingsCommand.js';
 import { useModelCommand } from './hooks/useModelCommand.js';
 import { useApprovalModeCommand } from './hooks/useApprovalModeCommand.js';
+import { useResumeCommand } from './hooks/useResumeCommand.js';
 import { useSlashCommandProcessor } from './hooks/slashCommandProcessor.js';
 import { useVimMode } from './contexts/VimModeContext.js';
 import { useConsoleMessages } from './hooks/useConsoleMessages.js';
@@ -191,8 +190,6 @@ export const AppContainer = (props: AppContainerProps) => {
 
   const [currentModel, setCurrentModel] = useState(getEffectiveModel());
 
-  const [userTier] = useState<UserTierId | undefined>(undefined);
-
   const [isConfigInitialized, setConfigInitialized] = useState(false);
 
   const [userMessages, setUserMessages] = useState<string[]>([]);
@@ -203,7 +200,7 @@ export const AppContainer = (props: AppContainerProps) => {
   const { stdout } = useStdout();
 
   // Additional hooks moved from App.tsx
-  const { stats: sessionStats } = useSessionStats();
+  const { stats: sessionStats, startNewSession } = useSessionStats();
   const logger = useLogger(config.storage, sessionStats.sessionId);
   const branchName = useGitBranchName(config.getTargetDir());
 
@@ -366,14 +363,6 @@ export const AppContainer = (props: AppContainerProps) => {
     cancelAuthentication,
   } = useAuthCommand(settings, config, historyManager.addItem);
 
-  const { proQuotaRequest, handleProQuotaChoice } = useQuotaAndFallback({
-    config,
-    historyManager,
-    userTier,
-    setAuthState,
-    setModelSwitchedFromQuotaError,
-  });
-
   useInitializationAuthError(initializationResult.authError, onAuthError);
 
   // Sync user tier from config when authentication changes
@@ -435,6 +424,18 @@ export const AppContainer = (props: AppContainerProps) => {
   const { isModelDialogOpen, openModelDialog, closeModelDialog } =
     useModelCommand();
 
+  const {
+    isResumeDialogOpen,
+    openResumeDialog,
+    closeResumeDialog,
+    handleResume,
+  } = useResumeCommand({
+    config,
+    historyManager,
+    startNewSession,
+    remount: refreshStatic,
+  });
+
   const {
     showWorkspaceMigrationDialog,
     workspaceExtensions,
@@ -488,6 +489,7 @@ export const AppContainer = (props: AppContainerProps) => {
       addConfirmUpdateExtensionRequest,
       openSubagentCreateDialog,
       openAgentsManagerDialog,
+      openResumeDialog,
     }),
     [
       openAuthDialog,
@@ -502,6 +504,7 @@ export const AppContainer = (props: AppContainerProps) => {
       addConfirmUpdateExtensionRequest,
       openSubagentCreateDialog,
       openAgentsManagerDialog,
+      openResumeDialog,
     ],
   );
 
@@ -737,8 +740,7 @@ export const AppContainer = (props: AppContainerProps) => {
     !initError &&
     !isProcessing &&
     (streamingState === StreamingState.Idle ||
-      streamingState === StreamingState.Responding) &&
-    !proQuotaRequest;
+      streamingState === StreamingState.Responding);
 
   const [controlsHeight, setControlsHeight] = useState(0);
 
@@ -1191,10 +1193,10 @@ export const AppContainer = (props: AppContainerProps) => {
     isAuthenticating ||
     isEditorDialogOpen ||
     showIdeRestartPrompt ||
-    !!proQuotaRequest ||
     isSubagentCreateDialogOpen ||
     isAgentsManagerDialogOpen ||
-    isApprovalModeDialogOpen;
+    isApprovalModeDialogOpen ||
+    isResumeDialogOpen;
 
   const pendingHistoryItems = useMemo(
     () => [...pendingSlashCommandHistoryItems, ...pendingGeminiHistoryItems],
@@ -1222,6 +1224,7 @@ export const AppContainer = (props: AppContainerProps) => {
       isModelDialogOpen,
       isPermissionsDialogOpen,
       isApprovalModeDialogOpen,
+      isResumeDialogOpen,
       slashCommands,
       pendingSlashCommandHistoryItems,
       commandContext,
@@ -1260,8 +1263,6 @@ export const AppContainer = (props: AppContainerProps) => {
       showWorkspaceMigrationDialog,
       workspaceExtensions,
       currentModel,
-      userTier,
-      proQuotaRequest,
       contextFileNames,
       errorCount,
       availableTerminalHeight,
@@ -1312,6 +1313,7 @@ export const AppContainer = (props: AppContainerProps) => {
       isModelDialogOpen,
       isPermissionsDialogOpen,
       isApprovalModeDialogOpen,
+      isResumeDialogOpen,
       slashCommands,
       pendingSlashCommandHistoryItems,
       commandContext,
@@ -1349,8 +1351,6 @@ export const AppContainer = (props: AppContainerProps) => {
       showAutoAcceptIndicator,
       showWorkspaceMigrationDialog,
       workspaceExtensions,
-      userTier,
-      proQuotaRequest,
       contextFileNames,
       errorCount,
       availableTerminalHeight,
@@ -1412,7 +1412,6 @@ export const AppContainer = (props: AppContainerProps) => {
       handleClearScreen,
       onWorkspaceMigrationDialogOpen,
       onWorkspaceMigrationDialogClose,
-      handleProQuotaChoice,
       // Vision switch dialog
       handleVisionSwitchSelect,
       // Welcome back dialog
@@ -1421,6 +1420,10 @@ export const AppContainer = (props: AppContainerProps) => {
       // Subagent dialogs
       closeSubagentCreateDialog,
       closeAgentsManagerDialog,
+      // Resume session dialog
+      openResumeDialog,
+      closeResumeDialog,
+      handleResume,
     }),
     [
       handleThemeSelect,
@@ -1446,13 +1449,16 @@ export const AppContainer = (props: AppContainerProps) => {
       handleClearScreen,
       onWorkspaceMigrationDialogOpen,
       onWorkspaceMigrationDialogClose,
-      handleProQuotaChoice,
       handleVisionSwitchSelect,
       handleWelcomeBackSelection,
       handleWelcomeBackClose,
       // Subagent dialogs
       closeSubagentCreateDialog,
       closeAgentsManagerDialog,
+      // Resume session dialog
+      openResumeDialog,
+      closeResumeDialog,
+      handleResume,
     ],
   );
 

packages/cli/src/ui/auth/AuthDialog.test.tsx

@@ -168,7 +168,7 @@ describe('AuthDialog', () => {
 
     it('should not show the GEMINI_API_KEY message if QWEN_DEFAULT_AUTH_TYPE is set to something else', () => {
       process.env['GEMINI_API_KEY'] = 'foobar';
-      process.env['QWEN_DEFAULT_AUTH_TYPE'] = AuthType.LOGIN_WITH_GOOGLE;
+      process.env['QWEN_DEFAULT_AUTH_TYPE'] = AuthType.USE_OPENAI;
 
       const settings: LoadedSettings = new LoadedSettings(
         {
@@ -212,7 +212,7 @@ describe('AuthDialog', () => {
 
     it('should show the GEMINI_API_KEY message if QWEN_DEFAULT_AUTH_TYPE is set to use api key', () => {
       process.env['GEMINI_API_KEY'] = 'foobar';
-      process.env['QWEN_DEFAULT_AUTH_TYPE'] = AuthType.USE_GEMINI;
+      process.env['QWEN_DEFAULT_AUTH_TYPE'] = AuthType.USE_OPENAI;
 
       const settings: LoadedSettings = new LoadedSettings(
         {
@@ -504,12 +504,12 @@ describe('AuthDialog', () => {
       },
       {
         settings: {
-          security: { auth: { selectedType: AuthType.LOGIN_WITH_GOOGLE } },
+          security: { auth: { selectedType: AuthType.USE_OPENAI } },
           ui: { customThemes: {} },
           mcpServers: {},
         },
         originalSettings: {
-          security: { auth: { selectedType: AuthType.LOGIN_WITH_GOOGLE } },
+          security: { auth: { selectedType: AuthType.USE_OPENAI } },
           ui: { customThemes: {} },
           mcpServers: {},
         },

packages/cli/src/ui/auth/useAuth.ts

@@ -225,16 +225,24 @@ export const useAuthCommand = (
     const defaultAuthType = process.env['QWEN_DEFAULT_AUTH_TYPE'];
     if (
       defaultAuthType &&
-      ![AuthType.QWEN_OAUTH, AuthType.USE_OPENAI].includes(
-        defaultAuthType as AuthType,
-      )
+      ![
+        AuthType.QWEN_OAUTH,
+        AuthType.USE_OPENAI,
+        AuthType.USE_GEMINI,
+        AuthType.USE_VERTEX_AI,
+      ].includes(defaultAuthType as AuthType)
     ) {
       onAuthError(
         t(
           'Invalid QWEN_DEFAULT_AUTH_TYPE value: "{{value}}". Valid values are: {{validValues}}',
           {
             value: defaultAuthType,
-            validValues: [AuthType.QWEN_OAUTH, AuthType.USE_OPENAI].join(', '),
+            validValues: [
+              AuthType.QWEN_OAUTH,
+              AuthType.USE_OPENAI,
+              AuthType.USE_GEMINI,
+              AuthType.USE_VERTEX_AI,
+            ].join(', '),
           },
         ),
       );

packages/cli/src/ui/commands/directoryCommand.tsx

@@ -130,7 +130,7 @@ export const directoryCommand: SlashCommand = {
             {
               type: MessageType.INFO,
               text: t(
-                'Successfully added GEMINI.md files from the following directories if there are:\n- {{directories}}',
+                'Successfully added QWEN.md files from the following directories if there are:\n- {{directories}}',
                 {
                   directories: added.join('\n- '),
                 },

packages/cli/src/ui/commands/ideCommand.test.ts

@@ -15,7 +15,6 @@ vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
   const original = await importOriginal<typeof core>();
   return {
     ...original,
-    getOauthClient: vi.fn(original.getOauthClient),
     getIdeInstaller: vi.fn(original.getIdeInstaller),
     IdeClient: {
       getInstance: vi.fn(),

packages/cli/src/ui/commands/restoreCommand.test.ts

@@ -89,7 +89,7 @@ describe('restoreCommand', () => {
       ).toEqual({
         type: 'message',
         messageType: 'error',
-        content: 'Could not determine the .gemini directory path.',
+        content: 'Could not determine the .qwen directory path.',
       });
     });
 

packages/cli/src/ui/commands/restoreCommand.ts

@@ -28,7 +28,7 @@ async function restoreAction(
     return {
       type: 'message',
       messageType: 'error',
-      content: 'Could not determine the .gemini directory path.',
+      content: 'Could not determine the .qwen directory path.',
     };
   }
 

packages/cli/src/ui/commands/resumeCommand.test.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { resumeCommand } from './resumeCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('resumeCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext();
+  });
+
+  it('should return a dialog action to open the resume dialog', async () => {
+    // Ensure the command has an action to test.
+    if (!resumeCommand.action) {
+      throw new Error('The resume command must have an action.');
+    }
+
+    const result = await resumeCommand.action(mockContext, '');
+
+    // Assert that the action returns the correct object to trigger the resume dialog.
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'resume',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(resumeCommand.name).toBe('resume');
+    expect(resumeCommand.description).toBe('Resume a previous session');
+  });
+});

packages/cli/src/ui/commands/resumeCommand.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { SlashCommand, SlashCommandActionReturn } from './types.js';
+import { CommandKind } from './types.js';
+import { t } from '../../i18n/index.js';
+
+export const resumeCommand: SlashCommand = {
+  name: 'resume',
+  kind: CommandKind.BUILT_IN,
+  get description() {
+    return t('Resume a previous session');
+  },
+  action: async (): Promise<SlashCommandActionReturn> => ({
+    type: 'dialog',
+    dialog: 'resume',
+  }),
+};

packages/cli/src/ui/commands/types.ts

@@ -124,7 +124,8 @@ export interface OpenDialogActionReturn {
     | 'subagent_create'
     | 'subagent_list'
     | 'permissions'
-    | 'approval-mode';
+    | 'approval-mode'
+    | 'resume';
 }
 
 /**

packages/cli/src/ui/components/DialogManager.tsx

@@ -17,7 +17,6 @@ import { AuthDialog } from '../auth/AuthDialog.js';
 import { OpenAIKeyPrompt } from './OpenAIKeyPrompt.js';
 import { EditorSettingsDialog } from './EditorSettingsDialog.js';
 import { WorkspaceMigrationDialog } from './WorkspaceMigrationDialog.js';
-import { ProQuotaDialog } from './ProQuotaDialog.js';
 import { PermissionsModifyTrustDialog } from './PermissionsModifyTrustDialog.js';
 import { ModelDialog } from './ModelDialog.js';
 import { ApprovalModeDialog } from './ApprovalModeDialog.js';
@@ -36,6 +35,7 @@ import { WelcomeBackDialog } from './WelcomeBackDialog.js';
 import { ModelSwitchDialog } from './ModelSwitchDialog.js';
 import { AgentCreationWizard } from './subagents/create/AgentCreationWizard.js';
 import { AgentsManagerDialog } from './subagents/manage/AgentsManagerDialog.js';
+import { SessionPicker } from './SessionPicker.js';
 
 interface DialogManagerProps {
   addItem: UseHistoryManagerReturn['addItem'];
@@ -86,15 +86,6 @@ export const DialogManager = ({
       />
     );
   }
-  if (uiState.proQuotaRequest) {
-    return (
-      <ProQuotaDialog
-        failedModel={uiState.proQuotaRequest.failedModel}
-        fallbackModel={uiState.proQuotaRequest.fallbackModel}
-        onChoice={uiActions.handleProQuotaChoice}
-      />
-    );
-  }
   if (uiState.shouldShowIdePrompt) {
     return (
       <IdeIntegrationNudge
@@ -290,5 +281,16 @@ export const DialogManager = ({
     );
   }
 
+  if (uiState.isResumeDialogOpen) {
+    return (
+      <SessionPicker
+        sessionService={config.getSessionService()}
+        currentBranch={uiState.branchName}
+        onSelect={uiActions.handleResume}
+        onCancel={uiActions.closeResumeDialog}
+      />
+    );
+  }
+
   return null;
 };

packages/cli/src/ui/components/PermissionsModifyTrustDialog.tsx

@@ -115,7 +115,7 @@ export function PermissionsModifyTrustDialog({
       {needsRestart && (
         <Box marginLeft={1} marginTop={1}>
           <Text color={theme.status.warning}>
-            To apply the trust changes, Gemini CLI must be restarted. Press
+            To apply the trust changes, Qwen Code must be restarted. Press
             &apos;r&apos; to restart CLI now.
           </Text>
         </Box>

packages/cli/src/ui/components/ProQuotaDialog.test.tsx

@@ -1,91 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { render } from 'ink-testing-library';
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
-import { ProQuotaDialog } from './ProQuotaDialog.js';
-import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
-
-// Mock the child component to make it easier to test the parent
-vi.mock('./shared/RadioButtonSelect.js', () => ({
-  RadioButtonSelect: vi.fn(),
-}));
-
-describe('ProQuotaDialog', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should render with correct title and options', () => {
-    const { lastFrame } = render(
-      <ProQuotaDialog
-        failedModel="gemini-2.5-pro"
-        fallbackModel="gemini-2.5-flash"
-        onChoice={() => {}}
-      />,
-    );
-
-    const output = lastFrame();
-    expect(output).toContain('Pro quota limit reached for gemini-2.5-pro.');
-
-    // Check that RadioButtonSelect was called with the correct items
-    expect(RadioButtonSelect).toHaveBeenCalledWith(
-      expect.objectContaining({
-        items: [
-          {
-            label: 'Change auth (executes the /auth command)',
-            value: 'auth',
-            key: 'auth',
-          },
-          {
-            label: `Continue with gemini-2.5-flash`,
-            value: 'continue',
-            key: 'continue',
-          },
-        ],
-      }),
-      undefined,
-    );
-  });
-
-  it('should call onChoice with "auth" when "Change auth" is selected', () => {
-    const mockOnChoice = vi.fn();
-    render(
-      <ProQuotaDialog
-        failedModel="gemini-2.5-pro"
-        fallbackModel="gemini-2.5-flash"
-        onChoice={mockOnChoice}
-      />,
-    );
-
-    // Get the onSelect function passed to RadioButtonSelect
-    const onSelect = (RadioButtonSelect as Mock).mock.calls[0][0].onSelect;
-
-    // Simulate the selection
-    onSelect('auth');
-
-    expect(mockOnChoice).toHaveBeenCalledWith('auth');
-  });
-
-  it('should call onChoice with "continue" when "Continue with flash" is selected', () => {
-    const mockOnChoice = vi.fn();
-    render(
-      <ProQuotaDialog
-        failedModel="gemini-2.5-pro"
-        fallbackModel="gemini-2.5-flash"
-        onChoice={mockOnChoice}
-      />,
-    );
-
-    // Get the onSelect function passed to RadioButtonSelect
-    const onSelect = (RadioButtonSelect as Mock).mock.calls[0][0].onSelect;
-
-    // Simulate the selection
-    onSelect('continue');
-
-    expect(mockOnChoice).toHaveBeenCalledWith('continue');
-  });
-});

packages/cli/src/ui/components/ProQuotaDialog.tsx

@@ -1,55 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type React from 'react';
-import { Box, Text } from 'ink';
-import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
-import { theme } from '../semantic-colors.js';
-import { t } from '../../i18n/index.js';
-
-interface ProQuotaDialogProps {
-  failedModel: string;
-  fallbackModel: string;
-  onChoice: (choice: 'auth' | 'continue') => void;
-}
-
-export function ProQuotaDialog({
-  failedModel,
-  fallbackModel,
-  onChoice,
-}: ProQuotaDialogProps): React.JSX.Element {
-  const items = [
-    {
-      label: t('Change auth (executes the /auth command)'),
-      value: 'auth' as const,
-      key: 'auth',
-    },
-    {
-      label: t('Continue with {{model}}', { model: fallbackModel }),
-      value: 'continue' as const,
-      key: 'continue',
-    },
-  ];
-
-  const handleSelect = (choice: 'auth' | 'continue') => {
-    onChoice(choice);
-  };
-
-  return (
-    <Box borderStyle="round" flexDirection="column" paddingX={1}>
-      <Text bold color={theme.status.warning}>
-        {t('Pro quota limit reached for {{model}}.', { model: failedModel })}
-      </Text>
-      <Box marginTop={1}>
-        <RadioButtonSelect
-          items={items}
-          initialIndex={1}
-          onSelect={handleSelect}
-        />
-      </Box>
-    </Box>
-  );
-}

packages/cli/src/ui/components/ResumeSessionPicker.tsx

@@ -1,436 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Code
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-import { render, Box, Text, useInput, useApp } from 'ink';
-import {
-  SessionService,
-  type SessionListItem,
-  type ListSessionsResult,
-  getGitBranch,
-} from '@qwen-code/qwen-code-core';
-import { theme } from '../semantic-colors.js';
-import { formatRelativeTime } from '../utils/formatters.js';
-
-const PAGE_SIZE = 20;
-
-interface SessionPickerProps {
-  sessionService: SessionService;
-  currentBranch?: string;
-  onSelect: (sessionId: string) => void;
-  onCancel: () => void;
-}
-
-/**
- * Truncates text to fit within a given width, adding ellipsis if needed.
- */
-function truncateText(text: string, maxWidth: number): string {
-  if (text.length <= maxWidth) return text;
-  if (maxWidth <= 3) return text.slice(0, maxWidth);
-  return text.slice(0, maxWidth - 3) + '...';
-}
-
-function SessionPicker({
-  sessionService,
-  currentBranch,
-  onSelect,
-  onCancel,
-}: SessionPickerProps): React.JSX.Element {
-  const { exit } = useApp();
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [sessionState, setSessionState] = useState<{
-    sessions: SessionListItem[];
-    hasMore: boolean;
-    nextCursor?: number;
-  }>({
-    sessions: [],
-    hasMore: true,
-    nextCursor: undefined,
-  });
-  const isLoadingMoreRef = useRef(false);
-  const [filterByBranch, setFilterByBranch] = useState(false);
-  const [isExiting, setIsExiting] = useState(false);
-  const [terminalSize, setTerminalSize] = useState({
-    width: process.stdout.columns || 80,
-    height: process.stdout.rows || 24,
-  });
-
-  // Update terminal size on resize
-  useEffect(() => {
-    const handleResize = () => {
-      setTerminalSize({
-        width: process.stdout.columns || 80,
-        height: process.stdout.rows || 24,
-      });
-    };
-    process.stdout.on('resize', handleResize);
-    return () => {
-      process.stdout.off('resize', handleResize);
-    };
-  }, []);
-
-  // Filter sessions by current branch if filter is enabled
-  const filteredSessions =
-    filterByBranch && currentBranch
-      ? sessionState.sessions.filter(
-          (session) => session.gitBranch === currentBranch,
-        )
-      : sessionState.sessions;
-
-  const hasSentinel = sessionState.hasMore;
-
-  // Reset selection when filter changes
-  useEffect(() => {
-    setSelectedIndex(0);
-  }, [filterByBranch]);
-
-  const loadMoreSessions = useCallback(async () => {
-    if (!sessionState.hasMore || isLoadingMoreRef.current) return;
-    isLoadingMoreRef.current = true;
-    try {
-      const result: ListSessionsResult = await sessionService.listSessions({
-        size: PAGE_SIZE,
-        cursor: sessionState.nextCursor,
-      });
-
-      setSessionState((prev) => ({
-        sessions: [...prev.sessions, ...result.items],
-        hasMore: result.hasMore && result.nextCursor !== undefined,
-        nextCursor: result.nextCursor,
-      }));
-    } finally {
-      isLoadingMoreRef.current = false;
-    }
-  }, [sessionService, sessionState.hasMore, sessionState.nextCursor]);
-
-  // Calculate visible items
-  // Reserved space: header (1), footer (1), separators (2), borders (2)
-  const reservedLines = 6;
-  // Each item takes 2 lines (prompt + metadata) + 1 line margin between items
-  // On average, this is ~3 lines per item, but the last item has no margin
-  const itemHeight = 3;
-  const maxVisibleItems = Math.max(
-    1,
-    Math.floor((terminalSize.height - reservedLines) / itemHeight),
-  );
-
-  // Calculate scroll offset
-  const scrollOffset = (() => {
-    if (filteredSessions.length <= maxVisibleItems) return 0;
-    const halfVisible = Math.floor(maxVisibleItems / 2);
-    let offset = selectedIndex - halfVisible;
-    offset = Math.max(0, offset);
-    offset = Math.min(filteredSessions.length - maxVisibleItems, offset);
-    return offset;
-  })();
-
-  const visibleSessions = filteredSessions.slice(
-    scrollOffset,
-    scrollOffset + maxVisibleItems,
-  );
-  const showScrollUp = scrollOffset > 0;
-  const showScrollDown =
-    scrollOffset + maxVisibleItems < filteredSessions.length;
-
-  // Sentinel (invisible) sits after the last session item; consider it visible
-  // once the viewport reaches the final real item.
-  const sentinelVisible =
-    hasSentinel && scrollOffset + maxVisibleItems >= filteredSessions.length;
-
-  // Load more when sentinel enters view or when filtered list is empty.
-  useEffect(() => {
-    if (!sessionState.hasMore || isLoadingMoreRef.current) return;
-
-    const shouldLoadMore =
-      filteredSessions.length === 0 ||
-      sentinelVisible ||
-      isLoadingMoreRef.current;
-
-    if (shouldLoadMore) {
-      void loadMoreSessions();
-    }
-  }, [
-    filteredSessions.length,
-    loadMoreSessions,
-    sessionState.hasMore,
-    sentinelVisible,
-  ]);
-
-  // Handle keyboard input
-  useInput((input, key) => {
-    // Ignore input if already exiting
-    if (isExiting) {
-      return;
-    }
-
-    // Escape or Ctrl+C to cancel
-    if (key.escape || (key.ctrl && input === 'c')) {
-      setIsExiting(true);
-      onCancel();
-      exit();
-      return;
-    }
-
-    if (key.return) {
-      const session = filteredSessions[selectedIndex];
-      if (session) {
-        setIsExiting(true);
-        onSelect(session.sessionId);
-        exit();
-      }
-      return;
-    }
-
-    if (key.upArrow || input === 'k') {
-      setSelectedIndex((prev) => Math.max(0, prev - 1));
-      return;
-    }
-
-    if (key.downArrow || input === 'j') {
-      if (filteredSessions.length === 0) {
-        return;
-      }
-      setSelectedIndex((prev) =>
-        Math.min(filteredSessions.length - 1, prev + 1),
-      );
-      return;
-    }
-
-    if (input === 'b' || input === 'B') {
-      if (currentBranch) {
-        setFilterByBranch((prev) => !prev);
-      }
-      return;
-    }
-  });
-
-  // Filtered sessions may have changed, ensure selectedIndex is valid
-  useEffect(() => {
-    if (
-      selectedIndex >= filteredSessions.length &&
-      filteredSessions.length > 0
-    ) {
-      setSelectedIndex(filteredSessions.length - 1);
-    }
-  }, [filteredSessions.length, selectedIndex]);
-
-  // Calculate content width (terminal width minus border padding)
-  const contentWidth = terminalSize.width - 4;
-  const promptMaxWidth = contentWidth - 4; // Account for "› " prefix
-
-  // Return empty while exiting to prevent visual glitches
-  if (isExiting) {
-    return <Box />;
-  }
-
-  return (
-    <Box
-      flexDirection="column"
-      width={terminalSize.width}
-      height={terminalSize.height - 1}
-      overflow="hidden"
-    >
-      {/* Main container with single border */}
-      <Box
-        flexDirection="column"
-        borderStyle="round"
-        borderColor={theme.border.default}
-        width={terminalSize.width}
-        height={terminalSize.height - 1}
-        overflow="hidden"
-      >
-        {/* Header row */}
-        <Box paddingX={1}>
-          <Text bold color={theme.text.primary}>
-            Resume Session
-          </Text>
-        </Box>
-
-        {/* Separator line */}
-        <Box>
-          <Text color={theme.border.default}>
-            {'─'.repeat(terminalSize.width - 2)}
-          </Text>
-        </Box>
-
-        {/* Session list with auto-scrolling */}
-        <Box flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
-          {filteredSessions.length === 0 ? (
-            <Box paddingY={1} justifyContent="center">
-              <Text color={theme.text.secondary}>
-                {filterByBranch
-                  ? `No sessions found for branch "${currentBranch}"`
-                  : 'No sessions found'}
-              </Text>
-            </Box>
-          ) : (
-            visibleSessions.map((session, visibleIndex) => {
-              const actualIndex = scrollOffset + visibleIndex;
-              const isSelected = actualIndex === selectedIndex;
-              const isFirst = visibleIndex === 0;
-              const isLast = visibleIndex === visibleSessions.length - 1;
-              const timeAgo = formatRelativeTime(session.mtime);
-              const messageText =
-                session.messageCount === 1
-                  ? '1 message'
-                  : `${session.messageCount} messages`;
-
-              // Show scroll indicator on first/last visible items
-              const showUpIndicator = isFirst && showScrollUp;
-              const showDownIndicator = isLast && showScrollDown;
-
-              // Determine the prefix: selector takes priority over scroll indicator
-              const prefix = isSelected
-                ? '› '
-                : showUpIndicator
-                  ? '↑ '
-                  : showDownIndicator
-                    ? '↓ '
-                    : '  ';
-
-              return (
-                <Box
-                  key={session.sessionId}
-                  flexDirection="column"
-                  marginBottom={isLast ? 0 : 1}
-                >
-                  {/* First line: prefix (selector or scroll indicator) + prompt text */}
-                  <Box>
-                    <Text
-                      color={
-                        isSelected
-                          ? theme.text.accent
-                          : showUpIndicator || showDownIndicator
-                            ? theme.text.secondary
-                            : undefined
-                      }
-                    >
-                      {prefix}
-                    </Text>
-                    <Text
-                      bold={isSelected}
-                      color={
-                        isSelected ? theme.text.accent : theme.text.primary
-                      }
-                    >
-                      {truncateText(
-                        session.prompt || '(empty prompt)',
-                        promptMaxWidth,
-                      )}
-                    </Text>
-                  </Box>
-
-                  {/* Second line: metadata (aligned with prompt text) */}
-                  <Box>
-                    <Text>{'  '}</Text>
-                    <Text color={theme.text.secondary}>
-                      {timeAgo} · {messageText}
-                      {session.gitBranch && ` · ${session.gitBranch}`}
-                    </Text>
-                  </Box>
-                </Box>
-              );
-            })
-          )}
-        </Box>
-
-        {/* Separator line */}
-        <Box>
-          <Text color={theme.border.default}>
-            {'─'.repeat(terminalSize.width - 2)}
-          </Text>
-        </Box>
-
-        {/* Footer with keyboard shortcuts */}
-        <Box paddingX={1}>
-          <Text color={theme.text.secondary}>
-            {currentBranch && (
-              <>
-                <Text
-                  bold={filterByBranch}
-                  color={filterByBranch ? theme.text.accent : undefined}
-                >
-                  B
-                </Text>
-                {' to toggle branch · '}
-              </>
-            )}
-            {'↑↓ to navigate · Esc to cancel'}
-          </Text>
-        </Box>
-      </Box>
-    </Box>
-  );
-}
-
-/**
- * Clears the terminal screen.
- */
-function clearScreen(): void {
-  // Move cursor to home position and clear screen
-  process.stdout.write('\x1b[2J\x1b[H');
-}
-
-/**
- * Shows an interactive session picker and returns the selected session ID.
- * Returns undefined if the user cancels or no sessions are available.
- */
-export async function showResumeSessionPicker(
-  cwd: string = process.cwd(),
-): Promise<string | undefined> {
-  const sessionService = new SessionService(cwd);
-  const hasSession = await sessionService.loadLastSession();
-  if (!hasSession) {
-    console.log('No sessions found. Start a new session with `qwen`.');
-    return undefined;
-  }
-
-  const currentBranch = getGitBranch(cwd);
-
-  // Clear the screen before showing the picker for a clean fullscreen experience
-  clearScreen();
-
-  // Enable raw mode for keyboard input if not already enabled
-  const wasRaw = process.stdin.isRaw;
-  if (process.stdin.isTTY && !wasRaw) {
-    process.stdin.setRawMode(true);
-  }
-
-  return new Promise<string | undefined>((resolve) => {
-    let selectedId: string | undefined;
-
-    const { unmount, waitUntilExit } = render(
-      <SessionPicker
-        sessionService={sessionService}
-        currentBranch={currentBranch}
-        onSelect={(id) => {
-          selectedId = id;
-        }}
-        onCancel={() => {
-          selectedId = undefined;
-        }}
-      />,
-      {
-        exitOnCtrlC: false,
-      },
-    );
-
-    waitUntilExit().then(() => {
-      unmount();
-
-      // Clear the screen after the picker closes for a clean fullscreen experience
-      clearScreen();
-
-      // Restore raw mode state only if we changed it and user cancelled
-      // (if user selected a session, main app will handle raw mode)
-      if (process.stdin.isTTY && !wasRaw && !selectedId) {
-        process.stdin.setRawMode(false);
-      }
-
-      resolve(selectedId);
-    });
-  });
-}

packages/cli/src/ui/components/SessionPicker.tsx

@@ -0,0 +1,251 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Text } from 'ink';
+import type {
+  SessionListItem as SessionData,
+  SessionService,
+} from '@qwen-code/qwen-code-core';
+import { theme } from '../semantic-colors.js';
+import { useSessionPicker } from '../hooks/useSessionPicker.js';
+import { formatRelativeTime } from '../utils/formatters.js';
+import {
+  formatMessageCount,
+  truncateText,
+} from '../utils/sessionPickerUtils.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { t } from '../../i18n/index.js';
+
+export interface SessionPickerProps {
+  sessionService: SessionService | null;
+  onSelect: (sessionId: string) => void;
+  onCancel: () => void;
+  currentBranch?: string;
+
+  /**
+   * Scroll mode. When true, keep selection centered (fullscreen-style).
+   * Defaults to true so dialog + standalone behave identically.
+   */
+  centerSelection?: boolean;
+}
+
+const PREFIX_CHARS = {
+  selected: '› ',
+  scrollUp: '↑ ',
+  scrollDown: '↓ ',
+  normal: '  ',
+};
+
+interface SessionListItemViewProps {
+  session: SessionData;
+  isSelected: boolean;
+  isFirst: boolean;
+  isLast: boolean;
+  showScrollUp: boolean;
+  showScrollDown: boolean;
+  maxPromptWidth: number;
+  prefixChars?: {
+    selected: string;
+    scrollUp: string;
+    scrollDown: string;
+    normal: string;
+  };
+  boldSelectedPrefix?: boolean;
+}
+
+function SessionListItemView({
+  session,
+  isSelected,
+  isFirst,
+  isLast,
+  showScrollUp,
+  showScrollDown,
+  maxPromptWidth,
+  prefixChars = PREFIX_CHARS,
+  boldSelectedPrefix = true,
+}: SessionListItemViewProps): React.JSX.Element {
+  const timeAgo = formatRelativeTime(session.mtime);
+  const messageText = formatMessageCount(session.messageCount);
+
+  const showUpIndicator = isFirst && showScrollUp;
+  const showDownIndicator = isLast && showScrollDown;
+
+  const prefix = isSelected
+    ? prefixChars.selected
+    : showUpIndicator
+      ? prefixChars.scrollUp
+      : showDownIndicator
+        ? prefixChars.scrollDown
+        : prefixChars.normal;
+
+  const promptText = session.prompt || '(empty prompt)';
+  const truncatedPrompt = truncateText(promptText, maxPromptWidth);
+
+  return (
+    <Box flexDirection="column" marginBottom={isLast ? 0 : 1}>
+      <Box>
+        <Text
+          color={
+            isSelected
+              ? theme.text.accent
+              : showUpIndicator || showDownIndicator
+                ? theme.text.secondary
+                : undefined
+          }
+          bold={isSelected && boldSelectedPrefix}
+        >
+          {prefix}
+        </Text>
+        <Text
+          color={isSelected ? theme.text.accent : theme.text.primary}
+          bold={isSelected}
+        >
+          {truncatedPrompt}
+        </Text>
+      </Box>
+      <Box paddingLeft={2}>
+        <Text color={theme.text.secondary}>
+          {timeAgo} · {messageText}
+          {session.gitBranch && ` · ${session.gitBranch}`}
+        </Text>
+      </Box>
+    </Box>
+  );
+}
+
+export function SessionPicker(props: SessionPickerProps) {
+  const {
+    sessionService,
+    onSelect,
+    onCancel,
+    currentBranch,
+    centerSelection = true,
+  } = props;
+
+  const { columns: width, rows: height } = useTerminalSize();
+
+  // Calculate box width (width + 6 for border padding)
+  const boxWidth = width + 6;
+  // Calculate visible items (same heuristic as before)
+  // Reserved space: header (1), footer (1), separators (2), borders (2)
+  const reservedLines = 6;
+  // Each item takes 2 lines (prompt + metadata) + 1 line margin between items
+  const itemHeight = 3;
+  const maxVisibleItems = Math.max(
+    1,
+    Math.floor((height - reservedLines) / itemHeight),
+  );
+
+  const picker = useSessionPicker({
+    sessionService,
+    currentBranch,
+    onSelect,
+    onCancel,
+    maxVisibleItems,
+    centerSelection,
+    isActive: true,
+  });
+
+  return (
+    <Box
+      flexDirection="column"
+      width={boxWidth}
+      height={height - 1}
+      overflow="hidden"
+    >
+      <Box
+        flexDirection="column"
+        borderStyle="round"
+        borderColor={theme.border.default}
+        width={boxWidth}
+        height={height - 1}
+        overflow="hidden"
+      >
+        {/* Header row */}
+        <Box paddingX={1}>
+          <Text bold color={theme.text.primary}>
+            {t('Resume Session')}
+          </Text>
+          {picker.filterByBranch && currentBranch && (
+            <Text color={theme.text.secondary}>
+              {' '}
+              {t('(branch: {{branch}})', { branch: currentBranch })}
+            </Text>
+          )}
+        </Box>
+
+        {/* Separator */}
+        <Box>
+          <Text color={theme.border.default}>{'─'.repeat(width - 2)}</Text>
+        </Box>
+
+        {/* Session list */}
+        <Box flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
+          {!sessionService || picker.isLoading ? (
+            <Box paddingY={1} justifyContent="center">
+              <Text color={theme.text.secondary}>
+                {t('Loading sessions...')}
+              </Text>
+            </Box>
+          ) : picker.filteredSessions.length === 0 ? (
+            <Box paddingY={1} justifyContent="center">
+              <Text color={theme.text.secondary}>
+                {picker.filterByBranch
+                  ? t('No sessions found for branch "{{branch}}"', {
+                      branch: currentBranch ?? '',
+                    })
+                  : t('No sessions found')}
+              </Text>
+            </Box>
+          ) : (
+            picker.visibleSessions.map((session, visibleIndex) => {
+              const actualIndex = picker.scrollOffset + visibleIndex;
+              return (
+                <SessionListItemView
+                  key={session.sessionId}
+                  session={session}
+                  isSelected={actualIndex === picker.selectedIndex}
+                  isFirst={visibleIndex === 0}
+                  isLast={visibleIndex === picker.visibleSessions.length - 1}
+                  showScrollUp={picker.showScrollUp}
+                  showScrollDown={picker.showScrollDown}
+                  maxPromptWidth={width}
+                  prefixChars={PREFIX_CHARS}
+                  boldSelectedPrefix={false}
+                />
+              );
+            })
+          )}
+        </Box>
+
+        {/* Separator */}
+        <Box>
+          <Text color={theme.border.default}>{'─'.repeat(width - 2)}</Text>
+        </Box>
+
+        {/* Footer */}
+        <Box paddingX={1}>
+          <Box flexDirection="row">
+            {currentBranch && (
+              <Text color={theme.text.secondary}>
+                <Text
+                  bold={picker.filterByBranch}
+                  color={picker.filterByBranch ? theme.text.accent : undefined}
+                >
+                  B
+                </Text>
+                {t(' to toggle branch')} ·
+              </Text>
+            )}
+            <Text color={theme.text.secondary}>
+              {t('↑↓ to navigate · Esc to cancel')}
+            </Text>
+          </Box>
+        </Box>
+      </Box>
+    </Box>
+  );
+}

packages/cli/src/ui/components/StandaloneSessionPicker.test.tsx

@@ -0,0 +1,624 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { KeypressProvider } from '../contexts/KeypressContext.js';
+import { SessionPicker } from './SessionPicker.js';
+import type {
+  SessionListItem,
+  ListSessionsResult,
+} from '@qwen-code/qwen-code-core';
+
+vi.mock('@qwen-code/qwen-code-core', async () => {
+  const actual = await vi.importActual('@qwen-code/qwen-code-core');
+  return {
+    ...actual,
+    getGitBranch: vi.fn().mockReturnValue('main'),
+  };
+});
+
+// Mock terminal size
+const mockTerminalSize = { columns: 80, rows: 24 };
+
+beforeEach(() => {
+  Object.defineProperty(process.stdout, 'columns', {
+    value: mockTerminalSize.columns,
+    configurable: true,
+  });
+  Object.defineProperty(process.stdout, 'rows', {
+    value: mockTerminalSize.rows,
+    configurable: true,
+  });
+});
+
+// Helper to create mock sessions
+function createMockSession(
+  overrides: Partial<SessionListItem> = {},
+): SessionListItem {
+  return {
+    sessionId: 'test-session-id',
+    cwd: '/test/path',
+    startTime: '2025-01-01T00:00:00.000Z',
+    mtime: Date.now(),
+    prompt: 'Test prompt',
+    gitBranch: 'main',
+    filePath: '/test/path/sessions/test-session-id.jsonl',
+    messageCount: 5,
+    ...overrides,
+  };
+}
+
+// Helper to create mock session service
+function createMockSessionService(
+  sessions: SessionListItem[] = [],
+  hasMore = false,
+) {
+  return {
+    listSessions: vi.fn().mockResolvedValue({
+      items: sessions,
+      hasMore,
+      nextCursor: hasMore ? Date.now() : undefined,
+    } as ListSessionsResult),
+    loadSession: vi.fn(),
+    loadLastSession: vi
+      .fn()
+      .mockResolvedValue(sessions.length > 0 ? {} : undefined),
+  };
+}
+
+describe('SessionPicker', () => {
+  const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Empty Sessions', () => {
+    it('should show sessions with 0 messages', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 'empty-1',
+          messageCount: 0,
+          prompt: '',
+        }),
+        createMockSession({
+          sessionId: 'with-messages',
+          messageCount: 5,
+          prompt: 'Hello',
+        }),
+        createMockSession({
+          sessionId: 'empty-2',
+          messageCount: 0,
+          prompt: '(empty prompt)',
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('Hello');
+      // Should show empty sessions too (rendered as "(empty prompt)" + "0 messages")
+      expect(output).toContain('0 messages');
+    });
+
+    it('should show sessions even when all sessions are empty', async () => {
+      const sessions = [
+        createMockSession({ sessionId: 'empty-1', messageCount: 0 }),
+        createMockSession({ sessionId: 'empty-2', messageCount: 0 }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('0 messages');
+    });
+
+    it('should show sessions with 1 or more messages', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 'one-msg',
+          messageCount: 1,
+          prompt: 'Single message',
+        }),
+        createMockSession({
+          sessionId: 'many-msg',
+          messageCount: 10,
+          prompt: 'Many messages',
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('Single message');
+      expect(output).toContain('Many messages');
+      expect(output).toContain('1 message');
+      expect(output).toContain('10 messages');
+    });
+  });
+
+  describe('Branch Filtering', () => {
+    it('should filter by branch when B is pressed', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 's1',
+          gitBranch: 'main',
+          prompt: 'Main branch',
+          messageCount: 1,
+        }),
+        createMockSession({
+          sessionId: 's2',
+          gitBranch: 'feature',
+          prompt: 'Feature branch',
+          messageCount: 1,
+        }),
+        createMockSession({
+          sessionId: 's3',
+          gitBranch: 'main',
+          prompt: 'Also main',
+          messageCount: 1,
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame, stdin } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+            currentBranch="main"
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // All sessions should be visible initially
+      let output = lastFrame();
+      expect(output).toContain('Main branch');
+      expect(output).toContain('Feature branch');
+
+      // Press B to filter by branch
+      stdin.write('B');
+      await wait(50);
+
+      output = lastFrame();
+      // Only main branch sessions should be visible
+      expect(output).toContain('Main branch');
+      expect(output).toContain('Also main');
+      expect(output).not.toContain('Feature branch');
+    });
+
+    it('should combine empty session filter with branch filter', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 's1',
+          gitBranch: 'main',
+          messageCount: 0,
+          prompt: 'Empty main',
+        }),
+        createMockSession({
+          sessionId: 's2',
+          gitBranch: 'main',
+          messageCount: 5,
+          prompt: 'Valid main',
+        }),
+        createMockSession({
+          sessionId: 's3',
+          gitBranch: 'feature',
+          messageCount: 5,
+          prompt: 'Valid feature',
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame, stdin } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+            currentBranch="main"
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // Press B to filter by branch
+      stdin.write('B');
+      await wait(50);
+
+      const output = lastFrame();
+      // Should only show sessions from main branch (including 0-message sessions)
+      expect(output).toContain('Valid main');
+      expect(output).toContain('Empty main');
+      expect(output).not.toContain('Valid feature');
+    });
+  });
+
+  describe('Keyboard Navigation', () => {
+    it('should navigate with arrow keys', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 's1',
+          prompt: 'First session',
+          messageCount: 1,
+        }),
+        createMockSession({
+          sessionId: 's2',
+          prompt: 'Second session',
+          messageCount: 1,
+        }),
+        createMockSession({
+          sessionId: 's3',
+          prompt: 'Third session',
+          messageCount: 1,
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame, stdin } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // First session should be selected initially (indicated by >)
+      let output = lastFrame();
+      expect(output).toContain('First session');
+
+      // Navigate down
+      stdin.write('\u001B[B'); // Down arrow
+      await wait(50);
+
+      output = lastFrame();
+      // Selection indicator should move
+      expect(output).toBeDefined();
+    });
+
+    it('should navigate with vim keys (j/k)', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 's1',
+          prompt: 'First',
+          messageCount: 1,
+        }),
+        createMockSession({
+          sessionId: 's2',
+          prompt: 'Second',
+          messageCount: 1,
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { stdin, unmount } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // Navigate with j (down)
+      stdin.write('j');
+      await wait(50);
+
+      // Navigate with k (up)
+      stdin.write('k');
+      await wait(50);
+
+      unmount();
+    });
+
+    it('should select session on Enter', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 'selected-session',
+          prompt: 'Select me',
+          messageCount: 1,
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { stdin } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // Press Enter to select
+      stdin.write('\r');
+      await wait(50);
+
+      expect(onSelect).toHaveBeenCalledWith('selected-session');
+    });
+
+    it('should cancel on Escape', async () => {
+      const sessions = [
+        createMockSession({ sessionId: 's1', messageCount: 1 }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { stdin } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      // Press Escape to cancel
+      stdin.write('\u001B');
+      await wait(50);
+
+      expect(onCancel).toHaveBeenCalled();
+      expect(onSelect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Display', () => {
+    it('should show session metadata', async () => {
+      const sessions = [
+        createMockSession({
+          sessionId: 's1',
+          prompt: 'Test prompt text',
+          messageCount: 5,
+          gitBranch: 'feature-branch',
+        }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('Test prompt text');
+      expect(output).toContain('5 messages');
+      expect(output).toContain('feature-branch');
+    });
+
+    it('should show header and footer', async () => {
+      const sessions = [createMockSession({ messageCount: 1 })];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('Resume Session');
+      expect(output).toContain('↑↓ to navigate');
+      expect(output).toContain('Esc to cancel');
+    });
+
+    it('should show branch toggle hint when currentBranch is provided', async () => {
+      const sessions = [createMockSession({ messageCount: 1 })];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+            currentBranch="main"
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('B');
+      expect(output).toContain('toggle branch');
+    });
+
+    it('should truncate long prompts', async () => {
+      const longPrompt = 'A'.repeat(300);
+      const sessions = [
+        createMockSession({ prompt: longPrompt, messageCount: 1 }),
+      ];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      // Should contain ellipsis for truncated text
+      expect(output).toContain('...');
+      // Should NOT contain the full untruncated prompt (300 A's in a row)
+      expect(output).not.toContain(longPrompt);
+    });
+
+    it('should show "(empty prompt)" for sessions without prompt text', async () => {
+      const sessions = [createMockSession({ prompt: '', messageCount: 1 })];
+      const mockService = createMockSessionService(sessions);
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { lastFrame } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(100);
+
+      const output = lastFrame();
+      expect(output).toContain('(empty prompt)');
+    });
+  });
+
+  describe('Pagination', () => {
+    it('should load more sessions when scrolling to bottom', async () => {
+      const firstPage = Array.from({ length: 5 }, (_, i) =>
+        createMockSession({
+          sessionId: `session-${i}`,
+          prompt: `Session ${i}`,
+          messageCount: 1,
+          mtime: Date.now() - i * 1000,
+        }),
+      );
+      const secondPage = Array.from({ length: 3 }, (_, i) =>
+        createMockSession({
+          sessionId: `session-${i + 5}`,
+          prompt: `Session ${i + 5}`,
+          messageCount: 1,
+          mtime: Date.now() - (i + 5) * 1000,
+        }),
+      );
+
+      const mockService = {
+        listSessions: vi
+          .fn()
+          .mockResolvedValueOnce({
+            items: firstPage,
+            hasMore: true,
+            nextCursor: Date.now() - 5000,
+          })
+          .mockResolvedValueOnce({
+            items: secondPage,
+            hasMore: false,
+            nextCursor: undefined,
+          }),
+        loadSession: vi.fn(),
+        loadLastSession: vi.fn().mockResolvedValue({}),
+      };
+
+      const onSelect = vi.fn();
+      const onCancel = vi.fn();
+
+      const { unmount } = render(
+        <KeypressProvider kittyProtocolEnabled={false}>
+          <SessionPicker
+            sessionService={mockService as never}
+            onSelect={onSelect}
+            onCancel={onCancel}
+          />
+        </KeypressProvider>,
+      );
+
+      await wait(200);
+
+      // First page should be loaded
+      expect(mockService.listSessions).toHaveBeenCalled();
+
+      unmount();
+    });
+  });
+});

packages/cli/src/ui/components/StandaloneSessionPicker.tsx

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState } from 'react';
+import { render, Box, useApp } from 'ink';
+import { getGitBranch, SessionService } from '@qwen-code/qwen-code-core';
+import { KeypressProvider } from '../contexts/KeypressContext.js';
+import { SessionPicker } from './SessionPicker.js';
+
+interface StandalonePickerScreenProps {
+  sessionService: SessionService;
+  onSelect: (sessionId: string) => void;
+  onCancel: () => void;
+  currentBranch?: string;
+}
+
+function StandalonePickerScreen({
+  sessionService,
+  onSelect,
+  onCancel,
+  currentBranch,
+}: StandalonePickerScreenProps): React.JSX.Element {
+  const { exit } = useApp();
+  const [isExiting, setIsExiting] = useState(false);
+  const handleExit = () => {
+    setIsExiting(true);
+    exit();
+  };
+
+  // Return empty while exiting to prevent visual glitches
+  if (isExiting) {
+    return <Box />;
+  }
+
+  return (
+    <SessionPicker
+      sessionService={sessionService}
+      onSelect={(id) => {
+        onSelect(id);
+        handleExit();
+      }}
+      onCancel={() => {
+        onCancel();
+        handleExit();
+      }}
+      currentBranch={currentBranch}
+      centerSelection={true}
+    />
+  );
+}
+
+/**
+ * Clears the terminal screen.
+ */
+function clearScreen(): void {
+  // Move cursor to home position and clear screen
+  process.stdout.write('\x1b[2J\x1b[H');
+}
+
+/**
+ * Shows an interactive session picker and returns the selected session ID.
+ * Returns undefined if the user cancels or no sessions are available.
+ */
+export async function showResumeSessionPicker(
+  cwd: string = process.cwd(),
+): Promise<string | undefined> {
+  const sessionService = new SessionService(cwd);
+  const hasSession = await sessionService.loadLastSession();
+  if (!hasSession) {
+    console.log('No sessions found. Start a new session with `qwen`.');
+    return undefined;
+  }
+
+  // Clear the screen before showing the picker for a clean fullscreen experience
+  clearScreen();
+
+  // Enable raw mode for keyboard input if not already enabled
+  const wasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY && !wasRaw) {
+    process.stdin.setRawMode(true);
+  }
+
+  return new Promise<string | undefined>((resolve) => {
+    let selectedId: string | undefined;
+
+    const { unmount, waitUntilExit } = render(
+      <KeypressProvider kittyProtocolEnabled={false}>
+        <StandalonePickerScreen
+          sessionService={sessionService}
+          onSelect={(id) => {
+            selectedId = id;
+          }}
+          onCancel={() => {
+            selectedId = undefined;
+          }}
+          currentBranch={getGitBranch(cwd)}
+        />
+      </KeypressProvider>,
+      {
+        exitOnCtrlC: false,
+      },
+    );
+
+    waitUntilExit().then(() => {
+      unmount();
+
+      // Clear the screen after the picker closes for a clean fullscreen experience
+      clearScreen();
+
+      // Restore raw mode state only if we changed it and user cancelled
+      // (if user selected a session, main app will handle raw mode)
+      if (process.stdin.isTTY && !wasRaw && !selectedId) {
+        process.stdin.setRawMode(false);
+      }
+
+      resolve(selectedId);
+    });
+  });
+}

packages/cli/src/ui/contexts/UIActionsContext.tsx

@@ -55,7 +55,6 @@ export interface UIActions {
   handleClearScreen: () => void;
   onWorkspaceMigrationDialogOpen: () => void;
   onWorkspaceMigrationDialogClose: () => void;
-  handleProQuotaChoice: (choice: 'auth' | 'continue') => void;
   // Vision switch dialog
   handleVisionSwitchSelect: (outcome: VisionSwitchOutcome) => void;
   // Welcome back dialog
@@ -64,6 +63,10 @@ export interface UIActions {
   // Subagent dialogs
   closeSubagentCreateDialog: () => void;
   closeAgentsManagerDialog: () => void;
+  // Resume session dialog
+  openResumeDialog: () => void;
+  closeResumeDialog: () => void;
+  handleResume: (sessionId: string) => void;
 }
 
 export const UIActionsContext = createContext<UIActions | null>(null);

packages/cli/src/ui/contexts/UIStateContext.tsx

@@ -22,21 +22,13 @@ import type {
   AuthType,
   IdeContext,
   ApprovalMode,
-  UserTierId,
   IdeInfo,
-  FallbackIntent,
 } from '@qwen-code/qwen-code-core';
 import type { DOMElement } from 'ink';
 import type { SessionStatsState } from '../contexts/SessionContext.js';
 import type { ExtensionUpdateState } from '../state/extensions.js';
 import type { UpdateObject } from '../utils/updateCheck.js';
 
-export interface ProQuotaDialogRequest {
-  failedModel: string;
-  fallbackModel: string;
-  resolve: (intent: FallbackIntent) => void;
-}
-
 import { type UseHistoryManagerReturn } from '../hooks/useHistoryManager.js';
 import { type RestartReason } from '../hooks/useIdeTrustListener.js';
 
@@ -60,6 +52,7 @@ export interface UIState {
   isModelDialogOpen: boolean;
   isPermissionsDialogOpen: boolean;
   isApprovalModeDialogOpen: boolean;
+  isResumeDialogOpen: boolean;
   slashCommands: readonly SlashCommand[];
   pendingSlashCommandHistoryItems: HistoryItemWithoutId[];
   commandContext: CommandContext;
@@ -98,8 +91,6 @@ export interface UIState {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   workspaceExtensions: any[]; // Extension[]
   // Quota-related state
-  userTier: UserTierId | undefined;
-  proQuotaRequest: ProQuotaDialogRequest | null;
   currentModel: string;
   contextFileNames: string[];
   errorCount: number;

packages/cli/src/ui/hooks/slashCommandProcessor.ts

@@ -56,6 +56,7 @@ const SLASH_COMMANDS_SKIP_RECORDING = new Set([
   'clear',
   'reset',
   'new',
+  'resume',
 ]);
 
 interface SlashCommandProcessorActions {
@@ -66,6 +67,7 @@ interface SlashCommandProcessorActions {
   openModelDialog: () => void;
   openPermissionsDialog: () => void;
   openApprovalModeDialog: () => void;
+  openResumeDialog: () => void;
   quit: (messages: HistoryItem[]) => void;
   setDebugMessage: (message: string) => void;
   dispatchExtensionStateUpdate: (action: ExtensionUpdateAction) => void;
@@ -417,6 +419,9 @@ export const useSlashCommandProcessor = (
                     case 'approval-mode':
                       actions.openApprovalModeDialog();
                       return { type: 'handled' };
+                    case 'resume':
+                      actions.openResumeDialog();
+                      return { type: 'handled' };
                     case 'help':
                       return { type: 'handled' };
                     default: {

packages/cli/src/ui/hooks/useGeminiStream.test.tsx

@@ -1323,7 +1323,7 @@ describe('useGeminiStream', () => {
     it('should call parseAndFormatApiError with the correct authType on stream initialization failure', async () => {
       // 1. Setup
       const mockError = new Error('Rate limit exceeded');
-      const mockAuthType = AuthType.LOGIN_WITH_GOOGLE;
+      const mockAuthType = AuthType.USE_VERTEX_AI;
       mockParseAndFormatApiError.mockClear();
       mockSendMessageStream.mockReturnValue(
         (async function* () {
@@ -1374,9 +1374,6 @@ describe('useGeminiStream', () => {
         expect(mockParseAndFormatApiError).toHaveBeenCalledWith(
           'Rate limit exceeded',
           mockAuthType,
-          undefined,
-          'gemini-2.5-pro',
-          'gemini-2.5-flash',
         );
       });
     });
@@ -2493,9 +2490,6 @@ describe('useGeminiStream', () => {
       expect(mockParseAndFormatApiError).toHaveBeenCalledWith(
         { message: 'Test error' },
         expect.any(String),
-        undefined,
-        'gemini-2.5-pro',
-        'gemini-2.5-flash',
       );
     });
   });

packages/cli/src/ui/hooks/useGeminiStream.ts

@@ -26,7 +26,6 @@ import {
   GitService,
   UnauthorizedError,
   UserPromptEvent,
-  DEFAULT_GEMINI_FLASH_MODEL,
   logConversationFinishedEvent,
   ConversationFinishedEvent,
   ApprovalMode,
@@ -600,9 +599,6 @@ export const useGeminiStream = (
           text: parseAndFormatApiError(
             eventValue.error,
             config.getContentGeneratorConfig()?.authType,
-            undefined,
-            config.getModel(),
-            DEFAULT_GEMINI_FLASH_MODEL,
           ),
         },
         userMessageTimestamp,
@@ -654,6 +650,9 @@ export const useGeminiStream = (
           'Response stopped due to image safety violations.',
         [FinishReason.UNEXPECTED_TOOL_CALL]:
           'Response stopped due to unexpected tool call.',
+        [FinishReason.IMAGE_PROHIBITED_CONTENT]:
+          'Response stopped due to image prohibited content.',
+        [FinishReason.NO_IMAGE]: 'Response stopped due to no image.',
       };
 
       const message = finishReasonMessages[finishReason];
@@ -770,11 +769,17 @@ export const useGeminiStream = (
       for await (const event of stream) {
         switch (event.type) {
           case ServerGeminiEventType.Thought:
-            thoughtBuffer = handleThoughtEvent(
-              event.value,
-              thoughtBuffer,
-              userMessageTimestamp,
-            );
+            // If the thought has a subject, it's a discrete status update rather than
+            // a streamed textual thought, so we update the thought state directly.
+            if (event.value.subject) {
+              setThought(event.value);
+            } else {
+              thoughtBuffer = handleThoughtEvent(
+                event.value,
+                thoughtBuffer,
+                userMessageTimestamp,
+              );
+            }
             break;
           case ServerGeminiEventType.Content:
             geminiMessageBuffer = handleContentEvent(
@@ -845,6 +850,7 @@ export const useGeminiStream = (
       handleMaxSessionTurnsEvent,
       handleSessionTokenLimitExceededEvent,
       handleCitationEvent,
+      setThought,
     ],
   );
 
@@ -987,9 +993,6 @@ export const useGeminiStream = (
                 text: parseAndFormatApiError(
                   getErrorMessage(error) || 'Unknown error',
                   config.getContentGeneratorConfig()?.authType,
-                  undefined,
-                  config.getModel(),
-                  DEFAULT_GEMINI_FLASH_MODEL,
                 ),
               },
               userMessageTimestamp,

packages/cli/src/ui/hooks/useQuotaAndFallback.test.ts

@@ -1,391 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  vi,
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  type Mock,
-} from 'vitest';
-import { act, renderHook } from '@testing-library/react';
-import {
-  type Config,
-  type FallbackModelHandler,
-  UserTierId,
-  AuthType,
-  isGenericQuotaExceededError,
-  isProQuotaExceededError,
-  makeFakeConfig,
-} from '@qwen-code/qwen-code-core';
-import { useQuotaAndFallback } from './useQuotaAndFallback.js';
-import type { UseHistoryManagerReturn } from './useHistoryManager.js';
-import { AuthState, MessageType } from '../types.js';
-
-// Mock the error checking functions from the core package to control test scenarios
-vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
-  const original =
-    await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
-  return {
-    ...original,
-    isGenericQuotaExceededError: vi.fn(),
-    isProQuotaExceededError: vi.fn(),
-  };
-});
-
-// Use a type alias for SpyInstance as it's not directly exported
-type SpyInstance = ReturnType<typeof vi.spyOn>;
-
-describe('useQuotaAndFallback', () => {
-  let mockConfig: Config;
-  let mockHistoryManager: UseHistoryManagerReturn;
-  let mockSetAuthState: Mock;
-  let mockSetModelSwitchedFromQuotaError: Mock;
-  let setFallbackHandlerSpy: SpyInstance;
-
-  const mockedIsGenericQuotaExceededError = isGenericQuotaExceededError as Mock;
-  const mockedIsProQuotaExceededError = isProQuotaExceededError as Mock;
-
-  beforeEach(() => {
-    mockConfig = makeFakeConfig();
-
-    // Spy on the method that requires the private field and mock its return.
-    // This is cleaner than modifying the config class for tests.
-    vi.spyOn(mockConfig, 'getContentGeneratorConfig').mockReturnValue({
-      model: 'test-model',
-      authType: AuthType.LOGIN_WITH_GOOGLE,
-    });
-
-    mockHistoryManager = {
-      addItem: vi.fn(),
-      history: [],
-      updateItem: vi.fn(),
-      clearItems: vi.fn(),
-      loadHistory: vi.fn(),
-    };
-    mockSetAuthState = vi.fn();
-    mockSetModelSwitchedFromQuotaError = vi.fn();
-
-    setFallbackHandlerSpy = vi.spyOn(mockConfig, 'setFallbackModelHandler');
-    vi.spyOn(mockConfig, 'setQuotaErrorOccurred');
-
-    mockedIsGenericQuotaExceededError.mockReturnValue(false);
-    mockedIsProQuotaExceededError.mockReturnValue(false);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should register a fallback handler on initialization', () => {
-    renderHook(() =>
-      useQuotaAndFallback({
-        config: mockConfig,
-        historyManager: mockHistoryManager,
-        userTier: UserTierId.FREE,
-        setAuthState: mockSetAuthState,
-        setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-      }),
-    );
-
-    expect(setFallbackHandlerSpy).toHaveBeenCalledTimes(1);
-    expect(setFallbackHandlerSpy.mock.calls[0][0]).toBeInstanceOf(Function);
-  });
-
-  describe('Fallback Handler Logic', () => {
-    // Helper function to render the hook and extract the registered handler
-    const getRegisteredHandler = (
-      userTier: UserTierId = UserTierId.FREE,
-    ): FallbackModelHandler => {
-      renderHook(
-        (props) =>
-          useQuotaAndFallback({
-            config: mockConfig,
-            historyManager: mockHistoryManager,
-            userTier: props.userTier,
-            setAuthState: mockSetAuthState,
-            setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-          }),
-        { initialProps: { userTier } },
-      );
-      return setFallbackHandlerSpy.mock.calls[0][0] as FallbackModelHandler;
-    };
-
-    it('should return null and take no action if already in fallback mode', async () => {
-      vi.spyOn(mockConfig, 'isInFallbackMode').mockReturnValue(true);
-      const handler = getRegisteredHandler();
-      const result = await handler('gemini-pro', 'gemini-flash', new Error());
-
-      expect(result).toBeNull();
-      expect(mockHistoryManager.addItem).not.toHaveBeenCalled();
-    });
-
-    it('should return null and take no action if authType is not LOGIN_WITH_GOOGLE', async () => {
-      // Override the default mock from beforeEach for this specific test
-      vi.spyOn(mockConfig, 'getContentGeneratorConfig').mockReturnValue({
-        model: 'test-model',
-        authType: AuthType.USE_GEMINI,
-      });
-
-      const handler = getRegisteredHandler();
-      const result = await handler('gemini-pro', 'gemini-flash', new Error());
-
-      expect(result).toBeNull();
-      expect(mockHistoryManager.addItem).not.toHaveBeenCalled();
-    });
-
-    describe('Automatic Fallback Scenarios', () => {
-      const testCases = [
-        {
-          errorType: 'generic',
-          tier: UserTierId.FREE,
-          expectedMessageSnippets: [
-            'Automatically switching from model-A to model-B',
-            'upgrade to a Gemini Code Assist Standard or Enterprise plan',
-          ],
-        },
-        {
-          errorType: 'generic',
-          tier: UserTierId.STANDARD, // Paid tier
-          expectedMessageSnippets: [
-            'Automatically switching from model-A to model-B',
-            'switch to using a paid API key from AI Studio',
-          ],
-        },
-        {
-          errorType: 'other',
-          tier: UserTierId.FREE,
-          expectedMessageSnippets: [
-            'Automatically switching from model-A to model-B for faster responses',
-            'upgrade to a Gemini Code Assist Standard or Enterprise plan',
-          ],
-        },
-        {
-          errorType: 'other',
-          tier: UserTierId.LEGACY, // Paid tier
-          expectedMessageSnippets: [
-            'Automatically switching from model-A to model-B for faster responses',
-            'switch to using a paid API key from AI Studio',
-          ],
-        },
-      ];
-
-      for (const { errorType, tier, expectedMessageSnippets } of testCases) {
-        it(`should handle ${errorType} error for ${tier} tier correctly`, async () => {
-          mockedIsGenericQuotaExceededError.mockReturnValue(
-            errorType === 'generic',
-          );
-
-          const handler = getRegisteredHandler(tier);
-          const result = await handler(
-            'model-A',
-            'model-B',
-            new Error('quota exceeded'),
-          );
-
-          // Automatic fallbacks should return 'stop'
-          expect(result).toBe('stop');
-
-          expect(mockHistoryManager.addItem).toHaveBeenCalledWith(
-            expect.objectContaining({ type: MessageType.INFO }),
-            expect.any(Number),
-          );
-
-          const message = (mockHistoryManager.addItem as Mock).mock.calls[0][0]
-            .text;
-          for (const snippet of expectedMessageSnippets) {
-            expect(message).toContain(snippet);
-          }
-
-          expect(mockSetModelSwitchedFromQuotaError).toHaveBeenCalledWith(true);
-          expect(mockConfig.setQuotaErrorOccurred).toHaveBeenCalledWith(true);
-        });
-      }
-    });
-
-    describe('Interactive Fallback (Pro Quota Error)', () => {
-      beforeEach(() => {
-        mockedIsProQuotaExceededError.mockReturnValue(true);
-      });
-
-      it('should set an interactive request and wait for user choice', async () => {
-        const { result } = renderHook(() =>
-          useQuotaAndFallback({
-            config: mockConfig,
-            historyManager: mockHistoryManager,
-            userTier: UserTierId.FREE,
-            setAuthState: mockSetAuthState,
-            setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-          }),
-        );
-
-        const handler = setFallbackHandlerSpy.mock
-          .calls[0][0] as FallbackModelHandler;
-
-        // Call the handler but do not await it, to check the intermediate state
-        const promise = handler(
-          'gemini-pro',
-          'gemini-flash',
-          new Error('pro quota'),
-        );
-
-        await act(async () => {});
-
-        // The hook should now have a pending request for the UI to handle
-        expect(result.current.proQuotaRequest).not.toBeNull();
-        expect(result.current.proQuotaRequest?.failedModel).toBe('gemini-pro');
-
-        // Simulate the user choosing to continue with the fallback model
-        act(() => {
-          result.current.handleProQuotaChoice('continue');
-        });
-
-        // The original promise from the handler should now resolve
-        const intent = await promise;
-        expect(intent).toBe('retry');
-
-        // The pending request should be cleared from the state
-        expect(result.current.proQuotaRequest).toBeNull();
-      });
-
-      it('should handle race conditions by stopping subsequent requests', async () => {
-        const { result } = renderHook(() =>
-          useQuotaAndFallback({
-            config: mockConfig,
-            historyManager: mockHistoryManager,
-            userTier: UserTierId.FREE,
-            setAuthState: mockSetAuthState,
-            setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-          }),
-        );
-
-        const handler = setFallbackHandlerSpy.mock
-          .calls[0][0] as FallbackModelHandler;
-
-        const promise1 = handler(
-          'gemini-pro',
-          'gemini-flash',
-          new Error('pro quota 1'),
-        );
-        await act(async () => {});
-
-        const firstRequest = result.current.proQuotaRequest;
-        expect(firstRequest).not.toBeNull();
-
-        const result2 = await handler(
-          'gemini-pro',
-          'gemini-flash',
-          new Error('pro quota 2'),
-        );
-
-        // The lock should have stopped the second request
-        expect(result2).toBe('stop');
-        expect(result.current.proQuotaRequest).toBe(firstRequest);
-
-        act(() => {
-          result.current.handleProQuotaChoice('continue');
-        });
-
-        const intent1 = await promise1;
-        expect(intent1).toBe('retry');
-        expect(result.current.proQuotaRequest).toBeNull();
-      });
-    });
-  });
-
-  describe('handleProQuotaChoice', () => {
-    beforeEach(() => {
-      mockedIsProQuotaExceededError.mockReturnValue(true);
-    });
-
-    it('should do nothing if there is no pending pro quota request', () => {
-      const { result } = renderHook(() =>
-        useQuotaAndFallback({
-          config: mockConfig,
-          historyManager: mockHistoryManager,
-          userTier: UserTierId.FREE,
-          setAuthState: mockSetAuthState,
-          setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-        }),
-      );
-
-      act(() => {
-        result.current.handleProQuotaChoice('auth');
-      });
-
-      expect(mockSetAuthState).not.toHaveBeenCalled();
-      expect(mockHistoryManager.addItem).not.toHaveBeenCalled();
-    });
-
-    it('should resolve intent to "auth" and trigger auth state update', async () => {
-      const { result } = renderHook(() =>
-        useQuotaAndFallback({
-          config: mockConfig,
-          historyManager: mockHistoryManager,
-          userTier: UserTierId.FREE,
-          setAuthState: mockSetAuthState,
-          setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-        }),
-      );
-
-      const handler = setFallbackHandlerSpy.mock
-        .calls[0][0] as FallbackModelHandler;
-      const promise = handler(
-        'gemini-pro',
-        'gemini-flash',
-        new Error('pro quota'),
-      );
-      await act(async () => {}); // Allow state to update
-
-      act(() => {
-        result.current.handleProQuotaChoice('auth');
-      });
-
-      const intent = await promise;
-      expect(intent).toBe('auth');
-      expect(mockSetAuthState).toHaveBeenCalledWith(AuthState.Updating);
-      expect(result.current.proQuotaRequest).toBeNull();
-    });
-
-    it('should resolve intent to "retry" and add info message on continue', async () => {
-      const { result } = renderHook(() =>
-        useQuotaAndFallback({
-          config: mockConfig,
-          historyManager: mockHistoryManager,
-          userTier: UserTierId.FREE,
-          setAuthState: mockSetAuthState,
-          setModelSwitchedFromQuotaError: mockSetModelSwitchedFromQuotaError,
-        }),
-      );
-
-      const handler = setFallbackHandlerSpy.mock
-        .calls[0][0] as FallbackModelHandler;
-      // The first `addItem` call is for the initial quota error message
-      const promise = handler(
-        'gemini-pro',
-        'gemini-flash',
-        new Error('pro quota'),
-      );
-      await act(async () => {}); // Allow state to update
-
-      act(() => {
-        result.current.handleProQuotaChoice('continue');
-      });
-
-      const intent = await promise;
-      expect(intent).toBe('retry');
-      expect(result.current.proQuotaRequest).toBeNull();
-
-      // Check for the second "Switched to fallback model" message
-      expect(mockHistoryManager.addItem).toHaveBeenCalledTimes(2);
-      const lastCall = (mockHistoryManager.addItem as Mock).mock.calls[1][0];
-      expect(lastCall.type).toBe(MessageType.INFO);
-      expect(lastCall.text).toContain('Switched to fallback model.');
-    });
-  });
-});

packages/cli/src/ui/hooks/useQuotaAndFallback.ts

@@ -1,175 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  AuthType,
-  type Config,
-  type FallbackModelHandler,
-  type FallbackIntent,
-  isGenericQuotaExceededError,
-  isProQuotaExceededError,
-  UserTierId,
-} from '@qwen-code/qwen-code-core';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { type UseHistoryManagerReturn } from './useHistoryManager.js';
-import { AuthState, MessageType } from '../types.js';
-import { type ProQuotaDialogRequest } from '../contexts/UIStateContext.js';
-
-interface UseQuotaAndFallbackArgs {
-  config: Config;
-  historyManager: UseHistoryManagerReturn;
-  userTier: UserTierId | undefined;
-  setAuthState: (state: AuthState) => void;
-  setModelSwitchedFromQuotaError: (value: boolean) => void;
-}
-
-export function useQuotaAndFallback({
-  config,
-  historyManager,
-  userTier,
-  setAuthState,
-  setModelSwitchedFromQuotaError,
-}: UseQuotaAndFallbackArgs) {
-  const [proQuotaRequest, setProQuotaRequest] =
-    useState<ProQuotaDialogRequest | null>(null);
-  const isDialogPending = useRef(false);
-
-  // Set up Flash fallback handler
-  useEffect(() => {
-    const fallbackHandler: FallbackModelHandler = async (
-      failedModel,
-      fallbackModel,
-      error,
-    ): Promise<FallbackIntent | null> => {
-      if (config.isInFallbackMode()) {
-        return null;
-      }
-
-      // Fallbacks are currently only handled for OAuth users.
-      const contentGeneratorConfig = config.getContentGeneratorConfig();
-      if (
-        !contentGeneratorConfig ||
-        contentGeneratorConfig.authType !== AuthType.LOGIN_WITH_GOOGLE
-      ) {
-        return null;
-      }
-
-      // Use actual user tier if available; otherwise, default to FREE tier behavior (safe default)
-      const isPaidTier =
-        userTier === UserTierId.LEGACY || userTier === UserTierId.STANDARD;
-
-      let message: string;
-
-      if (error && isProQuotaExceededError(error)) {
-        // Pro Quota specific messages (Interactive)
-        if (isPaidTier) {
-          message = `⚡ You have reached your daily ${failedModel} quota limit.
-⚡ You can choose to authenticate with a paid API key or continue with the fallback model.
-⚡ To continue accessing the ${failedModel} model today, consider using /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
-        } else {
-          message = `⚡ You have reached your daily ${failedModel} quota limit.
-⚡ You can choose to authenticate with a paid API key or continue with the fallback model.
-⚡ To increase your limits, upgrade to a Gemini Code Assist Standard or Enterprise plan with higher limits at https://goo.gle/set-up-gemini-code-assist
-⚡ Or you can utilize a Gemini API Key. See: https://goo.gle/gemini-cli-docs-auth#gemini-api-key
-⚡ You can switch authentication methods by typing /auth`;
-        }
-      } else if (error && isGenericQuotaExceededError(error)) {
-        // Generic Quota (Automatic fallback)
-        const actionMessage = `⚡ You have reached your daily quota limit.\n⚡ Automatically switching from ${failedModel} to ${fallbackModel} for the remainder of this session.`;
-
-        if (isPaidTier) {
-          message = `${actionMessage}
-⚡ To continue accessing the ${failedModel} model today, consider using /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
-        } else {
-          message = `${actionMessage}
-⚡ To increase your limits, upgrade to a Gemini Code Assist Standard or Enterprise plan with higher limits at https://goo.gle/set-up-gemini-code-assist
-⚡ Or you can utilize a Gemini API Key. See: https://goo.gle/gemini-cli-docs-auth#gemini-api-key
-⚡ You can switch authentication methods by typing /auth`;
-        }
-      } else {
-        // Consecutive 429s or other errors (Automatic fallback)
-        const actionMessage = `⚡ Automatically switching from ${failedModel} to ${fallbackModel} for faster responses for the remainder of this session.`;
-
-        if (isPaidTier) {
-          message = `${actionMessage}
-⚡ Possible reasons for this are that you have received multiple consecutive capacity errors or you have reached your daily ${failedModel} quota limit
-⚡ To continue accessing the ${failedModel} model today, consider using /auth to switch to using a paid API key from AI Studio at https://aistudio.google.com/apikey`;
-        } else {
-          message = `${actionMessage}
-⚡ Possible reasons for this are that you have received multiple consecutive capacity errors or you have reached your daily ${failedModel} quota limit
-⚡ To increase your limits, upgrade to a Gemini Code Assist Standard or Enterprise plan with higher limits at https://goo.gle/set-up-gemini-code-assist
-⚡ Or you can utilize a Gemini API Key. See: https://goo.gle/gemini-cli-docs-auth#gemini-api-key
-⚡ You can switch authentication methods by typing /auth`;
-        }
-      }
-
-      // Add message to UI history
-      historyManager.addItem(
-        {
-          type: MessageType.INFO,
-          text: message,
-        },
-        Date.now(),
-      );
-
-      setModelSwitchedFromQuotaError(true);
-      config.setQuotaErrorOccurred(true);
-
-      // Interactive Fallback for Pro quota
-      if (error && isProQuotaExceededError(error)) {
-        if (isDialogPending.current) {
-          return 'stop'; // A dialog is already active, so just stop this request.
-        }
-        isDialogPending.current = true;
-
-        const intent: FallbackIntent = await new Promise<FallbackIntent>(
-          (resolve) => {
-            setProQuotaRequest({
-              failedModel,
-              fallbackModel,
-              resolve,
-            });
-          },
-        );
-
-        return intent;
-      }
-
-      return 'stop';
-    };
-
-    config.setFallbackModelHandler(fallbackHandler);
-  }, [config, historyManager, userTier, setModelSwitchedFromQuotaError]);
-
-  const handleProQuotaChoice = useCallback(
-    (choice: 'auth' | 'continue') => {
-      if (!proQuotaRequest) return;
-
-      const intent: FallbackIntent = choice === 'auth' ? 'auth' : 'retry';
-      proQuotaRequest.resolve(intent);
-      setProQuotaRequest(null);
-      isDialogPending.current = false; // Reset the flag here
-
-      if (choice === 'auth') {
-        setAuthState(AuthState.Updating);
-      } else {
-        historyManager.addItem(
-          {
-            type: MessageType.INFO,
-            text: 'Switched to fallback model. Tip: Press Ctrl+P (or Up Arrow) to recall your previous prompt and submit it again if you wish.',
-          },
-          Date.now(),
-        );
-      }
-    },
-    [proQuotaRequest, setAuthState, historyManager],
-  );
-
-  return {
-    proQuotaRequest,
-    handleProQuotaChoice,
-  };
-}

packages/cli/src/ui/hooks/useQwenAuth.test.ts

@@ -411,7 +411,7 @@ describe('useQwenAuth', () => {
     expect(geminiResult.current.qwenAuthState.authStatus).toBe('idle');
 
     const { result: oauthResult } = renderHook(() =>
-      useQwenAuth(AuthType.LOGIN_WITH_GOOGLE, true),
+      useQwenAuth(AuthType.USE_OPENAI, true),
     );
     expect(oauthResult.current.qwenAuthState.authStatus).toBe('idle');
   });

packages/cli/src/ui/hooks/useResumeCommand.test.ts

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { act, renderHook } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { useResumeCommand } from './useResumeCommand.js';
+
+const resumeMocks = vi.hoisted(() => {
+  let resolveLoadSession:
+    | ((value: { conversation: unknown } | undefined) => void)
+    | undefined;
+  let pendingLoadSession:
+    | Promise<{ conversation: unknown } | undefined>
+    | undefined;
+
+  return {
+    createPendingLoadSession() {
+      pendingLoadSession = new Promise((resolve) => {
+        resolveLoadSession = resolve;
+      });
+      return pendingLoadSession;
+    },
+    resolvePendingLoadSession(value: { conversation: unknown } | undefined) {
+      resolveLoadSession?.(value);
+    },
+    getPendingLoadSession() {
+      return pendingLoadSession;
+    },
+    reset() {
+      resolveLoadSession = undefined;
+      pendingLoadSession = undefined;
+    },
+  };
+});
+
+vi.mock('../utils/resumeHistoryUtils.js', () => ({
+  buildResumedHistoryItems: vi.fn(() => [{ id: 1, type: 'user', text: 'hi' }]),
+}));
+
+vi.mock('@qwen-code/qwen-code-core', () => {
+  class SessionService {
+    constructor(_cwd: string) {}
+    async loadSession(_sessionId: string) {
+      return (
+        resumeMocks.getPendingLoadSession() ??
+        Promise.resolve({
+          conversation: [{ role: 'user', parts: [{ text: 'hello' }] }],
+        })
+      );
+    }
+  }
+
+  return {
+    SessionService,
+  };
+});
+
+describe('useResumeCommand', () => {
+  it('should initialize with dialog closed', () => {
+    const { result } = renderHook(() => useResumeCommand());
+
+    expect(result.current.isResumeDialogOpen).toBe(false);
+  });
+
+  it('should open the dialog when openResumeDialog is called', () => {
+    const { result } = renderHook(() => useResumeCommand());
+
+    act(() => {
+      result.current.openResumeDialog();
+    });
+
+    expect(result.current.isResumeDialogOpen).toBe(true);
+  });
+
+  it('should close the dialog when closeResumeDialog is called', () => {
+    const { result } = renderHook(() => useResumeCommand());
+
+    // Open the dialog first
+    act(() => {
+      result.current.openResumeDialog();
+    });
+
+    expect(result.current.isResumeDialogOpen).toBe(true);
+
+    // Close the dialog
+    act(() => {
+      result.current.closeResumeDialog();
+    });
+
+    expect(result.current.isResumeDialogOpen).toBe(false);
+  });
+
+  it('should maintain stable function references across renders', () => {
+    const { result, rerender } = renderHook(() => useResumeCommand());
+
+    const initialOpenFn = result.current.openResumeDialog;
+    const initialCloseFn = result.current.closeResumeDialog;
+    const initialHandleResume = result.current.handleResume;
+
+    rerender();
+
+    expect(result.current.openResumeDialog).toBe(initialOpenFn);
+    expect(result.current.closeResumeDialog).toBe(initialCloseFn);
+    expect(result.current.handleResume).toBe(initialHandleResume);
+  });
+
+  it('handleResume no-ops when config is null', async () => {
+    const historyManager = { clearItems: vi.fn(), loadHistory: vi.fn() };
+    const startNewSession = vi.fn();
+
+    const { result } = renderHook(() =>
+      useResumeCommand({
+        config: null,
+        historyManager,
+        startNewSession,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.handleResume('session-1');
+    });
+
+    expect(startNewSession).not.toHaveBeenCalled();
+    expect(historyManager.clearItems).not.toHaveBeenCalled();
+    expect(historyManager.loadHistory).not.toHaveBeenCalled();
+  });
+
+  it('handleResume closes the dialog immediately and restores session state', async () => {
+    resumeMocks.reset();
+    resumeMocks.createPendingLoadSession();
+
+    const historyManager = { clearItems: vi.fn(), loadHistory: vi.fn() };
+    const startNewSession = vi.fn();
+    const geminiClient = {
+      initialize: vi.fn(),
+    };
+
+    const config = {
+      getTargetDir: () => '/tmp',
+      getGeminiClient: () => geminiClient,
+      startNewSession: vi.fn(),
+    } as unknown as import('@qwen-code/qwen-code-core').Config;
+
+    const { result } = renderHook(() =>
+      useResumeCommand({
+        config,
+        historyManager,
+        startNewSession,
+      }),
+    );
+
+    // Open first so we can verify the dialog closes immediately.
+    act(() => {
+      result.current.openResumeDialog();
+    });
+    expect(result.current.isResumeDialogOpen).toBe(true);
+
+    let resumePromise: Promise<void> | undefined;
+    act(() => {
+      // Start resume but do not await it yet — we want to assert the dialog
+      // closes immediately before the async session load completes.
+      resumePromise = result.current.handleResume('session-2') as unknown as
+        | Promise<void>
+        | undefined;
+    });
+    expect(result.current.isResumeDialogOpen).toBe(false);
+
+    // Now finish the async load and let the handler complete.
+    resumeMocks.resolvePendingLoadSession({
+      conversation: [{ role: 'user', parts: [{ text: 'hello' }] }],
+    });
+    await act(async () => {
+      await resumePromise;
+    });
+
+    expect(config.startNewSession).toHaveBeenCalledWith(
+      'session-2',
+      expect.objectContaining({
+        conversation: expect.anything(),
+      }),
+    );
+    expect(startNewSession).toHaveBeenCalledWith('session-2');
+    expect(geminiClient.initialize).toHaveBeenCalledTimes(1);
+    expect(historyManager.clearItems).toHaveBeenCalledTimes(1);
+    expect(historyManager.loadHistory).toHaveBeenCalledTimes(1);
+  });
+});

packages/cli/src/ui/hooks/useResumeCommand.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+import { SessionService, type Config } from '@qwen-code/qwen-code-core';
+import { buildResumedHistoryItems } from '../utils/resumeHistoryUtils.js';
+import type { UseHistoryManagerReturn } from './useHistoryManager.js';
+
+export interface UseResumeCommandOptions {
+  config: Config | null;
+  historyManager: Pick<UseHistoryManagerReturn, 'clearItems' | 'loadHistory'>;
+  startNewSession: (sessionId: string) => void;
+  remount?: () => void;
+}
+
+export interface UseResumeCommandResult {
+  isResumeDialogOpen: boolean;
+  openResumeDialog: () => void;
+  closeResumeDialog: () => void;
+  handleResume: (sessionId: string) => void;
+}
+
+export function useResumeCommand(
+  options?: UseResumeCommandOptions,
+): UseResumeCommandResult {
+  const [isResumeDialogOpen, setIsResumeDialogOpen] = useState(false);
+
+  const openResumeDialog = useCallback(() => {
+    setIsResumeDialogOpen(true);
+  }, []);
+
+  const closeResumeDialog = useCallback(() => {
+    setIsResumeDialogOpen(false);
+  }, []);
+
+  const { config, historyManager, startNewSession, remount } = options ?? {};
+
+  const handleResume = useCallback(
+    async (sessionId: string) => {
+      if (!config || !historyManager || !startNewSession) {
+        return;
+      }
+
+      // Close dialog immediately to prevent input capture during async operations.
+      closeResumeDialog();
+
+      const cwd = config.getTargetDir();
+      const sessionService = new SessionService(cwd);
+      const sessionData = await sessionService.loadSession(sessionId);
+
+      if (!sessionData) {
+        return;
+      }
+
+      // Start new session in UI context.
+      startNewSession(sessionId);
+
+      // Reset UI history.
+      const uiHistoryItems = buildResumedHistoryItems(sessionData, config);
+      historyManager.clearItems();
+      historyManager.loadHistory(uiHistoryItems);
+
+      // Update session history core.
+      config.startNewSession(sessionId, sessionData);
+      await config.getGeminiClient()?.initialize?.();
+
+      // Refresh terminal UI.
+      remount?.();
+    },
+    [closeResumeDialog, config, historyManager, startNewSession, remount],
+  );
+
+  return {
+    isResumeDialogOpen,
+    openResumeDialog,
+    closeResumeDialog,
+    handleResume,
+  };
+}

packages/cli/src/ui/hooks/useSessionPicker.ts

@@ -0,0 +1,279 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Unified session picker hook for both dialog and standalone modes.
+ *
+ * IMPORTANT:
+ * - Uses KeypressContext (`useKeypress`) so it behaves correctly inside the main app.
+ * - Standalone mode should wrap the picker in `<KeypressProvider>` when rendered
+ *   outside the main app.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import type {
+  ListSessionsResult,
+  SessionListItem,
+  SessionService,
+} from '@qwen-code/qwen-code-core';
+import {
+  filterSessions,
+  SESSION_PAGE_SIZE,
+  type SessionState,
+} from '../utils/sessionPickerUtils.js';
+import { useKeypress } from './useKeypress.js';
+
+export interface UseSessionPickerOptions {
+  sessionService: SessionService | null;
+  currentBranch?: string;
+  onSelect: (sessionId: string) => void;
+  onCancel: () => void;
+  maxVisibleItems: number;
+  /**
+   * If true, computes centered scroll offset (keeps selection near middle).
+   * If false, uses follow mode (scrolls when selection reaches edge).
+   */
+  centerSelection?: boolean;
+  /**
+   * Enable/disable input handling.
+   */
+  isActive?: boolean;
+}
+
+export interface UseSessionPickerResult {
+  selectedIndex: number;
+  sessionState: SessionState;
+  filteredSessions: SessionListItem[];
+  filterByBranch: boolean;
+  isLoading: boolean;
+  scrollOffset: number;
+  visibleSessions: SessionListItem[];
+  showScrollUp: boolean;
+  showScrollDown: boolean;
+  loadMoreSessions: () => Promise<void>;
+}
+
+export function useSessionPicker({
+  sessionService,
+  currentBranch,
+  onSelect,
+  onCancel,
+  maxVisibleItems,
+  centerSelection = false,
+  isActive = true,
+}: UseSessionPickerOptions): UseSessionPickerResult {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [sessionState, setSessionState] = useState<SessionState>({
+    sessions: [],
+    hasMore: true,
+    nextCursor: undefined,
+  });
+  const [filterByBranch, setFilterByBranch] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+
+  // For follow mode (non-centered)
+  const [followScrollOffset, setFollowScrollOffset] = useState(0);
+
+  const isLoadingMoreRef = useRef(false);
+
+  const filteredSessions = useMemo(
+    () => filterSessions(sessionState.sessions, filterByBranch, currentBranch),
+    [sessionState.sessions, filterByBranch, currentBranch],
+  );
+
+  const scrollOffset = useMemo(() => {
+    if (centerSelection) {
+      if (filteredSessions.length <= maxVisibleItems) {
+        return 0;
+      }
+      const halfVisible = Math.floor(maxVisibleItems / 2);
+      let offset = selectedIndex - halfVisible;
+      offset = Math.max(0, offset);
+      offset = Math.min(filteredSessions.length - maxVisibleItems, offset);
+      return offset;
+    }
+    return followScrollOffset;
+  }, [
+    centerSelection,
+    filteredSessions.length,
+    followScrollOffset,
+    maxVisibleItems,
+    selectedIndex,
+  ]);
+
+  const visibleSessions = useMemo(
+    () => filteredSessions.slice(scrollOffset, scrollOffset + maxVisibleItems),
+    [filteredSessions, maxVisibleItems, scrollOffset],
+  );
+  const showScrollUp = scrollOffset > 0;
+  const showScrollDown =
+    scrollOffset + maxVisibleItems < filteredSessions.length;
+
+  // Initial load
+  useEffect(() => {
+    if (!sessionService) {
+      return;
+    }
+
+    const loadInitialSessions = async () => {
+      try {
+        const result: ListSessionsResult = await sessionService.listSessions({
+          size: SESSION_PAGE_SIZE,
+        });
+        setSessionState({
+          sessions: result.items,
+          hasMore: result.hasMore,
+          nextCursor: result.nextCursor,
+        });
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void loadInitialSessions();
+  }, [sessionService]);
+
+  const loadMoreSessions = useCallback(async () => {
+    if (!sessionService || !sessionState.hasMore || isLoadingMoreRef.current) {
+      return;
+    }
+
+    isLoadingMoreRef.current = true;
+    try {
+      const result: ListSessionsResult = await sessionService.listSessions({
+        size: SESSION_PAGE_SIZE,
+        cursor: sessionState.nextCursor,
+      });
+      setSessionState((prev) => ({
+        sessions: [...prev.sessions, ...result.items],
+        hasMore: result.hasMore && result.nextCursor !== undefined,
+        nextCursor: result.nextCursor,
+      }));
+    } finally {
+      isLoadingMoreRef.current = false;
+    }
+  }, [sessionService, sessionState.hasMore, sessionState.nextCursor]);
+
+  // Reset selection when filter changes
+  useEffect(() => {
+    setSelectedIndex(0);
+    setFollowScrollOffset(0);
+  }, [filterByBranch]);
+
+  // Ensure selectedIndex is valid when filtered sessions change
+  useEffect(() => {
+    if (
+      selectedIndex >= filteredSessions.length &&
+      filteredSessions.length > 0
+    ) {
+      setSelectedIndex(filteredSessions.length - 1);
+    }
+  }, [filteredSessions.length, selectedIndex]);
+
+  // Auto-load more when centered mode hits the sentinel or list is empty.
+  useEffect(() => {
+    if (
+      isLoading ||
+      !sessionState.hasMore ||
+      isLoadingMoreRef.current ||
+      !centerSelection
+    ) {
+      return;
+    }
+
+    const sentinelVisible =
+      scrollOffset + maxVisibleItems >= filteredSessions.length;
+    const shouldLoadMore = filteredSessions.length === 0 || sentinelVisible;
+
+    if (shouldLoadMore) {
+      void loadMoreSessions();
+    }
+  }, [
+    centerSelection,
+    filteredSessions.length,
+    isLoading,
+    loadMoreSessions,
+    maxVisibleItems,
+    scrollOffset,
+    sessionState.hasMore,
+  ]);
+
+  // Key handling (KeypressContext)
+  useKeypress(
+    (key) => {
+      const { name, sequence, ctrl } = key;
+
+      if (name === 'escape' || (ctrl && name === 'c')) {
+        onCancel();
+        return;
+      }
+
+      if (name === 'return') {
+        const session = filteredSessions[selectedIndex];
+        if (session) {
+          onSelect(session.sessionId);
+        }
+        return;
+      }
+
+      if (name === 'up' || name === 'k') {
+        setSelectedIndex((prev) => {
+          const newIndex = Math.max(0, prev - 1);
+          if (!centerSelection && newIndex < followScrollOffset) {
+            setFollowScrollOffset(newIndex);
+          }
+          return newIndex;
+        });
+        return;
+      }
+
+      if (name === 'down' || name === 'j') {
+        if (filteredSessions.length === 0) {
+          return;
+        }
+
+        setSelectedIndex((prev) => {
+          const newIndex = Math.min(filteredSessions.length - 1, prev + 1);
+
+          if (
+            !centerSelection &&
+            newIndex >= followScrollOffset + maxVisibleItems
+          ) {
+            setFollowScrollOffset(newIndex - maxVisibleItems + 1);
+          }
+
+          // Follow mode: load more when near the end.
+          if (!centerSelection && newIndex >= filteredSessions.length - 3) {
+            void loadMoreSessions();
+          }
+
+          return newIndex;
+        });
+        return;
+      }
+
+      if (sequence === 'b' || sequence === 'B') {
+        if (currentBranch) {
+          setFilterByBranch((prev) => !prev);
+        }
+      }
+    },
+    { isActive },
+  );
+
+  return {
+    selectedIndex,
+    sessionState,
+    filteredSessions,
+    filterByBranch,
+    isLoading,
+    scrollOffset,
+    visibleSessions,
+    showScrollUp,
+    showScrollDown,
+    loadMoreSessions,
+  };
+}

packages/cli/src/ui/hooks/useToolScheduler.test.ts

@@ -62,7 +62,7 @@ const mockConfig = {
   getAllowedTools: vi.fn(() => []),
   getContentGeneratorConfig: () => ({
     model: 'test-model',
-    authType: 'oauth-personal',
+    authType: 'gemini-api-key',
   }),
   getUseSmartEdit: () => false,
   getUseModelRouter: () => false,

packages/cli/src/ui/utils/sessionPickerUtils.test.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { truncateText } from './sessionPickerUtils.js';
+
+describe('sessionPickerUtils', () => {
+  describe('truncateText', () => {
+    it('returns the original text when it fits and has no newline', () => {
+      expect(truncateText('hello', 10)).toBe('hello');
+    });
+
+    it('truncates long text with ellipsis', () => {
+      expect(truncateText('hello world', 5)).toBe('he...');
+    });
+
+    it('truncates without ellipsis when maxWidth <= 3', () => {
+      expect(truncateText('hello', 3)).toBe('hel');
+      expect(truncateText('hello', 2)).toBe('he');
+    });
+
+    it('breaks at newline and returns only the first line', () => {
+      expect(truncateText('hello\nworld', 20)).toBe('hello');
+      expect(truncateText('hello\r\nworld', 20)).toBe('hello');
+    });
+
+    it('breaks at newline and still truncates the first line when needed', () => {
+      expect(truncateText('hello\nworld', 2)).toBe('he');
+      expect(truncateText('hello\nworld', 3)).toBe('hel');
+      expect(truncateText('hello\nworld', 4)).toBe('h...');
+    });
+
+    it('does not add ellipsis when the string ends at a newline', () => {
+      expect(truncateText('hello\n', 20)).toBe('hello');
+      expect(truncateText('hello\r\n', 20)).toBe('hello');
+    });
+
+    it('returns only the first line even if there are multiple line breaks', () => {
+      expect(truncateText('hello\n\nworld', 20)).toBe('hello');
+    });
+  });
+});

packages/cli/src/ui/utils/sessionPickerUtils.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { SessionListItem } from '@qwen-code/qwen-code-core';
+
+/**
+ * State for managing loaded sessions in the session picker.
+ */
+export interface SessionState {
+  sessions: SessionListItem[];
+  hasMore: boolean;
+  nextCursor?: number;
+}
+
+/**
+ * Page size for loading sessions.
+ */
+export const SESSION_PAGE_SIZE = 20;
+
+/**
+ * Truncates text to fit within a given width, adding ellipsis if needed.
+ */
+export function truncateText(text: string, maxWidth: number): string {
+  const firstLine = text.split(/\r?\n/, 1)[0];
+  if (firstLine.length <= maxWidth) {
+    return firstLine;
+  }
+  if (maxWidth <= 3) {
+    return firstLine.slice(0, maxWidth);
+  }
+  return firstLine.slice(0, maxWidth - 3) + '...';
+}
+
+/**
+ * Filters sessions optionally by branch.
+ */
+export function filterSessions(
+  sessions: SessionListItem[],
+  filterByBranch: boolean,
+  currentBranch?: string,
+): SessionListItem[] {
+  return sessions.filter((session) => {
+    // Apply branch filter if enabled
+    if (filterByBranch && currentBranch) {
+      return session.gitBranch === currentBranch;
+    }
+    return true;
+  });
+}
+
+/**
+ * Formats message count for display with proper pluralization.
+ */
+export function formatMessageCount(count: number): string {
+  return count === 1 ? '1 message' : `${count} messages`;
+}

packages/cli/src/utils/gitUtils.test.ts

@@ -76,6 +76,105 @@ describe('getGitHubRepoInfo', async () => {
     );
     expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
   });
+
+  // Tests for credential formats
+
+  it('returns the owner and repo for URL with classic PAT token (ghp_)', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@github.com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('returns the owner and repo for URL with fine-grained PAT token (github_pat_)', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://github_pat_xxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@github.com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('returns the owner and repo for URL with username:password format', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://username:password@github.com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('returns the owner and repo for URL with OAuth token (oauth2:token)', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://oauth2:gho_xxxxxxxxxxxx@github.com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('returns the owner and repo for URL with GitHub Actions token (x-access-token)', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://x-access-token:ghs_xxxxxxxxxxxx@github.com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  // Tests for case insensitivity
+
+  it('returns the owner and repo for URL with uppercase GITHUB.COM', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://GITHUB.COM/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('returns the owner and repo for URL with mixed case GitHub.Com', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://GitHub.Com/owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  // Tests for SSH format
+
+  it('returns the owner and repo for SSH URL', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'git@github.com:owner/repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('throws for non-GitHub SSH URL', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'git@gitlab.com:owner/repo.git',
+    );
+    expect(() => {
+      getGitHubRepoInfo();
+    }).toThrowError(/Owner & repo could not be extracted from remote URL/);
+  });
+
+  // Tests for edge cases
+
+  it('returns the owner and repo for URL without .git suffix', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://github.com/owner/repo',
+    );
+    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
+  });
+
+  it('throws for non-GitHub HTTPS URL', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://gitlab.com/owner/repo.git',
+    );
+    expect(() => {
+      getGitHubRepoInfo();
+    }).toThrowError(/Owner & repo could not be extracted from remote URL/);
+  });
+
+  it('handles repo names containing .git substring', async () => {
+    vi.mocked(child_process.execSync).mockReturnValueOnce(
+      'https://github.com/owner/my.git.repo.git',
+    );
+    expect(getGitHubRepoInfo()).toEqual({
+      owner: 'owner',
+      repo: 'my.git.repo',
+    });
+  });
 });
 
 describe('getGitRepoRoot', async () => {

packages/cli/src/utils/gitUtils.ts

@@ -103,17 +103,38 @@ export function getGitHubRepoInfo(): { owner: string; repo: string } {
     encoding: 'utf-8',
   }).trim();
 
-  // Matches either https://github.com/owner/repo.git or git@github.com:owner/repo.git
-  const match = remoteUrl.match(
-    /(?:https?:\/\/|git@)github\.com(?::|\/)([^/]+)\/([^/]+?)(?:\.git)?$/,
-  );
-
-  // If the regex fails match, throw an error.
-  if (!match || !match[1] || !match[2]) {
+  // Handle SCP-style SSH URLs (git@github.com:owner/repo.git)
+  let urlToParse = remoteUrl;
+  if (remoteUrl.startsWith('git@github.com:')) {
+    urlToParse = remoteUrl.replace('git@github.com:', '');
+  } else if (remoteUrl.startsWith('git@')) {
+    // SSH URL for a different provider (GitLab, Bitbucket, etc.)
     throw new Error(
       `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
     );
   }
 
-  return { owner: match[1], repo: match[2] };
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(urlToParse, 'https://github.com');
+  } catch {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
+    );
+  }
+
+  if (parsedUrl.host !== 'github.com') {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
+    );
+  }
+
+  const parts = parsedUrl.pathname.split('/').filter((part) => part !== '');
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
+    );
+  }
+
+  return { owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
 }

packages/cli/src/utils/relaunch.test.ts

@@ -115,7 +115,7 @@ describe('relaunchAppInChildProcess', () => {
     vi.clearAllMocks();
 
     process.env = { ...originalEnv };
-    delete process.env['GEMINI_CLI_NO_RELAUNCH'];
+    delete process.env['QWEN_CODE_NO_RELAUNCH'];
 
     process.execArgv = [...originalExecArgv];
     process.argv = [...originalArgv];
@@ -145,9 +145,9 @@ describe('relaunchAppInChildProcess', () => {
     stdinResumeSpy.mockRestore();
   });
 
-  describe('when GEMINI_CLI_NO_RELAUNCH is set', () => {
+  describe('when QWEN_CODE_NO_RELAUNCH is set', () => {
     it('should return early without spawning a child process', async () => {
-      process.env['GEMINI_CLI_NO_RELAUNCH'] = 'true';
+      process.env['QWEN_CODE_NO_RELAUNCH'] = 'true';
 
       await relaunchAppInChildProcess(['--test'], ['--verbose']);
 
@@ -156,9 +156,9 @@ describe('relaunchAppInChildProcess', () => {
     });
   });
 
-  describe('when GEMINI_CLI_NO_RELAUNCH is not set', () => {
+  describe('when QWEN_CODE_NO_RELAUNCH is not set', () => {
     beforeEach(() => {
-      delete process.env['GEMINI_CLI_NO_RELAUNCH'];
+      delete process.env['QWEN_CODE_NO_RELAUNCH'];
     });
 
     it('should construct correct node arguments from execArgv, additionalNodeArgs, script, additionalScriptArgs, and argv', () => {

packages/cli/src/utils/relaunch.ts

@@ -27,7 +27,7 @@ export async function relaunchAppInChildProcess(
   additionalNodeArgs: string[],
   additionalScriptArgs: string[],
 ) {
-  if (process.env['GEMINI_CLI_NO_RELAUNCH']) {
+  if (process.env['QWEN_CODE_NO_RELAUNCH']) {
     return;
   }
 
@@ -44,7 +44,7 @@ export async function relaunchAppInChildProcess(
       ...additionalScriptArgs,
       ...scriptArgs,
     ];
-    const newEnv = { ...process.env, GEMINI_CLI_NO_RELAUNCH: 'true' };
+    const newEnv = { ...process.env, QWEN_CODE_NO_RELAUNCH: 'true' };
 
     // The parent process should not be reading from stdin while the child is running.
     process.stdin.pause();

packages/cli/src/validateNonInterActiveAuth.ts

@@ -21,6 +21,13 @@ function getAuthTypeFromEnv(): AuthType | undefined {
     return AuthType.QWEN_OAUTH;
   }
 
+  if (process.env['GEMINI_API_KEY']) {
+    return AuthType.USE_GEMINI;
+  }
+  if (process.env['GOOGLE_API_KEY']) {
+    return AuthType.USE_VERTEX_AI;
+  }
+
   return undefined;
 }
 

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/qwen-code-core",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Qwen Code Core",
   "repository": {
     "type": "git",
@@ -23,8 +23,8 @@
     "scripts/postinstall.js"
   ],
   "dependencies": {
-    "@google/genai": "1.16.0",
-    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@google/genai": "1.30.0",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "@opentelemetry/api": "^1.9.0",
     "async-mutex": "^0.5.0",
     "@opentelemetry/exporter-logs-otlp-grpc": "^0.203.0",
@@ -34,7 +34,6 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
     "@opentelemetry/instrumentation-http": "^0.203.0",
-    "@opentelemetry/resource-detector-gcp": "^0.40.0",
     "@opentelemetry/sdk-node": "^0.203.0",
     "@types/html-to-text": "^9.0.4",
     "@xterm/headless": "5.5.0",
@@ -48,7 +47,7 @@
     "fdir": "^6.4.6",
     "fzf": "^0.5.2",
     "glob": "^10.5.0",
-    "google-auth-library": "^9.11.0",
+    "google-auth-library": "^10.5.0",
     "html-to-text": "^9.0.5",
     "https-proxy-agent": "^7.0.6",
     "ignore": "^7.0.0",
@@ -63,7 +62,7 @@
     "simple-git": "^3.28.0",
     "strip-ansi": "^7.1.0",
     "tiktoken": "^1.0.21",
-    "undici": "^7.10.0",
+    "undici": "^6.22.0",
     "uuid": "^9.0.1",
     "ws": "^8.18.0"
   },

packages/core/src/code_assist/codeAssist.ts

@@ -1,54 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { ContentGenerator } from '../core/contentGenerator.js';
-import { AuthType } from '../core/contentGenerator.js';
-import { getOauthClient } from './oauth2.js';
-import { setupUser } from './setup.js';
-import type { HttpOptions } from './server.js';
-import { CodeAssistServer } from './server.js';
-import type { Config } from '../config/config.js';
-import { LoggingContentGenerator } from '../core/loggingContentGenerator.js';
-
-export async function createCodeAssistContentGenerator(
-  httpOptions: HttpOptions,
-  authType: AuthType,
-  config: Config,
-  sessionId?: string,
-): Promise<ContentGenerator> {
-  if (
-    authType === AuthType.LOGIN_WITH_GOOGLE ||
-    authType === AuthType.CLOUD_SHELL
-  ) {
-    const authClient = await getOauthClient(authType, config);
-    const userData = await setupUser(authClient);
-    return new CodeAssistServer(
-      authClient,
-      userData.projectId,
-      httpOptions,
-      sessionId,
-      userData.userTier,
-    );
-  }
-
-  throw new Error(`Unsupported authType: ${authType}`);
-}
-
-export function getCodeAssistServer(
-  config: Config,
-): CodeAssistServer | undefined {
-  let server = config.getContentGenerator();
-
-  // Unwrap LoggingContentGenerator if present
-  if (server instanceof LoggingContentGenerator) {
-    server = server.getWrapped();
-  }
-
-  if (!(server instanceof CodeAssistServer)) {
-    return undefined;
-  }
-  return server;
-}

packages/core/src/code_assist/converter.test.ts

@@ -1,456 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect } from 'vitest';
-import type { CaGenerateContentResponse } from './converter.js';
-import {
-  toGenerateContentRequest,
-  fromGenerateContentResponse,
-  toContents,
-} from './converter.js';
-import type {
-  ContentListUnion,
-  GenerateContentParameters,
-} from '@google/genai';
-import {
-  GenerateContentResponse,
-  FinishReason,
-  BlockedReason,
-  type Part,
-} from '@google/genai';
-
-describe('converter', () => {
-  describe('toCodeAssistRequest', () => {
-    it('should convert a simple request with project', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq).toEqual({
-        model: 'gemini-pro',
-        project: 'my-project',
-        request: {
-          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-          systemInstruction: undefined,
-          cachedContent: undefined,
-          tools: undefined,
-          toolConfig: undefined,
-          labels: undefined,
-          safetySettings: undefined,
-          generationConfig: undefined,
-          session_id: 'my-session',
-        },
-        user_prompt_id: 'my-prompt',
-      });
-    });
-
-    it('should convert a request without a project', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        undefined,
-        'my-session',
-      );
-      expect(codeAssistReq).toEqual({
-        model: 'gemini-pro',
-        project: undefined,
-        request: {
-          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-          systemInstruction: undefined,
-          cachedContent: undefined,
-          tools: undefined,
-          toolConfig: undefined,
-          labels: undefined,
-          safetySettings: undefined,
-          generationConfig: undefined,
-          session_id: 'my-session',
-        },
-        user_prompt_id: 'my-prompt',
-      });
-    });
-
-    it('should convert a request with sessionId', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'session-123',
-      );
-      expect(codeAssistReq).toEqual({
-        model: 'gemini-pro',
-        project: 'my-project',
-        request: {
-          contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
-          systemInstruction: undefined,
-          cachedContent: undefined,
-          tools: undefined,
-          toolConfig: undefined,
-          labels: undefined,
-          safetySettings: undefined,
-          generationConfig: undefined,
-          session_id: 'session-123',
-        },
-        user_prompt_id: 'my-prompt',
-      });
-    });
-
-    it('should handle string content', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: 'Hello',
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq.request.contents).toEqual([
-        { role: 'user', parts: [{ text: 'Hello' }] },
-      ]);
-    });
-
-    it('should handle Part[] content', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: [{ text: 'Hello' }, { text: 'World' }],
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq.request.contents).toEqual([
-        { role: 'user', parts: [{ text: 'Hello' }] },
-        { role: 'user', parts: [{ text: 'World' }] },
-      ]);
-    });
-
-    it('should handle system instructions', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: 'Hello',
-        config: {
-          systemInstruction: 'You are a helpful assistant.',
-        },
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq.request.systemInstruction).toEqual({
-        role: 'user',
-        parts: [{ text: 'You are a helpful assistant.' }],
-      });
-    });
-
-    it('should handle generation config', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: 'Hello',
-        config: {
-          temperature: 0.8,
-          topK: 40,
-        },
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq.request.generationConfig).toEqual({
-        temperature: 0.8,
-        topK: 40,
-      });
-    });
-
-    it('should handle all generation config fields', () => {
-      const genaiReq: GenerateContentParameters = {
-        model: 'gemini-pro',
-        contents: 'Hello',
-        config: {
-          temperature: 0.1,
-          topP: 0.2,
-          topK: 3,
-          candidateCount: 4,
-          maxOutputTokens: 5,
-          stopSequences: ['a'],
-          responseLogprobs: true,
-          logprobs: 6,
-          presencePenalty: 0.7,
-          frequencyPenalty: 0.8,
-          seed: 9,
-          responseMimeType: 'application/json',
-        },
-      };
-      const codeAssistReq = toGenerateContentRequest(
-        genaiReq,
-        'my-prompt',
-        'my-project',
-        'my-session',
-      );
-      expect(codeAssistReq.request.generationConfig).toEqual({
-        temperature: 0.1,
-        topP: 0.2,
-        topK: 3,
-        candidateCount: 4,
-        maxOutputTokens: 5,
-        stopSequences: ['a'],
-        responseLogprobs: true,
-        logprobs: 6,
-        presencePenalty: 0.7,
-        frequencyPenalty: 0.8,
-        seed: 9,
-        responseMimeType: 'application/json',
-      });
-    });
-  });
-
-  describe('fromCodeAssistResponse', () => {
-    it('should convert a simple response', () => {
-      const codeAssistRes: CaGenerateContentResponse = {
-        response: {
-          candidates: [
-            {
-              index: 0,
-              content: {
-                role: 'model',
-                parts: [{ text: 'Hi there!' }],
-              },
-              finishReason: FinishReason.STOP,
-              safetyRatings: [],
-            },
-          ],
-        },
-      };
-      const genaiRes = fromGenerateContentResponse(codeAssistRes);
-      expect(genaiRes).toBeInstanceOf(GenerateContentResponse);
-      expect(genaiRes.candidates).toEqual(codeAssistRes.response.candidates);
-    });
-
-    it('should handle prompt feedback and usage metadata', () => {
-      const codeAssistRes: CaGenerateContentResponse = {
-        response: {
-          candidates: [],
-          promptFeedback: {
-            blockReason: BlockedReason.SAFETY,
-            safetyRatings: [],
-          },
-          usageMetadata: {
-            promptTokenCount: 10,
-            candidatesTokenCount: 20,
-            totalTokenCount: 30,
-          },
-        },
-      };
-      const genaiRes = fromGenerateContentResponse(codeAssistRes);
-      expect(genaiRes.promptFeedback).toEqual(
-        codeAssistRes.response.promptFeedback,
-      );
-      expect(genaiRes.usageMetadata).toEqual(
-        codeAssistRes.response.usageMetadata,
-      );
-    });
-
-    it('should handle automatic function calling history', () => {
-      const codeAssistRes: CaGenerateContentResponse = {
-        response: {
-          candidates: [],
-          automaticFunctionCallingHistory: [
-            {
-              role: 'model',
-              parts: [
-                {
-                  functionCall: {
-                    name: 'test_function',
-                    args: {
-                      foo: 'bar',
-                    },
-                  },
-                },
-              ],
-            },
-          ],
-        },
-      };
-      const genaiRes = fromGenerateContentResponse(codeAssistRes);
-      expect(genaiRes.automaticFunctionCallingHistory).toEqual(
-        codeAssistRes.response.automaticFunctionCallingHistory,
-      );
-    });
-
-    it('should handle modelVersion', () => {
-      const codeAssistRes: CaGenerateContentResponse = {
-        response: {
-          candidates: [],
-          modelVersion: 'qwen3-coder-plus',
-        },
-      };
-      const genaiRes = fromGenerateContentResponse(codeAssistRes);
-      expect(genaiRes.modelVersion).toEqual('qwen3-coder-plus');
-    });
-  });
-
-  describe('toContents', () => {
-    it('should handle Content', () => {
-      const content: ContentListUnion = {
-        role: 'user',
-        parts: [{ text: 'hello' }],
-      };
-      expect(toContents(content)).toEqual([
-        { role: 'user', parts: [{ text: 'hello' }] },
-      ]);
-    });
-
-    it('should handle array of Contents', () => {
-      const contents: ContentListUnion = [
-        { role: 'user', parts: [{ text: 'hello' }] },
-        { role: 'model', parts: [{ text: 'hi' }] },
-      ];
-      expect(toContents(contents)).toEqual([
-        { role: 'user', parts: [{ text: 'hello' }] },
-        { role: 'model', parts: [{ text: 'hi' }] },
-      ]);
-    });
-
-    it('should handle Part', () => {
-      const part: ContentListUnion = { text: 'a part' };
-      expect(toContents(part)).toEqual([
-        { role: 'user', parts: [{ text: 'a part' }] },
-      ]);
-    });
-
-    it('should handle array of Parts', () => {
-      const parts = [{ text: 'part 1' }, 'part 2'];
-      expect(toContents(parts)).toEqual([
-        { role: 'user', parts: [{ text: 'part 1' }] },
-        { role: 'user', parts: [{ text: 'part 2' }] },
-      ]);
-    });
-
-    it('should handle string', () => {
-      const str: ContentListUnion = 'a string';
-      expect(toContents(str)).toEqual([
-        { role: 'user', parts: [{ text: 'a string' }] },
-      ]);
-    });
-
-    it('should handle array of strings', () => {
-      const strings: ContentListUnion = ['string 1', 'string 2'];
-      expect(toContents(strings)).toEqual([
-        { role: 'user', parts: [{ text: 'string 1' }] },
-        { role: 'user', parts: [{ text: 'string 2' }] },
-      ]);
-    });
-
-    it('should convert thought parts to text parts for API compatibility', () => {
-      const contentWithThought: ContentListUnion = {
-        role: 'model',
-        parts: [
-          { text: 'regular text' },
-          { thought: 'thinking about the problem' } as Part & {
-            thought: string;
-          },
-          { text: 'more text' },
-        ],
-      };
-      expect(toContents(contentWithThought)).toEqual([
-        {
-          role: 'model',
-          parts: [
-            { text: 'regular text' },
-            { text: '[Thought: thinking about the problem]' },
-            { text: 'more text' },
-          ],
-        },
-      ]);
-    });
-
-    it('should combine text and thought for text parts with thoughts', () => {
-      const contentWithTextAndThought: ContentListUnion = {
-        role: 'model',
-        parts: [
-          {
-            text: 'Here is my response',
-            thought: 'I need to be careful here',
-          } as Part & { thought: string },
-        ],
-      };
-      expect(toContents(contentWithTextAndThought)).toEqual([
-        {
-          role: 'model',
-          parts: [
-            {
-              text: 'Here is my response\n[Thought: I need to be careful here]',
-            },
-          ],
-        },
-      ]);
-    });
-
-    it('should preserve non-thought properties while removing thought', () => {
-      const contentWithComplexPart: ContentListUnion = {
-        role: 'model',
-        parts: [
-          {
-            functionCall: { name: 'calculate', args: { x: 5, y: 10 } },
-            thought: 'Performing calculation',
-          } as Part & { thought: string },
-        ],
-      };
-      expect(toContents(contentWithComplexPart)).toEqual([
-        {
-          role: 'model',
-          parts: [
-            {
-              functionCall: { name: 'calculate', args: { x: 5, y: 10 } },
-            },
-          ],
-        },
-      ]);
-    });
-
-    it('should convert invalid text content to valid text part with thought', () => {
-      const contentWithInvalidText: ContentListUnion = {
-        role: 'model',
-        parts: [
-          {
-            text: 123, // Invalid - should be string
-            thought: 'Processing number',
-          } as Part & { thought: string; text: number },
-        ],
-      };
-      expect(toContents(contentWithInvalidText)).toEqual([
-        {
-          role: 'model',
-          parts: [
-            {
-              text: '123\n[Thought: Processing number]',
-            },
-          ],
-        },
-      ]);
-    });
-  });
-});

packages/core/src/code_assist/converter.ts

@@ -1,285 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  Content,
-  ContentListUnion,
-  ContentUnion,
-  GenerateContentConfig,
-  GenerateContentParameters,
-  CountTokensParameters,
-  CountTokensResponse,
-  GenerationConfigRoutingConfig,
-  MediaResolution,
-  Candidate,
-  ModelSelectionConfig,
-  GenerateContentResponsePromptFeedback,
-  GenerateContentResponseUsageMetadata,
-  Part,
-  SafetySetting,
-  PartUnion,
-  SpeechConfigUnion,
-  ThinkingConfig,
-  ToolListUnion,
-  ToolConfig,
-} from '@google/genai';
-import { GenerateContentResponse } from '@google/genai';
-
-export interface CAGenerateContentRequest {
-  model: string;
-  project?: string;
-  user_prompt_id?: string;
-  request: VertexGenerateContentRequest;
-}
-
-interface VertexGenerateContentRequest {
-  contents: Content[];
-  systemInstruction?: Content;
-  cachedContent?: string;
-  tools?: ToolListUnion;
-  toolConfig?: ToolConfig;
-  labels?: Record<string, string>;
-  safetySettings?: SafetySetting[];
-  generationConfig?: VertexGenerationConfig;
-  session_id?: string;
-}
-
-interface VertexGenerationConfig {
-  temperature?: number;
-  topP?: number;
-  topK?: number;
-  candidateCount?: number;
-  maxOutputTokens?: number;
-  stopSequences?: string[];
-  responseLogprobs?: boolean;
-  logprobs?: number;
-  presencePenalty?: number;
-  frequencyPenalty?: number;
-  seed?: number;
-  responseMimeType?: string;
-  responseJsonSchema?: unknown;
-  responseSchema?: unknown;
-  routingConfig?: GenerationConfigRoutingConfig;
-  modelSelectionConfig?: ModelSelectionConfig;
-  responseModalities?: string[];
-  mediaResolution?: MediaResolution;
-  speechConfig?: SpeechConfigUnion;
-  audioTimestamp?: boolean;
-  thinkingConfig?: ThinkingConfig;
-}
-
-export interface CaGenerateContentResponse {
-  response: VertexGenerateContentResponse;
-}
-
-interface VertexGenerateContentResponse {
-  candidates: Candidate[];
-  automaticFunctionCallingHistory?: Content[];
-  promptFeedback?: GenerateContentResponsePromptFeedback;
-  usageMetadata?: GenerateContentResponseUsageMetadata;
-  modelVersion?: string;
-}
-
-export interface CaCountTokenRequest {
-  request: VertexCountTokenRequest;
-}
-
-interface VertexCountTokenRequest {
-  model: string;
-  contents: Content[];
-}
-
-export interface CaCountTokenResponse {
-  totalTokens: number;
-}
-
-export function toCountTokenRequest(
-  req: CountTokensParameters,
-): CaCountTokenRequest {
-  return {
-    request: {
-      model: 'models/' + req.model,
-      contents: toContents(req.contents),
-    },
-  };
-}
-
-export function fromCountTokenResponse(
-  res: CaCountTokenResponse,
-): CountTokensResponse {
-  return {
-    totalTokens: res.totalTokens,
-  };
-}
-
-export function toGenerateContentRequest(
-  req: GenerateContentParameters,
-  userPromptId: string,
-  project?: string,
-  sessionId?: string,
-): CAGenerateContentRequest {
-  return {
-    model: req.model,
-    project,
-    user_prompt_id: userPromptId,
-    request: toVertexGenerateContentRequest(req, sessionId),
-  };
-}
-
-export function fromGenerateContentResponse(
-  res: CaGenerateContentResponse,
-): GenerateContentResponse {
-  const inres = res.response;
-  const out = new GenerateContentResponse();
-  out.candidates = inres.candidates;
-  out.automaticFunctionCallingHistory = inres.automaticFunctionCallingHistory;
-  out.promptFeedback = inres.promptFeedback;
-  out.usageMetadata = inres.usageMetadata;
-  out.modelVersion = inres.modelVersion;
-  return out;
-}
-
-function toVertexGenerateContentRequest(
-  req: GenerateContentParameters,
-  sessionId?: string,
-): VertexGenerateContentRequest {
-  return {
-    contents: toContents(req.contents),
-    systemInstruction: maybeToContent(req.config?.systemInstruction),
-    cachedContent: req.config?.cachedContent,
-    tools: req.config?.tools,
-    toolConfig: req.config?.toolConfig,
-    labels: req.config?.labels,
-    safetySettings: req.config?.safetySettings,
-    generationConfig: toVertexGenerationConfig(req.config),
-    session_id: sessionId,
-  };
-}
-
-export function toContents(contents: ContentListUnion): Content[] {
-  if (Array.isArray(contents)) {
-    // it's a Content[] or a PartsUnion[]
-    return contents.map(toContent);
-  }
-  // it's a Content or a PartsUnion
-  return [toContent(contents)];
-}
-
-function maybeToContent(content?: ContentUnion): Content | undefined {
-  if (!content) {
-    return undefined;
-  }
-  return toContent(content);
-}
-
-function toContent(content: ContentUnion): Content {
-  if (Array.isArray(content)) {
-    // it's a PartsUnion[]
-    return {
-      role: 'user',
-      parts: toParts(content),
-    };
-  }
-  if (typeof content === 'string') {
-    // it's a string
-    return {
-      role: 'user',
-      parts: [{ text: content }],
-    };
-  }
-  if ('parts' in content) {
-    // it's a Content - process parts to handle thought filtering
-    return {
-      ...content,
-      parts: content.parts
-        ? toParts(content.parts.filter((p) => p != null))
-        : [],
-    };
-  }
-  // it's a Part
-  return {
-    role: 'user',
-    parts: [toPart(content as Part)],
-  };
-}
-
-export function toParts(parts: PartUnion[]): Part[] {
-  return parts.map(toPart);
-}
-
-function toPart(part: PartUnion): Part {
-  if (typeof part === 'string') {
-    // it's a string
-    return { text: part };
-  }
-
-  // Handle thought parts for CountToken API compatibility
-  // The CountToken API expects parts to have certain required "oneof" fields initialized,
-  // but thought parts don't conform to this schema and cause API failures
-  if ('thought' in part && part.thought) {
-    const thoughtText = `[Thought: ${part.thought}]`;
-
-    const newPart = { ...part };
-    delete (newPart as Record<string, unknown>)['thought'];
-
-    const hasApiContent =
-      'functionCall' in newPart ||
-      'functionResponse' in newPart ||
-      'inlineData' in newPart ||
-      'fileData' in newPart;
-
-    if (hasApiContent) {
-      // It's a functionCall or other non-text part. Just strip the thought.
-      return newPart;
-    }
-
-    // If no other valid API content, this must be a text part.
-    // Combine existing text (if any) with the thought, preserving other properties.
-    const text = (newPart as { text?: unknown }).text;
-    const existingText = text ? String(text) : '';
-    const combinedText = existingText
-      ? `${existingText}\n${thoughtText}`
-      : thoughtText;
-
-    return {
-      ...newPart,
-      text: combinedText,
-    };
-  }
-
-  return part;
-}
-
-function toVertexGenerationConfig(
-  config?: GenerateContentConfig,
-): VertexGenerationConfig | undefined {
-  if (!config) {
-    return undefined;
-  }
-  return {
-    temperature: config.temperature,
-    topP: config.topP,
-    topK: config.topK,
-    candidateCount: config.candidateCount,
-    maxOutputTokens: config.maxOutputTokens,
-    stopSequences: config.stopSequences,
-    responseLogprobs: config.responseLogprobs,
-    logprobs: config.logprobs,
-    presencePenalty: config.presencePenalty,
-    frequencyPenalty: config.frequencyPenalty,
-    seed: config.seed,
-    responseMimeType: config.responseMimeType,
-    responseSchema: config.responseSchema,
-    responseJsonSchema: config.responseJsonSchema,
-    routingConfig: config.routingConfig,
-    modelSelectionConfig: config.modelSelectionConfig,
-    responseModalities: config.responseModalities,
-    mediaResolution: config.mediaResolution,
-    speechConfig: config.speechConfig,
-    audioTimestamp: config.audioTimestamp,
-    thinkingConfig: config.thinkingConfig,
-  };
-}

packages/core/src/code_assist/oauth-credential-storage.test.ts

@@ -1,217 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { type Credentials } from 'google-auth-library';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { OAuthCredentialStorage } from './oauth-credential-storage.js';
-import type { OAuthCredentials } from '../mcp/token-storage/types.js';
-
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { promises as fs } from 'node:fs';
-
-// Mock external dependencies
-const mockHybridTokenStorage = vi.hoisted(() => ({
-  getCredentials: vi.fn(),
-  setCredentials: vi.fn(),
-  deleteCredentials: vi.fn(),
-}));
-vi.mock('../mcp/token-storage/hybrid-token-storage.js', () => ({
-  HybridTokenStorage: vi.fn(() => mockHybridTokenStorage),
-}));
-vi.mock('node:fs', () => ({
-  promises: {
-    readFile: vi.fn(),
-    rm: vi.fn(),
-  },
-}));
-vi.mock('node:os');
-vi.mock('node:path');
-
-describe('OAuthCredentialStorage', () => {
-  const mockCredentials: Credentials = {
-    access_token: 'mock_access_token',
-    refresh_token: 'mock_refresh_token',
-    expiry_date: Date.now() + 3600 * 1000,
-    token_type: 'Bearer',
-    scope: 'email profile',
-  };
-
-  const mockMcpCredentials: OAuthCredentials = {
-    serverName: 'main-account',
-    token: {
-      accessToken: 'mock_access_token',
-      refreshToken: 'mock_refresh_token',
-      tokenType: 'Bearer',
-      scope: 'email profile',
-      expiresAt: mockCredentials.expiry_date!,
-    },
-    updatedAt: expect.any(Number),
-  };
-
-  const oldFilePath = '/mock/home/.qwen/oauth.json';
-
-  beforeEach(() => {
-    vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockResolvedValue(null);
-    vi.spyOn(mockHybridTokenStorage, 'setCredentials').mockResolvedValue(
-      undefined,
-    );
-    vi.spyOn(mockHybridTokenStorage, 'deleteCredentials').mockResolvedValue(
-      undefined,
-    );
-
-    vi.spyOn(fs, 'readFile').mockRejectedValue(new Error('File not found'));
-    vi.spyOn(fs, 'rm').mockResolvedValue(undefined);
-
-    vi.spyOn(os, 'homedir').mockReturnValue('/mock/home');
-    vi.spyOn(path, 'join').mockReturnValue(oldFilePath);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('loadCredentials', () => {
-    it('should load credentials from HybridTokenStorage if available', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockResolvedValue(
-        mockMcpCredentials,
-      );
-
-      const result = await OAuthCredentialStorage.loadCredentials();
-
-      expect(mockHybridTokenStorage.getCredentials).toHaveBeenCalledWith(
-        'main-account',
-      );
-      expect(result).toEqual(mockCredentials);
-    });
-
-    it('should fallback to migrateFromFileStorage if no credentials in HybridTokenStorage', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockResolvedValue(
-        null,
-      );
-      vi.spyOn(fs, 'readFile').mockResolvedValue(
-        JSON.stringify(mockCredentials),
-      );
-
-      const result = await OAuthCredentialStorage.loadCredentials();
-
-      expect(mockHybridTokenStorage.getCredentials).toHaveBeenCalledWith(
-        'main-account',
-      );
-      expect(fs.readFile).toHaveBeenCalledWith(oldFilePath, 'utf-8');
-      expect(mockHybridTokenStorage.setCredentials).toHaveBeenCalled(); // Verify credentials were saved
-      expect(fs.rm).toHaveBeenCalledWith(oldFilePath, { force: true }); // Verify old file was removed
-      expect(result).toEqual(mockCredentials);
-    });
-
-    it('should return null if no credentials found and no old file to migrate', async () => {
-      vi.spyOn(fs, 'readFile').mockRejectedValue({
-        message: 'File not found',
-        code: 'ENOENT',
-      });
-
-      const result = await OAuthCredentialStorage.loadCredentials();
-
-      expect(result).toBeNull();
-    });
-
-    it('should throw an error if loading fails', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockRejectedValue(
-        new Error('Loading error'),
-      );
-
-      await expect(OAuthCredentialStorage.loadCredentials()).rejects.toThrow(
-        'Failed to load OAuth credentials',
-      );
-    });
-
-    it('should throw an error if read file fails', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockResolvedValue(
-        null,
-      );
-      vi.spyOn(fs, 'readFile').mockRejectedValue(
-        new Error('Permission denied'),
-      );
-
-      await expect(OAuthCredentialStorage.loadCredentials()).rejects.toThrow(
-        'Failed to load OAuth credentials',
-      );
-    });
-
-    it('should not throw error if migration file removal failed', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'getCredentials').mockResolvedValue(
-        null,
-      );
-      vi.spyOn(fs, 'readFile').mockResolvedValue(
-        JSON.stringify(mockCredentials),
-      );
-      vi.spyOn(OAuthCredentialStorage, 'saveCredentials').mockResolvedValue(
-        undefined,
-      );
-      vi.spyOn(fs, 'rm').mockRejectedValue(new Error('Deletion failed'));
-
-      const result = await OAuthCredentialStorage.loadCredentials();
-
-      expect(result).toEqual(mockCredentials);
-    });
-  });
-
-  describe('saveCredentials', () => {
-    it('should save credentials to HybridTokenStorage', async () => {
-      await OAuthCredentialStorage.saveCredentials(mockCredentials);
-
-      expect(mockHybridTokenStorage.setCredentials).toHaveBeenCalledWith(
-        mockMcpCredentials,
-      );
-    });
-
-    it('should throw an error if access_token is missing', async () => {
-      const invalidCredentials: Credentials = {
-        ...mockCredentials,
-        access_token: undefined,
-      };
-      await expect(
-        OAuthCredentialStorage.saveCredentials(invalidCredentials),
-      ).rejects.toThrow(
-        'Attempted to save credentials without an access token.',
-      );
-    });
-  });
-
-  describe('clearCredentials', () => {
-    it('should delete credentials from HybridTokenStorage', async () => {
-      await OAuthCredentialStorage.clearCredentials();
-
-      expect(mockHybridTokenStorage.deleteCredentials).toHaveBeenCalledWith(
-        'main-account',
-      );
-    });
-
-    it('should attempt to remove the old file-based storage', async () => {
-      await OAuthCredentialStorage.clearCredentials();
-
-      expect(fs.rm).toHaveBeenCalledWith(oldFilePath, { force: true });
-    });
-
-    it('should not throw an error if deleting old file fails', async () => {
-      vi.spyOn(fs, 'rm').mockRejectedValue(new Error('File deletion failed'));
-
-      await expect(
-        OAuthCredentialStorage.clearCredentials(),
-      ).resolves.toBeUndefined();
-    });
-
-    it('should throw an error if clearing from HybridTokenStorage fails', async () => {
-      vi.spyOn(mockHybridTokenStorage, 'deleteCredentials').mockRejectedValue(
-        new Error('Deletion error'),
-      );
-
-      await expect(OAuthCredentialStorage.clearCredentials()).rejects.toThrow(
-        'Failed to clear OAuth credentials',
-      );
-    });
-  });
-});

packages/core/src/code_assist/oauth-credential-storage.ts

@@ -1,130 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { type Credentials } from 'google-auth-library';
-import { HybridTokenStorage } from '../mcp/token-storage/hybrid-token-storage.js';
-import { OAUTH_FILE } from '../config/storage.js';
-import type { OAuthCredentials } from '../mcp/token-storage/types.js';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { promises as fs } from 'node:fs';
-
-const QWEN_DIR = '.qwen';
-const KEYCHAIN_SERVICE_NAME = 'qwen-code-oauth';
-const MAIN_ACCOUNT_KEY = 'main-account';
-
-export class OAuthCredentialStorage {
-  private static storage: HybridTokenStorage = new HybridTokenStorage(
-    KEYCHAIN_SERVICE_NAME,
-  );
-
-  /**
-   * Load cached OAuth credentials
-   */
-  static async loadCredentials(): Promise<Credentials | null> {
-    try {
-      const credentials = await this.storage.getCredentials(MAIN_ACCOUNT_KEY);
-
-      if (credentials?.token) {
-        const { accessToken, refreshToken, expiresAt, tokenType, scope } =
-          credentials.token;
-        // Convert from OAuthCredentials format to Google Credentials format
-        const googleCreds: Credentials = {
-          access_token: accessToken,
-          refresh_token: refreshToken || undefined,
-          token_type: tokenType || undefined,
-          scope: scope || undefined,
-        };
-
-        if (expiresAt) {
-          googleCreds.expiry_date = expiresAt;
-        }
-
-        return googleCreds;
-      }
-
-      // Fallback: Try to migrate from old file-based storage
-      return await this.migrateFromFileStorage();
-    } catch (error: unknown) {
-      console.error(error);
-      throw new Error('Failed to load OAuth credentials');
-    }
-  }
-
-  /**
-   * Save OAuth credentials
-   */
-  static async saveCredentials(credentials: Credentials): Promise<void> {
-    if (!credentials.access_token) {
-      throw new Error('Attempted to save credentials without an access token.');
-    }
-
-    // Convert Google Credentials to OAuthCredentials format
-    const mcpCredentials: OAuthCredentials = {
-      serverName: MAIN_ACCOUNT_KEY,
-      token: {
-        accessToken: credentials.access_token,
-        refreshToken: credentials.refresh_token || undefined,
-        tokenType: credentials.token_type || 'Bearer',
-        scope: credentials.scope || undefined,
-        expiresAt: credentials.expiry_date || undefined,
-      },
-      updatedAt: Date.now(),
-    };
-
-    await this.storage.setCredentials(mcpCredentials);
-  }
-
-  /**
-   * Clear cached OAuth credentials
-   */
-  static async clearCredentials(): Promise<void> {
-    try {
-      await this.storage.deleteCredentials(MAIN_ACCOUNT_KEY);
-
-      // Also try to remove the old file if it exists
-      const oldFilePath = path.join(os.homedir(), QWEN_DIR, OAUTH_FILE);
-      await fs.rm(oldFilePath, { force: true }).catch(() => {});
-    } catch (error: unknown) {
-      console.error(error);
-      throw new Error('Failed to clear OAuth credentials');
-    }
-  }
-
-  /**
-   * Migrate credentials from old file-based storage to keychain
-   */
-  private static async migrateFromFileStorage(): Promise<Credentials | null> {
-    const oldFilePath = path.join(os.homedir(), QWEN_DIR, OAUTH_FILE);
-
-    let credsJson: string;
-    try {
-      credsJson = await fs.readFile(oldFilePath, 'utf-8');
-    } catch (error: unknown) {
-      if (
-        typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'ENOENT'
-      ) {
-        // File doesn't exist, so no migration.
-        return null;
-      }
-      // Other read errors should propagate.
-      throw error;
-    }
-
-    const credentials = JSON.parse(credsJson) as Credentials;
-
-    // Save to new storage
-    await this.saveCredentials(credentials);
-
-    // Remove old file after successful migration
-    await fs.rm(oldFilePath, { force: true }).catch(() => {});
-
-    return credentials;
-  }
-}

packages/core/src/code_assist/oauth2.ts

@@ -1,563 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { Credentials } from 'google-auth-library';
-import {
-  CodeChallengeMethod,
-  Compute,
-  OAuth2Client,
-} from 'google-auth-library';
-import crypto from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import * as http from 'node:http';
-import * as net from 'node:net';
-import path from 'node:path';
-import readline from 'node:readline';
-import url from 'node:url';
-import open from 'open';
-import type { Config } from '../config/config.js';
-import { Storage } from '../config/storage.js';
-import { AuthType } from '../core/contentGenerator.js';
-import { FatalAuthenticationError, getErrorMessage } from '../utils/errors.js';
-import { UserAccountManager } from '../utils/userAccountManager.js';
-import { OAuthCredentialStorage } from './oauth-credential-storage.js';
-import { FORCE_ENCRYPTED_FILE_ENV_VAR } from '../mcp/token-storage/index.js';
-
-const userAccountManager = new UserAccountManager();
-
-//  OAuth Client ID used to initiate OAuth2Client class.
-const OAUTH_CLIENT_ID =
-  '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com';
-
-// OAuth Secret value used to initiate OAuth2Client class.
-// Note: It's ok to save this in git because this is an installed application
-// as described here: https://developers.google.com/identity/protocols/oauth2#installed
-// "The process results in a client ID and, in some cases, a client secret,
-// which you embed in the source code of your application. (In this context,
-// the client secret is obviously not treated as a secret.)"
-const OAUTH_CLIENT_SECRET = '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';
-
-// OAuth Scopes for Cloud Code authorization.
-const OAUTH_SCOPE = [
-  'https://www.googleapis.com/auth/cloud-platform',
-  'https://www.googleapis.com/auth/userinfo.email',
-  'https://www.googleapis.com/auth/userinfo.profile',
-];
-
-const HTTP_REDIRECT = 301;
-const SIGN_IN_SUCCESS_URL =
-  'https://developers.google.com/gemini-code-assist/auth_success_gemini';
-const SIGN_IN_FAILURE_URL =
-  'https://developers.google.com/gemini-code-assist/auth_failure_gemini';
-
-/**
- * An Authentication URL for updating the credentials of a Oauth2Client
- * as well as a promise that will resolve when the credentials have
- * been refreshed (or which throws error when refreshing credentials failed).
- */
-export interface OauthWebLogin {
-  authUrl: string;
-  loginCompletePromise: Promise<void>;
-}
-
-const oauthClientPromises = new Map<AuthType, Promise<OAuth2Client>>();
-
-function getUseEncryptedStorageFlag() {
-  return process.env[FORCE_ENCRYPTED_FILE_ENV_VAR] === 'true';
-}
-
-async function initOauthClient(
-  authType: AuthType,
-  config: Config,
-): Promise<OAuth2Client> {
-  const client = new OAuth2Client({
-    clientId: OAUTH_CLIENT_ID,
-    clientSecret: OAUTH_CLIENT_SECRET,
-    transporterOptions: {
-      proxy: config.getProxy(),
-    },
-  });
-  const useEncryptedStorage = getUseEncryptedStorageFlag();
-
-  if (
-    process.env['GOOGLE_GENAI_USE_GCA'] &&
-    process.env['GOOGLE_CLOUD_ACCESS_TOKEN']
-  ) {
-    client.setCredentials({
-      access_token: process.env['GOOGLE_CLOUD_ACCESS_TOKEN'],
-    });
-    await fetchAndCacheUserInfo(client);
-    return client;
-  }
-
-  client.on('tokens', async (tokens: Credentials) => {
-    if (useEncryptedStorage) {
-      await OAuthCredentialStorage.saveCredentials(tokens);
-    } else {
-      await cacheCredentials(tokens);
-    }
-  });
-
-  // If there are cached creds on disk, they always take precedence
-  if (await loadCachedCredentials(client)) {
-    // Found valid cached credentials.
-    // Check if we need to retrieve Google Account ID or Email
-    if (!userAccountManager.getCachedGoogleAccount()) {
-      try {
-        await fetchAndCacheUserInfo(client);
-      } catch (error) {
-        // Non-fatal, continue with existing auth.
-        console.warn('Failed to fetch user info:', getErrorMessage(error));
-      }
-    }
-    console.log('Loaded cached credentials.');
-    return client;
-  }
-
-  // In Google Cloud Shell, we can use Application Default Credentials (ADC)
-  // provided via its metadata server to authenticate non-interactively using
-  // the identity of the user logged into Cloud Shell.
-  if (authType === AuthType.CLOUD_SHELL) {
-    try {
-      console.log("Attempting to authenticate via Cloud Shell VM's ADC.");
-      const computeClient = new Compute({
-        // We can leave this empty, since the metadata server will provide
-        // the service account email.
-      });
-      await computeClient.getAccessToken();
-      console.log('Authentication successful.');
-
-      // Do not cache creds in this case; note that Compute client will handle its own refresh
-      return computeClient;
-    } catch (e) {
-      throw new Error(
-        `Could not authenticate using Cloud Shell credentials. Please select a different authentication method or ensure you are in a properly configured environment. Error: ${getErrorMessage(
-          e,
-        )}`,
-      );
-    }
-  }
-
-  if (config.isBrowserLaunchSuppressed()) {
-    let success = false;
-    const maxRetries = 2;
-    for (let i = 0; !success && i < maxRetries; i++) {
-      success = await authWithUserCode(client);
-      if (!success) {
-        console.error(
-          '\nFailed to authenticate with user code.',
-          i === maxRetries - 1 ? '' : 'Retrying...\n',
-        );
-      }
-    }
-    if (!success) {
-      throw new FatalAuthenticationError(
-        'Failed to authenticate with user code.',
-      );
-    }
-  } else {
-    const webLogin = await authWithWeb(client);
-
-    console.log(
-      `\n\nCode Assist login required.\n` +
-        `Attempting to open authentication page in your browser.\n` +
-        `Otherwise navigate to:\n\n${webLogin.authUrl}\n\n`,
-    );
-    try {
-      // Attempt to open the authentication URL in the default browser.
-      // We do not use the `wait` option here because the main script's execution
-      // is already paused by `loginCompletePromise`, which awaits the server callback.
-      const childProcess = await open(webLogin.authUrl);
-
-      // IMPORTANT: Attach an error handler to the returned child process.
-      // Without this, if `open` fails to spawn a process (e.g., `xdg-open` is not found
-      // in a minimal Docker container), it will emit an unhandled 'error' event,
-      // causing the entire Node.js process to crash.
-      childProcess.on('error', (error) => {
-        console.error(
-          'Failed to open browser automatically. Please try running again with NO_BROWSER=true set.',
-        );
-        console.error('Browser error details:', getErrorMessage(error));
-      });
-    } catch (err) {
-      console.error(
-        'An unexpected error occurred while trying to open the browser:',
-        getErrorMessage(err),
-        '\nThis might be due to browser compatibility issues or system configuration.',
-        '\nPlease try running again with NO_BROWSER=true set for manual authentication.',
-      );
-      throw new FatalAuthenticationError(
-        `Failed to open browser: ${getErrorMessage(err)}`,
-      );
-    }
-    console.log('Waiting for authentication...');
-
-    // Add timeout to prevent infinite waiting when browser tab gets stuck
-    const authTimeout = 5 * 60 * 1000; // 5 minutes timeout
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
-        reject(
-          new FatalAuthenticationError(
-            'Authentication timed out after 5 minutes. The browser tab may have gotten stuck in a loading state. ' +
-              'Please try again or use NO_BROWSER=true for manual authentication.',
-          ),
-        );
-      }, authTimeout);
-    });
-
-    await Promise.race([webLogin.loginCompletePromise, timeoutPromise]);
-  }
-
-  return client;
-}
-
-export async function getOauthClient(
-  authType: AuthType,
-  config: Config,
-): Promise<OAuth2Client> {
-  if (!oauthClientPromises.has(authType)) {
-    oauthClientPromises.set(authType, initOauthClient(authType, config));
-  }
-  return oauthClientPromises.get(authType)!;
-}
-
-async function authWithUserCode(client: OAuth2Client): Promise<boolean> {
-  const redirectUri = 'https://codeassist.google.com/authcode';
-  const codeVerifier = await client.generateCodeVerifierAsync();
-  const state = crypto.randomBytes(32).toString('hex');
-  const authUrl: string = client.generateAuthUrl({
-    redirect_uri: redirectUri,
-    access_type: 'offline',
-    scope: OAUTH_SCOPE,
-    code_challenge_method: CodeChallengeMethod.S256,
-    code_challenge: codeVerifier.codeChallenge,
-    state,
-  });
-  console.log('Please visit the following URL to authorize the application:');
-  console.log('');
-  console.log(authUrl);
-  console.log('');
-
-  const code = await new Promise<string>((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    rl.question('Enter the authorization code: ', (code) => {
-      rl.close();
-      resolve(code.trim());
-    });
-  });
-
-  if (!code) {
-    console.error('Authorization code is required.');
-    return false;
-  }
-
-  try {
-    const { tokens } = await client.getToken({
-      code,
-      codeVerifier: codeVerifier.codeVerifier,
-      redirect_uri: redirectUri,
-    });
-    client.setCredentials(tokens);
-  } catch (error) {
-    console.error(
-      'Failed to authenticate with authorization code:',
-      getErrorMessage(error),
-    );
-    return false;
-  }
-  return true;
-}
-
-async function authWithWeb(client: OAuth2Client): Promise<OauthWebLogin> {
-  const port = await getAvailablePort();
-  // The hostname used for the HTTP server binding (e.g., '0.0.0.0' in Docker).
-  const host = process.env['OAUTH_CALLBACK_HOST'] || 'localhost';
-  // The `redirectUri` sent to Google's authorization server MUST use a loopback IP literal
-  // (i.e., 'localhost' or '127.0.0.1'). This is a strict security policy for credentials of
-  // type 'Desktop app' or 'Web application' (when using loopback flow) to mitigate
-  // authorization code interception attacks.
-  const redirectUri = `http://localhost:${port}/oauth2callback`;
-  const state = crypto.randomBytes(32).toString('hex');
-  const authUrl = client.generateAuthUrl({
-    redirect_uri: redirectUri,
-    access_type: 'offline',
-    scope: OAUTH_SCOPE,
-    state,
-  });
-
-  const loginCompletePromise = new Promise<void>((resolve, reject) => {
-    const server = http.createServer(async (req, res) => {
-      try {
-        if (req.url!.indexOf('/oauth2callback') === -1) {
-          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
-          res.end();
-          reject(
-            new FatalAuthenticationError(
-              'OAuth callback not received. Unexpected request: ' + req.url,
-            ),
-          );
-        }
-        // acquire the code from the querystring, and close the web server.
-        const qs = new url.URL(req.url!, 'http://localhost:3000').searchParams;
-        if (qs.get('error')) {
-          res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
-          res.end();
-
-          const errorCode = qs.get('error');
-          const errorDescription =
-            qs.get('error_description') || 'No additional details provided';
-          reject(
-            new FatalAuthenticationError(
-              `Google OAuth error: ${errorCode}. ${errorDescription}`,
-            ),
-          );
-        } else if (qs.get('state') !== state) {
-          res.end('State mismatch. Possible CSRF attack');
-
-          reject(
-            new FatalAuthenticationError(
-              'OAuth state mismatch. Possible CSRF attack or browser session issue.',
-            ),
-          );
-        } else if (qs.get('code')) {
-          try {
-            const { tokens } = await client.getToken({
-              code: qs.get('code')!,
-              redirect_uri: redirectUri,
-            });
-            client.setCredentials(tokens);
-
-            // Retrieve and cache Google Account ID during authentication
-            try {
-              await fetchAndCacheUserInfo(client);
-            } catch (error) {
-              console.warn(
-                'Failed to retrieve Google Account ID during authentication:',
-                getErrorMessage(error),
-              );
-              // Don't fail the auth flow if Google Account ID retrieval fails
-            }
-
-            res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_SUCCESS_URL });
-            res.end();
-            resolve();
-          } catch (error) {
-            res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_FAILURE_URL });
-            res.end();
-            reject(
-              new FatalAuthenticationError(
-                `Failed to exchange authorization code for tokens: ${getErrorMessage(error)}`,
-              ),
-            );
-          }
-        } else {
-          reject(
-            new FatalAuthenticationError(
-              'No authorization code received from Google OAuth. Please try authenticating again.',
-            ),
-          );
-        }
-      } catch (e) {
-        // Provide more specific error message for unexpected errors during OAuth flow
-        if (e instanceof FatalAuthenticationError) {
-          reject(e);
-        } else {
-          reject(
-            new FatalAuthenticationError(
-              `Unexpected error during OAuth authentication: ${getErrorMessage(e)}`,
-            ),
-          );
-        }
-      } finally {
-        server.close();
-      }
-    });
-
-    server.listen(port, host, () => {
-      // Server started successfully
-    });
-
-    server.on('error', (err) => {
-      reject(
-        new FatalAuthenticationError(
-          `OAuth callback server error: ${getErrorMessage(err)}`,
-        ),
-      );
-    });
-  });
-
-  return {
-    authUrl,
-    loginCompletePromise,
-  };
-}
-
-export function getAvailablePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    let port = 0;
-    try {
-      const portStr = process.env['OAUTH_CALLBACK_PORT'];
-      if (portStr) {
-        port = parseInt(portStr, 10);
-        if (isNaN(port) || port <= 0 || port > 65535) {
-          return reject(
-            new Error(`Invalid value for OAUTH_CALLBACK_PORT: "${portStr}"`),
-          );
-        }
-        return resolve(port);
-      }
-      const server = net.createServer();
-      server.listen(0, () => {
-        const address = server.address()! as net.AddressInfo;
-        port = address.port;
-      });
-      server.on('listening', () => {
-        server.close();
-        server.unref();
-      });
-      server.on('error', (e) => reject(e));
-      server.on('close', () => resolve(port));
-    } catch (e) {
-      reject(e);
-    }
-  });
-}
-
-async function loadCachedCredentials(client: OAuth2Client): Promise<boolean> {
-  const useEncryptedStorage = getUseEncryptedStorageFlag();
-  if (useEncryptedStorage) {
-    const credentials = await OAuthCredentialStorage.loadCredentials();
-    if (credentials) {
-      client.setCredentials(credentials);
-      return true;
-    }
-    return false;
-  }
-
-  const pathsToTry = [
-    Storage.getOAuthCredsPath(),
-    process.env['GOOGLE_APPLICATION_CREDENTIALS'],
-  ].filter((p): p is string => !!p);
-
-  for (const keyFile of pathsToTry) {
-    try {
-      const creds = await fs.readFile(keyFile, 'utf-8');
-      client.setCredentials(JSON.parse(creds));
-
-      // This will verify locally that the credentials look good.
-      const { token } = await client.getAccessToken();
-      if (!token) {
-        continue;
-      }
-
-      // This will check with the server to see if it hasn't been revoked.
-      await client.getTokenInfo(token);
-
-      return true;
-    } catch (error) {
-      // Log specific error for debugging, but continue trying other paths
-      console.debug(
-        `Failed to load credentials from ${keyFile}:`,
-        getErrorMessage(error),
-      );
-    }
-  }
-
-  return false;
-}
-
-async function cacheCredentials(credentials: Credentials) {
-  const filePath = Storage.getOAuthCredsPath();
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-
-  const credString = JSON.stringify(credentials, null, 2);
-  await fs.writeFile(filePath, credString, { mode: 0o600 });
-  try {
-    await fs.chmod(filePath, 0o600);
-  } catch {
-    /* empty */
-  }
-}
-
-export function clearOauthClientCache() {
-  oauthClientPromises.clear();
-}
-
-export async function clearCachedCredentialFile() {
-  try {
-    const useEncryptedStorage = getUseEncryptedStorageFlag();
-    if (useEncryptedStorage) {
-      await OAuthCredentialStorage.clearCredentials();
-    } else {
-      await fs.rm(Storage.getOAuthCredsPath(), { force: true });
-    }
-    // Clear the Google Account ID cache when credentials are cleared
-    await userAccountManager.clearCachedGoogleAccount();
-    // Clear the in-memory OAuth client cache to force re-authentication
-    clearOauthClientCache();
-
-    /**
-     * Also clear Qwen SharedTokenManager cache and credentials file to prevent stale credentials
-     * when switching between auth types
-     * TODO: We do not depend on code_assist, we'll have to build an independent auth-cleaning procedure.
-     */
-    try {
-      const { SharedTokenManager } = await import(
-        '../qwen/sharedTokenManager.js'
-      );
-      const { clearQwenCredentials } = await import('../qwen/qwenOAuth2.js');
-
-      const sharedManager = SharedTokenManager.getInstance();
-      sharedManager.clearCache();
-
-      await clearQwenCredentials();
-    } catch (qwenError) {
-      console.debug('Could not clear Qwen credentials:', qwenError);
-    }
-  } catch (e) {
-    console.error('Failed to clear cached credentials:', e);
-  }
-}
-
-async function fetchAndCacheUserInfo(client: OAuth2Client): Promise<void> {
-  try {
-    const { token } = await client.getAccessToken();
-    if (!token) {
-      return;
-    }
-
-    const response = await fetch(
-      'https://www.googleapis.com/oauth2/v2/userinfo',
-      {
-        headers: {
-          Authorization: `Bearer ${token}`,
-        },
-      },
-    );
-
-    if (!response.ok) {
-      console.error(
-        'Failed to fetch user info:',
-        response.status,
-        response.statusText,
-      );
-      return;
-    }
-
-    const userInfo = await response.json();
-    await userAccountManager.cacheGoogleAccount(userInfo.email);
-  } catch (error) {
-    console.error('Error retrieving user info:', error);
-  }
-}
-
-// Helper to ensure test isolation
-export function resetOauthClientForTesting() {
-  oauthClientPromises.clear();
-}

packages/core/src/code_assist/server.test.ts

@@ -1,255 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { beforeEach, describe, it, expect, vi } from 'vitest';
-import { CodeAssistServer } from './server.js';
-import { OAuth2Client } from 'google-auth-library';
-import { UserTierId } from './types.js';
-
-vi.mock('google-auth-library');
-
-describe('CodeAssistServer', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it('should be able to be constructed', () => {
-    const auth = new OAuth2Client();
-    const server = new CodeAssistServer(
-      auth,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    expect(server).toBeInstanceOf(CodeAssistServer);
-  });
-
-  it('should call the generateContent endpoint', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockResponse = {
-      response: {
-        candidates: [
-          {
-            index: 0,
-            content: {
-              role: 'model',
-              parts: [{ text: 'response' }],
-            },
-            finishReason: 'STOP',
-            safetyRatings: [],
-          },
-        ],
-      },
-    };
-    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
-
-    const response = await server.generateContent(
-      {
-        model: 'test-model',
-        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
-      },
-      'user-prompt-id',
-    );
-
-    expect(server.requestPost).toHaveBeenCalledWith(
-      'generateContent',
-      expect.any(Object),
-      undefined,
-    );
-    expect(response.candidates?.[0]?.content?.parts?.[0]?.text).toBe(
-      'response',
-    );
-  });
-
-  it('should call the generateContentStream endpoint', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockResponse = (async function* () {
-      yield {
-        response: {
-          candidates: [
-            {
-              index: 0,
-              content: {
-                role: 'model',
-                parts: [{ text: 'response' }],
-              },
-              finishReason: 'STOP',
-              safetyRatings: [],
-            },
-          ],
-        },
-      };
-    })();
-    vi.spyOn(server, 'requestStreamingPost').mockResolvedValue(mockResponse);
-
-    const stream = await server.generateContentStream(
-      {
-        model: 'test-model',
-        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
-      },
-      'user-prompt-id',
-    );
-
-    for await (const res of stream) {
-      expect(server.requestStreamingPost).toHaveBeenCalledWith(
-        'streamGenerateContent',
-        expect.any(Object),
-        undefined,
-      );
-      expect(res.candidates?.[0]?.content?.parts?.[0]?.text).toBe('response');
-    }
-  });
-
-  it('should call the onboardUser endpoint', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockResponse = {
-      name: 'operations/123',
-      done: true,
-    };
-    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
-
-    const response = await server.onboardUser({
-      tierId: 'test-tier',
-      cloudaicompanionProject: 'test-project',
-      metadata: {},
-    });
-
-    expect(server.requestPost).toHaveBeenCalledWith(
-      'onboardUser',
-      expect.any(Object),
-    );
-    expect(response.name).toBe('operations/123');
-  });
-
-  it('should call the loadCodeAssist endpoint', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockResponse = {
-      currentTier: {
-        id: UserTierId.FREE,
-        name: 'Free',
-        description: 'free tier',
-      },
-      allowedTiers: [],
-      ineligibleTiers: [],
-      cloudaicompanionProject: 'projects/test',
-    };
-    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
-
-    const response = await server.loadCodeAssist({
-      metadata: {},
-    });
-
-    expect(server.requestPost).toHaveBeenCalledWith(
-      'loadCodeAssist',
-      expect.any(Object),
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it('should return 0 for countTokens', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockResponse = {
-      totalTokens: 100,
-    };
-    vi.spyOn(server, 'requestPost').mockResolvedValue(mockResponse);
-
-    const response = await server.countTokens({
-      model: 'test-model',
-      contents: [{ role: 'user', parts: [{ text: 'request' }] }],
-    });
-    expect(response.totalTokens).toBe(100);
-  });
-
-  it('should throw an error for embedContent', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    await expect(
-      server.embedContent({
-        model: 'test-model',
-        contents: [{ role: 'user', parts: [{ text: 'request' }] }],
-      }),
-    ).rejects.toThrow();
-  });
-
-  it('should handle VPC-SC errors when calling loadCodeAssist', async () => {
-    const client = new OAuth2Client();
-    const server = new CodeAssistServer(
-      client,
-      'test-project',
-      {},
-      'test-session',
-      UserTierId.FREE,
-    );
-    const mockVpcScError = {
-      response: {
-        data: {
-          error: {
-            details: [
-              {
-                reason: 'SECURITY_POLICY_VIOLATED',
-              },
-            ],
-          },
-        },
-      },
-    };
-    vi.spyOn(server, 'requestPost').mockRejectedValue(mockVpcScError);
-
-    const response = await server.loadCodeAssist({
-      metadata: {},
-    });
-
-    expect(server.requestPost).toHaveBeenCalledWith(
-      'loadCodeAssist',
-      expect.any(Object),
-    );
-    expect(response).toEqual({
-      currentTier: { id: UserTierId.STANDARD },
-    });
-  });
-});

packages/core/src/code_assist/server.ts

@@ -1,253 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { OAuth2Client } from 'google-auth-library';
-import type {
-  CodeAssistGlobalUserSettingResponse,
-  GoogleRpcResponse,
-  LoadCodeAssistRequest,
-  LoadCodeAssistResponse,
-  LongRunningOperationResponse,
-  OnboardUserRequest,
-  SetCodeAssistGlobalUserSettingRequest,
-} from './types.js';
-import type {
-  CountTokensParameters,
-  CountTokensResponse,
-  EmbedContentParameters,
-  EmbedContentResponse,
-  GenerateContentParameters,
-  GenerateContentResponse,
-} from '@google/genai';
-import * as readline from 'node:readline';
-import type { ContentGenerator } from '../core/contentGenerator.js';
-import { UserTierId } from './types.js';
-import type {
-  CaCountTokenResponse,
-  CaGenerateContentResponse,
-} from './converter.js';
-import {
-  fromCountTokenResponse,
-  fromGenerateContentResponse,
-  toCountTokenRequest,
-  toGenerateContentRequest,
-} from './converter.js';
-
-/** HTTP options to be used in each of the requests. */
-export interface HttpOptions {
-  /** Additional HTTP headers to be sent with the request. */
-  headers?: Record<string, string>;
-}
-
-export const CODE_ASSIST_ENDPOINT = 'https://localhost:0'; // Disable Google Code Assist API Request
-export const CODE_ASSIST_API_VERSION = 'v1internal';
-
-export class CodeAssistServer implements ContentGenerator {
-  constructor(
-    readonly client: OAuth2Client,
-    readonly projectId?: string,
-    readonly httpOptions: HttpOptions = {},
-    readonly sessionId?: string,
-    readonly userTier?: UserTierId,
-  ) {}
-
-  async generateContentStream(
-    req: GenerateContentParameters,
-    userPromptId: string,
-  ): Promise<AsyncGenerator<GenerateContentResponse>> {
-    const resps = await this.requestStreamingPost<CaGenerateContentResponse>(
-      'streamGenerateContent',
-      toGenerateContentRequest(
-        req,
-        userPromptId,
-        this.projectId,
-        this.sessionId,
-      ),
-      req.config?.abortSignal,
-    );
-    return (async function* (): AsyncGenerator<GenerateContentResponse> {
-      for await (const resp of resps) {
-        yield fromGenerateContentResponse(resp);
-      }
-    })();
-  }
-
-  async generateContent(
-    req: GenerateContentParameters,
-    userPromptId: string,
-  ): Promise<GenerateContentResponse> {
-    const resp = await this.requestPost<CaGenerateContentResponse>(
-      'generateContent',
-      toGenerateContentRequest(
-        req,
-        userPromptId,
-        this.projectId,
-        this.sessionId,
-      ),
-      req.config?.abortSignal,
-    );
-    return fromGenerateContentResponse(resp);
-  }
-
-  async onboardUser(
-    req: OnboardUserRequest,
-  ): Promise<LongRunningOperationResponse> {
-    return await this.requestPost<LongRunningOperationResponse>(
-      'onboardUser',
-      req,
-    );
-  }
-
-  async loadCodeAssist(
-    req: LoadCodeAssistRequest,
-  ): Promise<LoadCodeAssistResponse> {
-    try {
-      return await this.requestPost<LoadCodeAssistResponse>(
-        'loadCodeAssist',
-        req,
-      );
-    } catch (e) {
-      if (isVpcScAffectedUser(e)) {
-        return {
-          currentTier: { id: UserTierId.STANDARD },
-        };
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  async getCodeAssistGlobalUserSetting(): Promise<CodeAssistGlobalUserSettingResponse> {
-    return await this.requestGet<CodeAssistGlobalUserSettingResponse>(
-      'getCodeAssistGlobalUserSetting',
-    );
-  }
-
-  async setCodeAssistGlobalUserSetting(
-    req: SetCodeAssistGlobalUserSettingRequest,
-  ): Promise<CodeAssistGlobalUserSettingResponse> {
-    return await this.requestPost<CodeAssistGlobalUserSettingResponse>(
-      'setCodeAssistGlobalUserSetting',
-      req,
-    );
-  }
-
-  async countTokens(req: CountTokensParameters): Promise<CountTokensResponse> {
-    const resp = await this.requestPost<CaCountTokenResponse>(
-      'countTokens',
-      toCountTokenRequest(req),
-    );
-    return fromCountTokenResponse(resp);
-  }
-
-  async embedContent(
-    _req: EmbedContentParameters,
-  ): Promise<EmbedContentResponse> {
-    throw Error();
-  }
-
-  async requestPost<T>(
-    method: string,
-    req: object,
-    signal?: AbortSignal,
-  ): Promise<T> {
-    const res = await this.client.request({
-      url: this.getMethodUrl(method),
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...this.httpOptions.headers,
-      },
-      responseType: 'json',
-      body: JSON.stringify(req),
-      signal,
-    });
-    return res.data as T;
-  }
-
-  async requestGet<T>(method: string, signal?: AbortSignal): Promise<T> {
-    const res = await this.client.request({
-      url: this.getMethodUrl(method),
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        ...this.httpOptions.headers,
-      },
-      responseType: 'json',
-      signal,
-    });
-    return res.data as T;
-  }
-
-  async requestStreamingPost<T>(
-    method: string,
-    req: object,
-    signal?: AbortSignal,
-  ): Promise<AsyncGenerator<T>> {
-    const res = await this.client.request({
-      url: this.getMethodUrl(method),
-      method: 'POST',
-      params: {
-        alt: 'sse',
-      },
-      headers: {
-        'Content-Type': 'application/json',
-        ...this.httpOptions.headers,
-      },
-      responseType: 'stream',
-      body: JSON.stringify(req),
-      signal,
-    });
-
-    return (async function* (): AsyncGenerator<T> {
-      const rl = readline.createInterface({
-        input: res.data as NodeJS.ReadableStream,
-        crlfDelay: Infinity, // Recognizes '\r\n' and '\n' as line breaks
-      });
-
-      let bufferedLines: string[] = [];
-      for await (const line of rl) {
-        // blank lines are used to separate JSON objects in the stream
-        if (line === '') {
-          if (bufferedLines.length === 0) {
-            continue; // no data to yield
-          }
-          yield JSON.parse(bufferedLines.join('\n')) as T;
-          bufferedLines = []; // Reset the buffer after yielding
-        } else if (line.startsWith('data: ')) {
-          bufferedLines.push(line.slice(6).trim());
-        } else {
-          throw new Error(`Unexpected line format in response: ${line}`);
-        }
-      }
-    })();
-  }
-
-  getMethodUrl(method: string): string {
-    const endpoint =
-      process.env['CODE_ASSIST_ENDPOINT'] ?? CODE_ASSIST_ENDPOINT;
-    return `${endpoint}/${CODE_ASSIST_API_VERSION}:${method}`;
-  }
-}
-
-function isVpcScAffectedUser(error: unknown): boolean {
-  if (error && typeof error === 'object' && 'response' in error) {
-    const gaxiosError = error as {
-      response?: {
-        data?: unknown;
-      };
-    };
-    const response = gaxiosError.response?.data as
-      | GoogleRpcResponse
-      | undefined;
-    if (Array.isArray(response?.error?.details)) {
-      return response.error.details.some(
-        (detail) => detail.reason === 'SECURITY_POLICY_VIOLATED',
-      );
-    }
-  }
-  return false;
-}

packages/core/src/code_assist/setup.test.ts

@@ -1,224 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { setupUser, ProjectIdRequiredError } from './setup.js';
-import { CodeAssistServer } from '../code_assist/server.js';
-import type { OAuth2Client } from 'google-auth-library';
-import type { GeminiUserTier } from './types.js';
-import { UserTierId } from './types.js';
-
-vi.mock('../code_assist/server.js');
-
-const mockPaidTier: GeminiUserTier = {
-  id: UserTierId.STANDARD,
-  name: 'paid',
-  description: 'Paid tier',
-  isDefault: true,
-};
-
-const mockFreeTier: GeminiUserTier = {
-  id: UserTierId.FREE,
-  name: 'free',
-  description: 'Free tier',
-  isDefault: true,
-};
-
-describe('setupUser for existing user', () => {
-  let mockLoad: ReturnType<typeof vi.fn>;
-  let mockOnboardUser: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-    mockLoad = vi.fn();
-    mockOnboardUser = vi.fn().mockResolvedValue({
-      done: true,
-      response: {
-        cloudaicompanionProject: {
-          id: 'server-project',
-        },
-      },
-    });
-    vi.mocked(CodeAssistServer).mockImplementation(
-      () =>
-        ({
-          loadCodeAssist: mockLoad,
-          onboardUser: mockOnboardUser,
-        }) as unknown as CodeAssistServer,
-    );
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it('should use GOOGLE_CLOUD_PROJECT when set and project from server is undefined', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
-    mockLoad.mockResolvedValue({
-      currentTier: mockPaidTier,
-    });
-    await setupUser({} as OAuth2Client);
-    expect(CodeAssistServer).toHaveBeenCalledWith(
-      {},
-      'test-project',
-      {},
-      '',
-      undefined,
-    );
-  });
-
-  it('should ignore GOOGLE_CLOUD_PROJECT when project from server is set', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
-    mockLoad.mockResolvedValue({
-      cloudaicompanionProject: 'server-project',
-      currentTier: mockPaidTier,
-    });
-    const projectId = await setupUser({} as OAuth2Client);
-    expect(CodeAssistServer).toHaveBeenCalledWith(
-      {},
-      'test-project',
-      {},
-      '',
-      undefined,
-    );
-    expect(projectId).toEqual({
-      projectId: 'server-project',
-      userTier: 'standard-tier',
-    });
-  });
-
-  it('should throw ProjectIdRequiredError when no project ID is available', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
-    // And the server itself requires a project ID internally
-    vi.mocked(CodeAssistServer).mockImplementation(() => {
-      throw new ProjectIdRequiredError();
-    });
-
-    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
-      ProjectIdRequiredError,
-    );
-  });
-});
-
-describe('setupUser for new user', () => {
-  let mockLoad: ReturnType<typeof vi.fn>;
-  let mockOnboardUser: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-    mockLoad = vi.fn();
-    mockOnboardUser = vi.fn().mockResolvedValue({
-      done: true,
-      response: {
-        cloudaicompanionProject: {
-          id: 'server-project',
-        },
-      },
-    });
-    vi.mocked(CodeAssistServer).mockImplementation(
-      () =>
-        ({
-          loadCodeAssist: mockLoad,
-          onboardUser: mockOnboardUser,
-        }) as unknown as CodeAssistServer,
-    );
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it('should use GOOGLE_CLOUD_PROJECT when set and onboard a new paid user', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
-    mockLoad.mockResolvedValue({
-      allowedTiers: [mockPaidTier],
-    });
-    const userData = await setupUser({} as OAuth2Client);
-    expect(CodeAssistServer).toHaveBeenCalledWith(
-      {},
-      'test-project',
-      {},
-      '',
-      undefined,
-    );
-    expect(mockLoad).toHaveBeenCalled();
-    expect(mockOnboardUser).toHaveBeenCalledWith({
-      tierId: 'standard-tier',
-      cloudaicompanionProject: 'test-project',
-      metadata: {
-        ideType: 'IDE_UNSPECIFIED',
-        platform: 'PLATFORM_UNSPECIFIED',
-        pluginType: 'GEMINI',
-        duetProject: 'test-project',
-      },
-    });
-    expect(userData).toEqual({
-      projectId: 'server-project',
-      userTier: 'standard-tier',
-    });
-  });
-
-  it('should onboard a new free user when GOOGLE_CLOUD_PROJECT is not set', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
-    mockLoad.mockResolvedValue({
-      allowedTiers: [mockFreeTier],
-    });
-    const userData = await setupUser({} as OAuth2Client);
-    expect(CodeAssistServer).toHaveBeenCalledWith(
-      {},
-      undefined,
-      {},
-      '',
-      undefined,
-    );
-    expect(mockLoad).toHaveBeenCalled();
-    expect(mockOnboardUser).toHaveBeenCalledWith({
-      tierId: 'free-tier',
-      cloudaicompanionProject: undefined,
-      metadata: {
-        ideType: 'IDE_UNSPECIFIED',
-        platform: 'PLATFORM_UNSPECIFIED',
-        pluginType: 'GEMINI',
-      },
-    });
-    expect(userData).toEqual({
-      projectId: 'server-project',
-      userTier: 'free-tier',
-    });
-  });
-
-  it('should use GOOGLE_CLOUD_PROJECT when onboard response has no project ID', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project');
-    mockLoad.mockResolvedValue({
-      allowedTiers: [mockPaidTier],
-    });
-    mockOnboardUser.mockResolvedValue({
-      done: true,
-      response: {
-        cloudaicompanionProject: undefined,
-      },
-    });
-    const userData = await setupUser({} as OAuth2Client);
-    expect(userData).toEqual({
-      projectId: 'test-project',
-      userTier: 'standard-tier',
-    });
-  });
-
-  it('should throw ProjectIdRequiredError when no project ID is available', async () => {
-    vi.stubEnv('GOOGLE_CLOUD_PROJECT', '');
-    mockLoad.mockResolvedValue({
-      allowedTiers: [mockPaidTier],
-    });
-    mockOnboardUser.mockResolvedValue({
-      done: true,
-      response: {},
-    });
-    await expect(setupUser({} as OAuth2Client)).rejects.toThrow(
-      ProjectIdRequiredError,
-    );
-  });
-});

packages/core/src/code_assist/setup.ts

@@ -1,124 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  ClientMetadata,
-  GeminiUserTier,
-  LoadCodeAssistResponse,
-  OnboardUserRequest,
-} from './types.js';
-import { UserTierId } from './types.js';
-import { CodeAssistServer } from './server.js';
-import type { OAuth2Client } from 'google-auth-library';
-
-export class ProjectIdRequiredError extends Error {
-  constructor() {
-    super(
-      'This account requires setting the GOOGLE_CLOUD_PROJECT env var. See https://goo.gle/gemini-cli-auth-docs#workspace-gca',
-    );
-  }
-}
-
-export interface UserData {
-  projectId: string;
-  userTier: UserTierId;
-}
-
-/**
- *
- * @param projectId the user's project id, if any
- * @returns the user's actual project id
- */
-export async function setupUser(client: OAuth2Client): Promise<UserData> {
-  const projectId = process.env['GOOGLE_CLOUD_PROJECT'] || undefined;
-  const caServer = new CodeAssistServer(client, projectId, {}, '', undefined);
-  const coreClientMetadata: ClientMetadata = {
-    ideType: 'IDE_UNSPECIFIED',
-    platform: 'PLATFORM_UNSPECIFIED',
-    pluginType: 'GEMINI',
-  };
-
-  const loadRes = await caServer.loadCodeAssist({
-    cloudaicompanionProject: projectId,
-    metadata: {
-      ...coreClientMetadata,
-      duetProject: projectId,
-    },
-  });
-
-  if (loadRes.currentTier) {
-    if (!loadRes.cloudaicompanionProject) {
-      if (projectId) {
-        return {
-          projectId,
-          userTier: loadRes.currentTier.id,
-        };
-      }
-      throw new ProjectIdRequiredError();
-    }
-    return {
-      projectId: loadRes.cloudaicompanionProject,
-      userTier: loadRes.currentTier.id,
-    };
-  }
-
-  const tier = getOnboardTier(loadRes);
-
-  let onboardReq: OnboardUserRequest;
-  if (tier.id === UserTierId.FREE) {
-    // The free tier uses a managed google cloud project. Setting a project in the `onboardUser` request causes a `Precondition Failed` error.
-    onboardReq = {
-      tierId: tier.id,
-      cloudaicompanionProject: undefined,
-      metadata: coreClientMetadata,
-    };
-  } else {
-    onboardReq = {
-      tierId: tier.id,
-      cloudaicompanionProject: projectId,
-      metadata: {
-        ...coreClientMetadata,
-        duetProject: projectId,
-      },
-    };
-  }
-
-  // Poll onboardUser until long running operation is complete.
-  let lroRes = await caServer.onboardUser(onboardReq);
-  while (!lroRes.done) {
-    await new Promise((f) => setTimeout(f, 5000));
-    lroRes = await caServer.onboardUser(onboardReq);
-  }
-
-  if (!lroRes.response?.cloudaicompanionProject?.id) {
-    if (projectId) {
-      return {
-        projectId,
-        userTier: tier.id,
-      };
-    }
-    throw new ProjectIdRequiredError();
-  }
-
-  return {
-    projectId: lroRes.response.cloudaicompanionProject.id,
-    userTier: tier.id,
-  };
-}
-
-function getOnboardTier(res: LoadCodeAssistResponse): GeminiUserTier {
-  for (const tier of res.allowedTiers || []) {
-    if (tier.isDefault) {
-      return tier;
-    }
-  }
-  return {
-    name: '',
-    description: '',
-    id: UserTierId.LEGACY,
-    userDefinedCloudaicompanionProject: true,
-  };
-}

packages/core/src/code_assist/types.ts

@@ -1,201 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export interface ClientMetadata {
-  ideType?: ClientMetadataIdeType;
-  ideVersion?: string;
-  pluginVersion?: string;
-  platform?: ClientMetadataPlatform;
-  updateChannel?: string;
-  duetProject?: string;
-  pluginType?: ClientMetadataPluginType;
-  ideName?: string;
-}
-
-export type ClientMetadataIdeType =
-  | 'IDE_UNSPECIFIED'
-  | 'VSCODE'
-  | 'INTELLIJ'
-  | 'VSCODE_CLOUD_WORKSTATION'
-  | 'INTELLIJ_CLOUD_WORKSTATION'
-  | 'CLOUD_SHELL';
-export type ClientMetadataPlatform =
-  | 'PLATFORM_UNSPECIFIED'
-  | 'DARWIN_AMD64'
-  | 'DARWIN_ARM64'
-  | 'LINUX_AMD64'
-  | 'LINUX_ARM64'
-  | 'WINDOWS_AMD64';
-export type ClientMetadataPluginType =
-  | 'PLUGIN_UNSPECIFIED'
-  | 'CLOUD_CODE'
-  | 'GEMINI'
-  | 'AIPLUGIN_INTELLIJ'
-  | 'AIPLUGIN_STUDIO';
-
-export interface LoadCodeAssistRequest {
-  cloudaicompanionProject?: string;
-  metadata: ClientMetadata;
-}
-
-/**
- * Represents LoadCodeAssistResponse proto json field
- * http://google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=224
- */
-export interface LoadCodeAssistResponse {
-  currentTier?: GeminiUserTier | null;
-  allowedTiers?: GeminiUserTier[] | null;
-  ineligibleTiers?: IneligibleTier[] | null;
-  cloudaicompanionProject?: string | null;
-}
-
-/**
- * GeminiUserTier reflects the structure received from the CodeAssist when calling LoadCodeAssist.
- */
-export interface GeminiUserTier {
-  id: UserTierId;
-  name?: string;
-  description?: string;
-  // This value is used to declare whether a given tier requires the user to configure the project setting on the IDE settings or not.
-  userDefinedCloudaicompanionProject?: boolean | null;
-  isDefault?: boolean;
-  privacyNotice?: PrivacyNotice;
-  hasAcceptedTos?: boolean;
-  hasOnboardedPreviously?: boolean;
-}
-
-/**
- * Includes information specifying the reasons for a user's ineligibility for a specific tier.
- * @param reasonCode mnemonic code representing the reason for in-eligibility.
- * @param reasonMessage message to display to the user.
- * @param tierId id of the tier.
- * @param tierName name of the tier.
- */
-export interface IneligibleTier {
-  reasonCode: IneligibleTierReasonCode;
-  reasonMessage: string;
-  tierId: UserTierId;
-  tierName: string;
-}
-
-/**
- * List of predefined reason codes when a tier is blocked from a specific tier.
- * https://source.corp.google.com/piper///depot/google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=378
- */
-export enum IneligibleTierReasonCode {
-  // go/keep-sorted start
-  DASHER_USER = 'DASHER_USER',
-  INELIGIBLE_ACCOUNT = 'INELIGIBLE_ACCOUNT',
-  NON_USER_ACCOUNT = 'NON_USER_ACCOUNT',
-  RESTRICTED_AGE = 'RESTRICTED_AGE',
-  RESTRICTED_NETWORK = 'RESTRICTED_NETWORK',
-  UNKNOWN = 'UNKNOWN',
-  UNKNOWN_LOCATION = 'UNKNOWN_LOCATION',
-  UNSUPPORTED_LOCATION = 'UNSUPPORTED_LOCATION',
-  // go/keep-sorted end
-}
-/**
- * UserTierId represents IDs returned from the Cloud Code Private API representing a user's tier
- *
- * //depot/google3/cloud/developer_experience/cloudcode/pa/service/usertier.go;l=16
- */
-export enum UserTierId {
-  FREE = 'free-tier',
-  LEGACY = 'legacy-tier',
-  STANDARD = 'standard-tier',
-}
-
-/**
- * PrivacyNotice reflects the structure received from the CodeAssist in regards to a tier
- * privacy notice.
- */
-export interface PrivacyNotice {
-  showNotice: boolean;
-  noticeText?: string;
-}
-
-/**
- * Proto signature of OnboardUserRequest as payload to OnboardUser call
- */
-export interface OnboardUserRequest {
-  tierId: string | undefined;
-  cloudaicompanionProject: string | undefined;
-  metadata: ClientMetadata | undefined;
-}
-
-/**
- * Represents LongRunningOperation proto
- * http://google3/google/longrunning/operations.proto;rcl=698857719;l=107
- */
-export interface LongRunningOperationResponse {
-  name: string;
-  done?: boolean;
-  response?: OnboardUserResponse;
-}
-
-/**
- * Represents OnboardUserResponse proto
- * http://google3/google/internal/cloud/code/v1internal/cloudcode.proto;l=215
- */
-export interface OnboardUserResponse {
-  // tslint:disable-next-line:enforce-name-casing This is the name of the field in the proto.
-  cloudaicompanionProject?: {
-    id: string;
-    name: string;
-  };
-}
-
-/**
- * Status code of user license status
- * it does not strictly correspond to the proto
- * Error value is an additional value assigned to error responses from OnboardUser
- */
-export enum OnboardUserStatusCode {
-  Default = 'DEFAULT',
-  Notice = 'NOTICE',
-  Warning = 'WARNING',
-  Error = 'ERROR',
-}
-
-/**
- * Status of user onboarded to gemini
- */
-export interface OnboardUserStatus {
-  statusCode: OnboardUserStatusCode;
-  displayMessage: string;
-  helpLink: HelpLinkUrl | undefined;
-}
-
-export interface HelpLinkUrl {
-  description: string;
-  url: string;
-}
-
-export interface SetCodeAssistGlobalUserSettingRequest {
-  cloudaicompanionProject?: string;
-  freeTierDataCollectionOptin: boolean;
-}
-
-export interface CodeAssistGlobalUserSettingResponse {
-  cloudaicompanionProject?: string;
-  freeTierDataCollectionOptin: boolean;
-}
-
-/**
- * Relevant fields that can be returned from a Google RPC response
- */
-export interface GoogleRpcResponse {
-  error?: {
-    details?: GoogleRpcErrorInfo[];
-  };
-}
-
-/**
- * Relevant fields that can be returned in the details of an error returned from GoogleRPCs
- */
-interface GoogleRpcErrorInfo {
-  reason?: string;
-}

packages/core/src/config/config.test.ts

@@ -283,23 +283,6 @@ describe('Server Config (config.ts)', () => {
       expect(config.isInFallbackMode()).toBe(false);
     });
 
-    it('should strip thoughts when switching from GenAI to Vertex', async () => {
-      const config = new Config(baseParams);
-
-      vi.mocked(createContentGeneratorConfig).mockImplementation(
-        (_: Config, authType: AuthType | undefined) =>
-          ({ authType }) as unknown as ContentGeneratorConfig,
-      );
-
-      await config.refreshAuth(AuthType.USE_GEMINI);
-
-      await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-
-      expect(
-        config.getGeminiClient().stripThoughtsFromHistory,
-      ).toHaveBeenCalledWith();
-    });
-
     it('should not strip thoughts when switching from Vertex to GenAI', async () => {
       const config = new Config(baseParams);
 

packages/core/src/config/config.ts

@@ -16,6 +16,7 @@ import { ProxyAgent, setGlobalDispatcher } from 'undici';
 import type {
   ContentGenerator,
   ContentGeneratorConfig,
+  AuthType,
 } from '../core/contentGenerator.js';
 import type { FallbackModelHandler } from '../fallback/types.js';
 import type { MCPOAuthConfig } from '../mcp/oauth-provider.js';
@@ -26,7 +27,6 @@ import type { AnyToolInvocation } from '../tools/tools.js';
 import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { GeminiClient } from '../core/client.js';
 import {
-  AuthType,
   createContentGenerator,
   createContentGeneratorConfig,
 } from '../core/contentGenerator.js';
@@ -287,7 +287,7 @@ export interface ConfigParameters {
   contextFileName?: string | string[];
   accessibility?: AccessibilitySettings;
   telemetry?: TelemetrySettings;
-  gitCoAuthor?: GitCoAuthorSettings;
+  gitCoAuthor?: boolean;
   usageStatisticsEnabled?: boolean;
   fileFiltering?: {
     respectGitIgnore?: boolean;
@@ -534,9 +534,9 @@ export class Config {
       useCollector: params.telemetry?.useCollector,
     };
     this.gitCoAuthor = {
-      enabled: params.gitCoAuthor?.enabled ?? true,
-      name: params.gitCoAuthor?.name ?? 'Qwen-Coder',
-      email: params.gitCoAuthor?.email ?? 'qwen-coder@alibabacloud.com',
+      enabled: params.gitCoAuthor ?? true,
+      name: 'Qwen-Coder',
+      email: 'qwen-coder@alibabacloud.com',
     };
     this.usageStatisticsEnabled = params.usageStatisticsEnabled ?? true;
 
@@ -684,16 +684,6 @@ export class Config {
   }
 
   async refreshAuth(authMethod: AuthType, isInitialAuth?: boolean) {
-    // Vertex and Genai have incompatible encryption and sending history with
-    // throughtSignature from Genai to Vertex will fail, we need to strip them
-    if (
-      this.contentGeneratorConfig?.authType === AuthType.USE_GEMINI &&
-      authMethod === AuthType.LOGIN_WITH_GOOGLE
-    ) {
-      // Restore the conversation history to the new client
-      this.geminiClient.stripThoughtsFromHistory();
-    }
-
     const newContentGeneratorConfig = createContentGeneratorConfig(
       this,
       authMethod,
@@ -741,9 +731,12 @@ export class Config {
   /**
    * Starts a new session and resets session-scoped services.
    */
-  startNewSession(sessionId?: string): string {
+  startNewSession(
+    sessionId?: string,
+    sessionData?: ResumedSessionData,
+  ): string {
     this.sessionId = sessionId ?? randomUUID();
-    this.sessionData = undefined;
+    this.sessionData = sessionData;
     this.chatRecordingService = this.chatRecordingEnabled
       ? new ChatRecordingService(this)
       : undefined;

packages/core/src/config/flashFallback.test.ts

@@ -31,7 +31,7 @@ describe('Flash Model Fallback Configuration', () => {
       config as unknown as { contentGeneratorConfig: unknown }
     ).contentGeneratorConfig = {
       model: DEFAULT_GEMINI_MODEL,
-      authType: 'oauth-personal',
+      authType: 'gemini-api-key',
     };
   });
 

packages/core/src/config/storage.ts

@@ -15,6 +15,7 @@ export const OAUTH_FILE = 'oauth_creds.json';
 const TMP_DIR_NAME = 'tmp';
 const BIN_DIR_NAME = 'bin';
 const PROJECT_DIR_NAME = 'projects';
+const IDE_DIR_NAME = 'ide';
 
 export class Storage {
   private readonly targetDir: string;
@@ -59,6 +60,10 @@ export class Storage {
     return path.join(Storage.getGlobalQwenDir(), TMP_DIR_NAME);
   }
 
+  static getGlobalIdeDir(): string {
+    return path.join(Storage.getGlobalQwenDir(), IDE_DIR_NAME);
+  }
+
   static getGlobalBinDir(): string {
     return path.join(Storage.getGlobalQwenDir(), BIN_DIR_NAME);
   }

packages/core/src/core/__tests__/openaiTimeoutHandling.test.ts

@@ -73,6 +73,7 @@ describe('OpenAIContentGenerator Timeout Handling', () => {
       }),
       buildClient: vi.fn().mockReturnValue(mockOpenAIClient),
       buildRequest: vi.fn().mockImplementation((req) => req),
+      getDefaultGenerationConfig: vi.fn().mockReturnValue({}),
     };
 
     // Create generator instance
@@ -299,6 +300,7 @@ describe('OpenAIContentGenerator Timeout Handling', () => {
         }),
         buildClient: vi.fn().mockReturnValue(mockOpenAIClient),
         buildRequest: vi.fn().mockImplementation((req) => req),
+        getDefaultGenerationConfig: vi.fn().mockReturnValue({}),
       };
 
       new OpenAIContentGenerator(
@@ -333,6 +335,7 @@ describe('OpenAIContentGenerator Timeout Handling', () => {
         }),
         buildClient: vi.fn().mockReturnValue(mockOpenAIClient),
         buildRequest: vi.fn().mockImplementation((req) => req),
+        getDefaultGenerationConfig: vi.fn().mockReturnValue({}),
       };
 
       new OpenAIContentGenerator(

packages/core/src/core/baseLlmClient.test.ts

@@ -146,13 +146,11 @@ describe('BaseLlmClient', () => {
       // Validate the parameters passed to the underlying generator
       expect(mockGenerateContent).toHaveBeenCalledTimes(1);
       expect(mockGenerateContent).toHaveBeenCalledWith(
-        {
+        expect.objectContaining({
           model: 'test-model',
           contents: defaultOptions.contents,
-          config: {
+          config: expect.objectContaining({
             abortSignal: defaultOptions.abortSignal,
-            temperature: 0,
-            topP: 1,
             tools: [
               {
                 functionDeclarations: [
@@ -164,9 +162,8 @@ describe('BaseLlmClient', () => {
                 ],
               },
             ],
-            // Crucial: systemInstruction should NOT be in the config object if not provided
-          },
-        },
+          }),
+        }),
         'test-prompt-id',
       );
     });
@@ -189,7 +186,6 @@ describe('BaseLlmClient', () => {
         expect.objectContaining({
           config: expect.objectContaining({
             temperature: 0.8,
-            topP: 1, // Default should remain if not overridden
             topK: 10,
             tools: expect.any(Array),
           }),

packages/core/src/core/baseLlmClient.ts

@@ -64,12 +64,6 @@ export interface GenerateJsonOptions {
  * A client dedicated to stateless, utility-focused LLM calls.
  */
 export class BaseLlmClient {
-  // Default configuration for utility tasks
-  private readonly defaultUtilityConfig: GenerateContentConfig = {
-    temperature: 0,
-    topP: 1,
-  };
-
   constructor(
     private readonly contentGenerator: ContentGenerator,
     private readonly config: Config,
@@ -90,7 +84,6 @@ export class BaseLlmClient {
 
     const requestConfig: GenerateContentConfig = {
       abortSignal,
-      ...this.defaultUtilityConfig,
       ...options.config,
       ...(systemInstruction && { systemInstruction }),
     };

packages/core/src/core/client.test.ts

@@ -15,11 +15,7 @@ import {
 } from 'vitest';
 
 import type { Content, GenerateContentResponse, Part } from '@google/genai';
-import {
-  isThinkingDefault,
-  isThinkingSupported,
-  GeminiClient,
-} from './client.js';
+import { GeminiClient } from './client.js';
 import { findCompressSplitPoint } from '../services/chatCompressionService.js';
 import {
   AuthType,
@@ -247,40 +243,6 @@ describe('findCompressSplitPoint', () => {
   });
 });
 
-describe('isThinkingSupported', () => {
-  it('should return true for gemini-2.5', () => {
-    expect(isThinkingSupported('gemini-2.5')).toBe(true);
-  });
-
-  it('should return true for gemini-2.5-pro', () => {
-    expect(isThinkingSupported('gemini-2.5-pro')).toBe(true);
-  });
-
-  it('should return false for other models', () => {
-    expect(isThinkingSupported('gemini-1.5-flash')).toBe(false);
-    expect(isThinkingSupported('some-other-model')).toBe(false);
-  });
-});
-
-describe('isThinkingDefault', () => {
-  it('should return false for gemini-2.5-flash-lite', () => {
-    expect(isThinkingDefault('gemini-2.5-flash-lite')).toBe(false);
-  });
-
-  it('should return true for gemini-2.5', () => {
-    expect(isThinkingDefault('gemini-2.5')).toBe(true);
-  });
-
-  it('should return true for gemini-2.5-pro', () => {
-    expect(isThinkingDefault('gemini-2.5-pro')).toBe(true);
-  });
-
-  it('should return false for other models', () => {
-    expect(isThinkingDefault('gemini-1.5-flash')).toBe(false);
-    expect(isThinkingDefault('some-other-model')).toBe(false);
-  });
-});
-
 describe('Gemini Client (client.ts)', () => {
   let mockContentGenerator: ContentGenerator;
   let mockConfig: Config;
@@ -2304,16 +2266,15 @@ ${JSON.stringify(
       );
 
       expect(mockContentGenerator.generateContent).toHaveBeenCalledWith(
-        {
+        expect.objectContaining({
           model: DEFAULT_GEMINI_FLASH_MODEL,
-          config: {
+          config: expect.objectContaining({
             abortSignal,
             systemInstruction: getCoreSystemPrompt(''),
             temperature: 0.5,
-            topP: 1,
-          },
+          }),
           contents,
-        },
+        }),
         'test-session-id',
       );
     });

packages/core/src/core/client.ts

@@ -15,11 +15,7 @@ import type {
 
 // Config
 import { ApprovalMode, type Config } from '../config/config.js';
-import {
-  DEFAULT_GEMINI_FLASH_MODEL,
-  DEFAULT_GEMINI_MODEL_AUTO,
-  DEFAULT_THINKING_MODE,
-} from '../config/models.js';
+import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 
 // Core modules
 import type { ContentGenerator } from './contentGenerator.js';
@@ -78,25 +74,10 @@ import { type File, type IdeContext } from '../ide/types.js';
 // Fallback handling
 import { handleFallback } from '../fallback/handler.js';
 
-export function isThinkingSupported(model: string) {
-  return model.startsWith('gemini-2.5') || model === DEFAULT_GEMINI_MODEL_AUTO;
-}
-
-export function isThinkingDefault(model: string) {
-  if (model.startsWith('gemini-2.5-flash-lite')) {
-    return false;
-  }
-  return model.startsWith('gemini-2.5') || model === DEFAULT_GEMINI_MODEL_AUTO;
-}
-
 const MAX_TURNS = 100;
 
 export class GeminiClient {
   private chat?: GeminiChat;
-  private readonly generateContentConfig: GenerateContentConfig = {
-    temperature: 0,
-    topP: 1,
-  };
   private sessionTurnCount = 0;
 
   private readonly loopDetector: LoopDetectionService;
@@ -208,20 +189,10 @@ export class GeminiClient {
       const model = this.config.getModel();
       const systemInstruction = getCoreSystemPrompt(userMemory, model);
 
-      const config: GenerateContentConfig = { ...this.generateContentConfig };
-
-      if (isThinkingSupported(model)) {
-        config.thinkingConfig = {
-          includeThoughts: true,
-          thinkingBudget: DEFAULT_THINKING_MODE,
-        };
-      }
-
       return new GeminiChat(
         this.config,
         {
           systemInstruction,
-          ...config,
           tools,
         },
         history,
@@ -618,11 +589,6 @@ export class GeminiClient {
   ): Promise<GenerateContentResponse> {
     let currentAttemptModel: string = model;
 
-    const configToUse: GenerateContentConfig = {
-      ...this.generateContentConfig,
-      ...generationConfig,
-    };
-
     try {
       const userMemory = this.config.getUserMemory();
       const finalSystemInstruction = generationConfig.systemInstruction
@@ -631,7 +597,7 @@ export class GeminiClient {
 
       const requestConfig: GenerateContentConfig = {
         abortSignal,
-        ...configToUse,
+        ...generationConfig,
         systemInstruction: finalSystemInstruction,
       };
 
@@ -672,7 +638,7 @@ export class GeminiClient {
         `Error generating content via API with model ${currentAttemptModel}.`,
         {
           requestContents: contents,
-          requestConfig: configToUse,
+          requestConfig: generationConfig,
         },
         'generateContent-api',
       );

packages/core/src/core/contentGenerator.test.ts

@@ -5,42 +5,19 @@
  */
 
 import { describe, it, expect, vi } from 'vitest';
-import type { ContentGenerator } from './contentGenerator.js';
 import { createContentGenerator, AuthType } from './contentGenerator.js';
-import { createCodeAssistContentGenerator } from '../code_assist/codeAssist.js';
 import { GoogleGenAI } from '@google/genai';
 import type { Config } from '../config/config.js';
-import { LoggingContentGenerator } from './loggingContentGenerator.js';
+import { LoggingContentGenerator } from './geminiContentGenerator/loggingContentGenerator.js';
 
-vi.mock('../code_assist/codeAssist.js');
 vi.mock('@google/genai');
 
-const mockConfig = {
-  getCliVersion: vi.fn().mockReturnValue('1.0.0'),
-} as unknown as Config;
-
 describe('createContentGenerator', () => {
-  it('should create a CodeAssistContentGenerator', async () => {
-    const mockGenerator = {} as unknown as ContentGenerator;
-    vi.mocked(createCodeAssistContentGenerator).mockResolvedValue(
-      mockGenerator as never,
-    );
-    const generator = await createContentGenerator(
-      {
-        model: 'test-model',
-        authType: AuthType.LOGIN_WITH_GOOGLE,
-      },
-      mockConfig,
-    );
-    expect(createCodeAssistContentGenerator).toHaveBeenCalled();
-    expect(generator).toEqual(
-      new LoggingContentGenerator(mockGenerator, mockConfig),
-    );
-  });
-
-  it('should create a GoogleGenAI content generator', async () => {
+  it('should create a Gemini content generator', async () => {
     const mockConfig = {
       getUsageStatisticsEnabled: () => true,
+      getContentGeneratorConfig: () => ({}),
+      getCliVersion: () => '1.0.0',
     } as unknown as Config;
 
     const mockGenerator = {
@@ -65,17 +42,17 @@ describe('createContentGenerator', () => {
         },
       },
     });
-    expect(generator).toEqual(
-      new LoggingContentGenerator(
-        (mockGenerator as GoogleGenAI).models,
-        mockConfig,
-      ),
-    );
+    // We expect it to be a LoggingContentGenerator wrapping a GeminiContentGenerator
+    expect(generator).toBeInstanceOf(LoggingContentGenerator);
+    const wrapped = (generator as LoggingContentGenerator).getWrapped();
+    expect(wrapped).toBeDefined();
   });
 
-  it('should create a GoogleGenAI content generator with client install id logging disabled', async () => {
+  it('should create a Gemini content generator with client install id logging disabled', async () => {
     const mockConfig = {
       getUsageStatisticsEnabled: () => false,
+      getContentGeneratorConfig: () => ({}),
+      getCliVersion: () => '1.0.0',
     } as unknown as Config;
     const mockGenerator = {
       models: {},
@@ -98,11 +75,6 @@ describe('createContentGenerator', () => {
         },
       },
     });
-    expect(generator).toEqual(
-      new LoggingContentGenerator(
-        (mockGenerator as GoogleGenAI).models,
-        mockConfig,
-      ),
-    );
+    expect(generator).toBeInstanceOf(LoggingContentGenerator);
   });
 });

packages/core/src/core/contentGenerator.ts

@@ -12,15 +12,9 @@ import type {
   GenerateContentParameters,
   GenerateContentResponse,
 } from '@google/genai';
-import { GoogleGenAI } from '@google/genai';
-import { createCodeAssistContentGenerator } from '../code_assist/codeAssist.js';
 import { DEFAULT_QWEN_MODEL } from '../config/models.js';
 import type { Config } from '../config/config.js';
 
-import type { UserTierId } from '../code_assist/types.js';
-import { InstallationManager } from '../utils/installationManager.js';
-import { LoggingContentGenerator } from './loggingContentGenerator.js';
-
 /**
  * Interface abstracting the core functionalities for generating content and counting tokens.
  */
@@ -39,14 +33,12 @@ export interface ContentGenerator {
 
   embedContent(request: EmbedContentParameters): Promise<EmbedContentResponse>;
 
-  userTier?: UserTierId;
+  useSummarizedThinking(): boolean;
 }
 
 export enum AuthType {
-  LOGIN_WITH_GOOGLE = 'oauth-personal',
   USE_GEMINI = 'gemini-api-key',
   USE_VERTEX_AI = 'vertex-ai',
-  CLOUD_SHELL = 'cloud-shell',
   USE_OPENAI = 'openai',
   QWEN_OAUTH = 'qwen-oauth',
 }
@@ -59,12 +51,9 @@ export type ContentGeneratorConfig = {
   authType?: AuthType | undefined;
   enableOpenAILogging?: boolean;
   openAILoggingDir?: string;
-  // Timeout configuration in milliseconds
-  timeout?: number;
-  // Maximum retries for failed requests
-  maxRetries?: number;
-  // Disable cache control for DashScope providers
-  disableCacheControl?: boolean;
+  timeout?: number; // Timeout configuration in milliseconds
+  maxRetries?: number; // Maximum retries for failed requests
+  disableCacheControl?: boolean; // Disable cache control for DashScope providers
   samplingParams?: {
     top_p?: number;
     top_k?: number;
@@ -74,8 +63,13 @@ export type ContentGeneratorConfig = {
     temperature?: number;
     max_tokens?: number;
   };
+  reasoning?: {
+    effort?: 'low' | 'medium' | 'high';
+  };
   proxy?: string | undefined;
   userAgent?: string;
+  // Schema compliance mode for tool definitions
+  schemaCompliance?: 'auto' | 'openapi_30';
 };
 
 export function createContentGeneratorConfig(
@@ -121,48 +115,14 @@ export async function createContentGenerator(
   gcConfig: Config,
   isInitialAuth?: boolean,
 ): Promise<ContentGenerator> {
-  const version = process.env['CLI_VERSION'] || process.version;
-  const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
-  const baseHeaders: Record<string, string> = {
-    'User-Agent': userAgent,
-  };
-
-  if (
-    config.authType === AuthType.LOGIN_WITH_GOOGLE ||
-    config.authType === AuthType.CLOUD_SHELL
-  ) {
-    const httpOptions = { headers: baseHeaders };
-    return new LoggingContentGenerator(
-      await createCodeAssistContentGenerator(
-        httpOptions,
-        config.authType,
-        gcConfig,
-      ),
-      gcConfig,
-    );
-  }
-
   if (
     config.authType === AuthType.USE_GEMINI ||
     config.authType === AuthType.USE_VERTEX_AI
   ) {
-    let headers: Record<string, string> = { ...baseHeaders };
-    if (gcConfig?.getUsageStatisticsEnabled()) {
-      const installationManager = new InstallationManager();
-      const installationId = installationManager.getInstallationId();
-      headers = {
-        ...headers,
-        'x-gemini-api-privileged-user-id': `${installationId}`,
-      };
-    }
-    const httpOptions = { headers };
-
-    const googleGenAI = new GoogleGenAI({
-      apiKey: config.apiKey === '' ? undefined : config.apiKey,
-      vertexai: config.vertexai,
-      httpOptions,
-    });
-    return new LoggingContentGenerator(googleGenAI.models, gcConfig);
+    const { createGeminiContentGenerator } = await import(
+      './geminiContentGenerator/index.js'
+    );
+    return createGeminiContentGenerator(config, gcConfig);
   }
 
   if (config.authType === AuthType.USE_OPENAI) {

packages/core/src/core/coreToolScheduler.test.ts

@@ -240,7 +240,7 @@ describe('CoreToolScheduler', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -318,7 +318,7 @@ describe('CoreToolScheduler', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -497,7 +497,7 @@ describe('CoreToolScheduler', () => {
         getExcludeTools: () => ['write_file', 'edit', 'run_shell_command'],
         getContentGeneratorConfig: () => ({
           model: 'test-model',
-          authType: 'oauth-personal',
+          authType: 'gemini-api-key',
         }),
         getShellExecutionConfig: () => ({
           terminalWidth: 90,
@@ -584,7 +584,7 @@ describe('CoreToolScheduler', () => {
         getExcludeTools: () => ['write_file', 'edit'], // Different excluded tools
         getContentGeneratorConfig: () => ({
           model: 'test-model',
-          authType: 'oauth-personal',
+          authType: 'gemini-api-key',
         }),
         getShellExecutionConfig: () => ({
           terminalWidth: 90,
@@ -674,7 +674,7 @@ describe('CoreToolScheduler with payload', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1001,7 +1001,7 @@ describe('CoreToolScheduler edit cancellation', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1108,7 +1108,7 @@ describe('CoreToolScheduler YOLO mode', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1258,7 +1258,7 @@ describe('CoreToolScheduler cancellation during executing with live output', ()
       getApprovalMode: () => ApprovalMode.DEFAULT,
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getToolRegistry: () => mockToolRegistry,
       getShellExecutionConfig: () => ({
@@ -1350,7 +1350,7 @@ describe('CoreToolScheduler request queueing', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1482,7 +1482,7 @@ describe('CoreToolScheduler request queueing', () => {
       getToolRegistry: () => toolRegistry,
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 80,
@@ -1586,7 +1586,7 @@ describe('CoreToolScheduler request queueing', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1854,7 +1854,7 @@ describe('CoreToolScheduler Sequential Execution', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,
@@ -1975,7 +1975,7 @@ describe('CoreToolScheduler Sequential Execution', () => {
       getAllowedTools: () => [],
       getContentGeneratorConfig: () => ({
         model: 'test-model',
-        authType: 'oauth-personal',
+        authType: 'gemini-api-key',
       }),
       getShellExecutionConfig: () => ({
         terminalWidth: 90,

packages/core/src/core/geminiChat.test.ts

@@ -100,6 +100,7 @@ describe('GeminiChat', () => {
       countTokens: vi.fn(),
       embedContent: vi.fn(),
       batchEmbedContents: vi.fn(),
+      useSummarizedThinking: vi.fn().mockReturnValue(false),
     } as unknown as ContentGenerator;
 
     mockHandleFallback.mockClear();
@@ -111,7 +112,7 @@ describe('GeminiChat', () => {
       getUsageStatisticsEnabled: () => true,
       getDebugMode: () => false,
       getContentGeneratorConfig: vi.fn().mockReturnValue({
-        authType: 'oauth-personal', // Ensure this is set for fallback tests
+        authType: 'gemini-api-key', // Ensure this is set for fallback tests
         model: 'test-model',
       }),
       getModel: vi.fn().mockReturnValue('gemini-pro'),
@@ -718,6 +719,99 @@ describe('GeminiChat', () => {
         1,
       );
     });
+
+    it('should handle summarized thinking by conditionally including thoughts in history', async () => {
+      // Case 1: useSummarizedThinking is true -> thoughts NOT in history
+      vi.mocked(mockContentGenerator.useSummarizedThinking).mockReturnValue(
+        true,
+      );
+      const stream1 = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: {
+                role: 'model',
+                parts: [{ thought: true, text: 'T1' }, { text: 'A1' }],
+              },
+              finishReason: 'STOP',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(
+        stream1,
+      );
+
+      const res1 = await chat.sendMessageStream('m1', { message: 'h1' }, 'p1');
+      for await (const _ of res1);
+
+      const history1 = chat.getHistory();
+      expect(history1[1].parts).toEqual([{ text: 'A1' }]);
+
+      // Case 2: useSummarizedThinking is false -> thoughts ARE in history
+      chat.clearHistory();
+      vi.mocked(mockContentGenerator.useSummarizedThinking).mockReturnValue(
+        false,
+      );
+      const stream2 = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: {
+                role: 'model',
+                parts: [{ thought: true, text: 'T2' }, { text: 'A2' }],
+              },
+              finishReason: 'STOP',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(
+        stream2,
+      );
+
+      const res2 = await chat.sendMessageStream('m1', { message: 'h1' }, 'p2');
+      for await (const _ of res2);
+
+      const history2 = chat.getHistory();
+      expect(history2[1].parts).toEqual([
+        { text: 'T2', thought: true },
+        { text: 'A2' },
+      ]);
+    });
+
+    it('should keep parts with thoughtSignature when consolidating history', async () => {
+      const stream = (async function* () {
+        yield {
+          candidates: [
+            {
+              content: {
+                role: 'model',
+                parts: [
+                  {
+                    text: 'p1',
+                    thoughtSignature: 's1',
+                  } as unknown as { text: string; thoughtSignature: string },
+                ],
+              },
+              finishReason: 'STOP',
+            },
+          ],
+        } as unknown as GenerateContentResponse;
+      })();
+      vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(
+        stream,
+      );
+
+      const res = await chat.sendMessageStream('m1', { message: 'h1' }, 'p1');
+      for await (const _ of res);
+
+      const history = chat.getHistory();
+      expect(history[1].parts![0]).toEqual({
+        text: 'p1',
+        thoughtSignature: 's1',
+      });
+    });
   });
 
   describe('addHistory', () => {
@@ -1382,7 +1476,7 @@ describe('GeminiChat', () => {
     });
 
     it('should call handleFallback with the specific failed model and retry if handler returns true', async () => {
-      const authType = AuthType.LOGIN_WITH_GOOGLE;
+      const authType = AuthType.USE_GEMINI;
       vi.mocked(mockConfig.getContentGeneratorConfig).mockReturnValue({
         model: 'test-model',
         authType,
@@ -1532,7 +1626,7 @@ describe('GeminiChat', () => {
   });
 
   describe('stripThoughtsFromHistory', () => {
-    it('should strip thought signatures', () => {
+    it('should strip thoughts and thought signatures, and remove empty content objects', () => {
       chat.setHistory([
         {
           role: 'user',
@@ -1544,10 +1638,15 @@ describe('GeminiChat', () => {
             { text: 'thinking...', thought: true },
             { text: 'hi' },
             {
-              functionCall: { name: 'test', args: {} },
-            },
+              text: 'hidden metadata',
+              thoughtSignature: 'abc',
+            } as unknown as { text: string; thoughtSignature: string },
           ],
         },
+        {
+          role: 'model',
+          parts: [{ text: 'only thinking', thought: true }],
+        },
       ]);
 
       chat.stripThoughtsFromHistory();
@@ -1559,7 +1658,7 @@ describe('GeminiChat', () => {
         },
         {
           role: 'model',
-          parts: [{ text: 'hi' }, { functionCall: { name: 'test', args: {} } }],
+          parts: [{ text: 'hi' }, { text: 'hidden metadata' }],
         },
       ]);
     });

packages/core/src/core/geminiChat.ts

@@ -92,6 +92,7 @@ export function isValidNonThoughtTextPart(part: Part): boolean {
   return (
     typeof part.text === 'string' &&
     !part.thought &&
+    !part.thoughtSignature &&
     // Technically, the model should never generate parts that have text and
     //  any of these but we don't trust them so check anyways.
     !part.functionCall &&
@@ -109,18 +110,24 @@ function isValidContent(content: Content): boolean {
     if (part === undefined || Object.keys(part).length === 0) {
       return false;
     }
-    if (
-      !part.thought &&
-      part.text !== undefined &&
-      part.text === '' &&
-      part.functionCall === undefined
-    ) {
+    if (!isValidContentPart(part)) {
       return false;
     }
   }
   return true;
 }
 
+function isValidContentPart(part: Part): boolean {
+  const isInvalid =
+    !part.thought &&
+    !part.thoughtSignature &&
+    part.text !== undefined &&
+    part.text === '' &&
+    part.functionCall === undefined;
+
+  return !isInvalid;
+}
+
 /**
  * Validates the history contains the correct roles.
  *
@@ -448,15 +455,29 @@ export class GeminiChat {
         if (!content.parts) return content;
 
         // Filter out thought parts entirely
-        const filteredParts = content.parts.filter(
-          (part) =>
-            !(
+        const filteredParts = content.parts
+          .filter(
+            (part) =>
+              !(
+                part &&
+                typeof part === 'object' &&
+                'thought' in part &&
+                part.thought
+              ),
+          )
+          .map((part) => {
+            if (
               part &&
               typeof part === 'object' &&
-              'thought' in part &&
-              part.thought
-            ),
-        );
+              'thoughtSignature' in part
+            ) {
+              const newPart = { ...part };
+              delete (newPart as { thoughtSignature?: string })
+                .thoughtSignature;
+              return newPart;
+            }
+            return part;
+          });
 
         return {
           ...content,
@@ -538,11 +559,15 @@ export class GeminiChat {
       yield chunk; // Yield every chunk to the UI immediately.
     }
 
-    const thoughtParts = allModelParts.filter((part) => part.thought);
-    const thoughtText = thoughtParts
-      .map((part) => part.text)
-      .join('')
-      .trim();
+    let thoughtText = '';
+    // Only include thoughts if not using summarized thinking.
+    if (!this.config.getContentGenerator().useSummarizedThinking()) {
+      thoughtText = allModelParts
+        .filter((part) => part.thought)
+        .map((part) => part.text)
+        .join('')
+        .trim();
+    }
 
     const contentParts = allModelParts.filter((part) => !part.thought);
     const consolidatedHistoryParts: Part[] = [];
@@ -555,7 +580,7 @@ export class GeminiChat {
         isValidNonThoughtTextPart(part)
       ) {
         lastPart.text += part.text;
-      } else {
+      } else if (isValidContentPart(part)) {
         consolidatedHistoryParts.push(part);
       }
     }

packages/core/src/core/geminiContentGenerator/geminiContentGenerator.test.ts

@@ -0,0 +1,173 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GeminiContentGenerator } from './geminiContentGenerator.js';
+import { GoogleGenAI } from '@google/genai';
+
+vi.mock('@google/genai', () => {
+  const mockGenerateContent = vi.fn();
+  const mockGenerateContentStream = vi.fn();
+  const mockCountTokens = vi.fn();
+  const mockEmbedContent = vi.fn();
+
+  return {
+    GoogleGenAI: vi.fn().mockImplementation(() => ({
+      models: {
+        generateContent: mockGenerateContent,
+        generateContentStream: mockGenerateContentStream,
+        countTokens: mockCountTokens,
+        embedContent: mockEmbedContent,
+      },
+    })),
+  };
+});
+
+describe('GeminiContentGenerator', () => {
+  let generator: GeminiContentGenerator;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let mockGoogleGenAI: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    generator = new GeminiContentGenerator({
+      apiKey: 'test-api-key',
+    });
+    mockGoogleGenAI = vi.mocked(GoogleGenAI).mock.results[0].value;
+  });
+
+  it('should call generateContent on the underlying model', async () => {
+    const request = { model: 'gemini-1.5-flash', contents: [] };
+    const expectedResponse = { responseId: 'test-id' };
+    mockGoogleGenAI.models.generateContent.mockResolvedValue(expectedResponse);
+
+    const response = await generator.generateContent(request, 'prompt-id');
+
+    expect(mockGoogleGenAI.models.generateContent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ...request,
+        config: expect.objectContaining({
+          temperature: 1,
+          topP: 0.95,
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingLevel: 'THINKING_LEVEL_UNSPECIFIED',
+          },
+        }),
+      }),
+    );
+    expect(response).toBe(expectedResponse);
+  });
+
+  it('should call generateContentStream on the underlying model', async () => {
+    const request = { model: 'gemini-1.5-flash', contents: [] };
+    const mockStream = (async function* () {
+      yield { responseId: '1' };
+    })();
+    mockGoogleGenAI.models.generateContentStream.mockResolvedValue(mockStream);
+
+    const stream = await generator.generateContentStream(request, 'prompt-id');
+
+    expect(mockGoogleGenAI.models.generateContentStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ...request,
+        config: expect.objectContaining({
+          temperature: 1,
+          topP: 0.95,
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingLevel: 'THINKING_LEVEL_UNSPECIFIED',
+          },
+        }),
+      }),
+    );
+    expect(stream).toBe(mockStream);
+  });
+
+  it('should call countTokens on the underlying model', async () => {
+    const request = { model: 'gemini-1.5-flash', contents: [] };
+    const expectedResponse = { totalTokens: 10 };
+    mockGoogleGenAI.models.countTokens.mockResolvedValue(expectedResponse);
+
+    const response = await generator.countTokens(request);
+
+    expect(mockGoogleGenAI.models.countTokens).toHaveBeenCalledWith(request);
+    expect(response).toBe(expectedResponse);
+  });
+
+  it('should call embedContent on the underlying model', async () => {
+    const request = { model: 'embedding-model', contents: [] };
+    const expectedResponse = { embeddings: [] };
+    mockGoogleGenAI.models.embedContent.mockResolvedValue(expectedResponse);
+
+    const response = await generator.embedContent(request);
+
+    expect(mockGoogleGenAI.models.embedContent).toHaveBeenCalledWith(request);
+    expect(response).toBe(expectedResponse);
+  });
+
+  it('should prioritize contentGeneratorConfig samplingParams over request config', async () => {
+    const generatorWithParams = new GeminiContentGenerator({ apiKey: 'test' }, {
+      model: 'gemini-1.5-flash',
+      samplingParams: {
+        temperature: 0.1,
+        top_p: 0.2,
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    const request = {
+      model: 'gemini-1.5-flash',
+      contents: [],
+      config: {
+        temperature: 0.9,
+        topP: 0.9,
+      },
+    };
+
+    await generatorWithParams.generateContent(request, 'prompt-id');
+
+    expect(mockGoogleGenAI.models.generateContent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        config: expect.objectContaining({
+          temperature: 0.1,
+          topP: 0.2,
+        }),
+      }),
+    );
+  });
+
+  it('should map reasoning effort to thinkingConfig', async () => {
+    const generatorWithReasoning = new GeminiContentGenerator(
+      { apiKey: 'test' },
+      {
+        model: 'gemini-2.5-pro',
+        reasoning: {
+          effort: 'high',
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
+    );
+
+    const request = {
+      model: 'gemini-2.5-pro',
+      contents: [],
+    };
+
+    await generatorWithReasoning.generateContent(request, 'prompt-id');
+
+    expect(mockGoogleGenAI.models.generateContent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        config: expect.objectContaining({
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingLevel: 'HIGH',
+          },
+        }),
+      }),
+    );
+  });
+});

packages/core/src/core/geminiContentGenerator/geminiContentGenerator.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  CountTokensParameters,
+  CountTokensResponse,
+  EmbedContentParameters,
+  EmbedContentResponse,
+  GenerateContentParameters,
+  GenerateContentResponse,
+  GenerateContentConfig,
+  ThinkingLevel,
+} from '@google/genai';
+import { GoogleGenAI } from '@google/genai';
+import type {
+  ContentGenerator,
+  ContentGeneratorConfig,
+} from '../contentGenerator.js';
+
+/**
+ * A wrapper for GoogleGenAI that implements the ContentGenerator interface.
+ */
+export class GeminiContentGenerator implements ContentGenerator {
+  private readonly googleGenAI: GoogleGenAI;
+  private readonly contentGeneratorConfig?: ContentGeneratorConfig;
+
+  constructor(
+    options: {
+      apiKey?: string;
+      vertexai?: boolean;
+      httpOptions?: { headers: Record<string, string> };
+    },
+    contentGeneratorConfig?: ContentGeneratorConfig,
+  ) {
+    this.googleGenAI = new GoogleGenAI(options);
+    this.contentGeneratorConfig = contentGeneratorConfig;
+  }
+
+  private buildSamplingParameters(
+    request: GenerateContentParameters,
+  ): GenerateContentConfig {
+    const configSamplingParams = this.contentGeneratorConfig?.samplingParams;
+    const requestConfig = request.config || {};
+
+    // Helper function to get parameter value with priority: config > request > default
+    const getParameterValue = <T>(
+      configValue: T | undefined,
+      requestKey: keyof GenerateContentConfig,
+      defaultValue?: T,
+    ): T | undefined => {
+      const requestValue = requestConfig[requestKey] as T | undefined;
+
+      if (configValue !== undefined) return configValue;
+      if (requestValue !== undefined) return requestValue;
+      return defaultValue;
+    };
+
+    return {
+      ...requestConfig,
+      temperature: getParameterValue<number>(
+        configSamplingParams?.temperature,
+        'temperature',
+        1,
+      ),
+      topP: getParameterValue<number>(
+        configSamplingParams?.top_p,
+        'topP',
+        0.95,
+      ),
+      topK: getParameterValue<number>(configSamplingParams?.top_k, 'topK', 64),
+      maxOutputTokens: getParameterValue<number>(
+        configSamplingParams?.max_tokens,
+        'maxOutputTokens',
+      ),
+      presencePenalty: getParameterValue<number>(
+        configSamplingParams?.presence_penalty,
+        'presencePenalty',
+      ),
+      frequencyPenalty: getParameterValue<number>(
+        configSamplingParams?.frequency_penalty,
+        'frequencyPenalty',
+      ),
+      thinkingConfig: getParameterValue(
+        this.contentGeneratorConfig?.reasoning
+          ? {
+              includeThoughts: true,
+              thinkingLevel: (this.contentGeneratorConfig.reasoning.effort ===
+              'low'
+                ? 'LOW'
+                : this.contentGeneratorConfig.reasoning.effort === 'high'
+                  ? 'HIGH'
+                  : 'THINKING_LEVEL_UNSPECIFIED') as ThinkingLevel,
+            }
+          : undefined,
+        'thinkingConfig',
+        {
+          includeThoughts: true,
+          thinkingLevel: 'THINKING_LEVEL_UNSPECIFIED' as ThinkingLevel,
+        },
+      ),
+    };
+  }
+
+  async generateContent(
+    request: GenerateContentParameters,
+    _userPromptId: string,
+  ): Promise<GenerateContentResponse> {
+    const finalRequest = {
+      ...request,
+      config: this.buildSamplingParameters(request),
+    };
+    return this.googleGenAI.models.generateContent(finalRequest);
+  }
+
+  async generateContentStream(
+    request: GenerateContentParameters,
+    _userPromptId: string,
+  ): Promise<AsyncGenerator<GenerateContentResponse>> {
+    const finalRequest = {
+      ...request,
+      config: this.buildSamplingParameters(request),
+    };
+    return this.googleGenAI.models.generateContentStream(finalRequest);
+  }
+
+  async countTokens(
+    request: CountTokensParameters,
+  ): Promise<CountTokensResponse> {
+    return this.googleGenAI.models.countTokens(request);
+  }
+
+  async embedContent(
+    request: EmbedContentParameters,
+  ): Promise<EmbedContentResponse> {
+    return this.googleGenAI.models.embedContent(request);
+  }
+
+  useSummarizedThinking(): boolean {
+    return true;
+  }
+}

packages/core/src/core/geminiContentGenerator/index.test.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createGeminiContentGenerator } from './index.js';
+import { GeminiContentGenerator } from './geminiContentGenerator.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
+import type { Config } from '../../config/config.js';
+import { AuthType } from '../contentGenerator.js';
+
+vi.mock('./geminiContentGenerator.js', () => ({
+  GeminiContentGenerator: vi.fn().mockImplementation(() => ({})),
+}));
+
+vi.mock('./loggingContentGenerator.js', () => ({
+  LoggingContentGenerator: vi.fn().mockImplementation((wrapped) => wrapped),
+}));
+
+describe('createGeminiContentGenerator', () => {
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockConfig = {
+      getUsageStatisticsEnabled: vi.fn().mockReturnValue(false),
+      getContentGeneratorConfig: vi.fn().mockReturnValue({}),
+      getCliVersion: vi.fn().mockReturnValue('1.0.0'),
+    } as unknown as Config;
+  });
+
+  it('should create a GeminiContentGenerator wrapped in LoggingContentGenerator', () => {
+    const config = {
+      model: 'gemini-1.5-flash',
+      apiKey: 'test-key',
+      authType: AuthType.USE_GEMINI,
+    };
+
+    const generator = createGeminiContentGenerator(config, mockConfig);
+
+    expect(GeminiContentGenerator).toHaveBeenCalled();
+    expect(LoggingContentGenerator).toHaveBeenCalled();
+    expect(generator).toBeDefined();
+  });
+});

packages/core/src/core/geminiContentGenerator/index.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GeminiContentGenerator } from './geminiContentGenerator.js';
+import type {
+  ContentGenerator,
+  ContentGeneratorConfig,
+} from '../contentGenerator.js';
+import type { Config } from '../../config/config.js';
+import { InstallationManager } from '../../utils/installationManager.js';
+import { LoggingContentGenerator } from './loggingContentGenerator.js';
+
+export { GeminiContentGenerator } from './geminiContentGenerator.js';
+export { LoggingContentGenerator } from './loggingContentGenerator.js';
+
+/**
+ * Create a Gemini content generator.
+ */
+export function createGeminiContentGenerator(
+  config: ContentGeneratorConfig,
+  gcConfig: Config,
+): ContentGenerator {
+  const version = process.env['CLI_VERSION'] || process.version;
+  const userAgent =
+    config.userAgent ||
+    `QwenCode/${version} (${process.platform}; ${process.arch})`;
+  const baseHeaders: Record<string, string> = {
+    'User-Agent': userAgent,
+  };
+
+  let headers: Record<string, string> = { ...baseHeaders };
+  if (gcConfig?.getUsageStatisticsEnabled()) {
+    const installationManager = new InstallationManager();
+    const installationId = installationManager.getInstallationId();
+    headers = {
+      ...headers,
+      'x-gemini-api-privileged-user-id': `${installationId}`,
+    };
+  }
+  const httpOptions = { headers };
+
+  const geminiContentGenerator = new GeminiContentGenerator(
+    {
+      apiKey: config.apiKey === '' ? undefined : config.apiKey,
+      vertexai: config.vertexai,
+      httpOptions,
+    },
+    config,
+  );
+
+  return new LoggingContentGenerator(geminiContentGenerator, gcConfig);
+}