@qwen-code/qwen-code 0.14.5 → 0.15.0-nightly.20260423.d40fe7cdb

package/README.md

@@ -24,7 +24,7 @@
 
 - **2026-04-13**: Qwen OAuth free tier policy update: daily quota adjusted to 100 requests/day (from 1,000).
 
-- **2026-04-02**: Qwen3.6-Plus is now live! Sign in via Qwen OAuth to use it directly, or get an API key from [Alibaba Cloud ModelStudio](https://modelstudio.console.alibabacloud.com/ap-southeast-1?tab=doc#/doc/?type=model&url=2840914_2&modelId=qwen3.6-plus) to access it through the OpenAI-compatible API.
+- **2026-04-02**: Qwen3.6-Plus is now live! Get an API key from [Alibaba Cloud ModelStudio](https://modelstudio.console.alibabacloud.com/ap-southeast-1?tab=doc#/doc/?type=model&url=2840914_2&modelId=qwen3.6-plus) to access it through the OpenAI-compatible API.
 
 - **2026-02-16**: Qwen3.5-Plus is now live!
 
@@ -49,10 +49,12 @@ Qwen Code is an open-source AI agent for the terminal, optimized for Qwen series
 bash -c "$(curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen.sh)"
 ```
 
-#### Windows (Run as Administrator CMD)
+#### Windows (Run as Administrator)
+
+Works in both Command Prompt and PowerShell:
 
 ```cmd
-curl -fsSL -o %TEMP%\install-qwen.bat https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen.bat && %TEMP%\install-qwen.bat
+powershell -Command "Invoke-WebRequest 'https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen.bat' -OutFile (Join-Path $env:TEMP 'install-qwen.bat'); & (Join-Path $env:TEMP 'install-qwen.bat')"
 ```
 
 > **Note**: It's recommended to restart your terminal after installation to ensure environment variables take effect.
@@ -118,26 +120,16 @@ Then follow the instructions inside to install, authenticate, and use Qwen Code
 
 ## Authentication
 
-Qwen Code supports two authentication methods:
-
-- **Qwen OAuth (recommended & free)**: sign in with your `qwen.ai` account in a browser.
-- **API-KEY**: use an API key to connect to any supported provider (OpenAI, Anthropic, Google GenAI, Alibaba Cloud ModelStudio, and other compatible endpoints).
-
-#### Qwen OAuth (recommended)
-
-Start `qwen`, then run:
-
-```bash
-/auth
-```
+Qwen Code supports the following authentication methods:
 
-Choose **Qwen OAuth** and complete the browser flow. Your credentials are cached locally so you usually won't need to log in again.
+- **API Key (recommended)**: use an API key from Alibaba Cloud Model Studio ([Beijing](https://bailian.console.aliyun.com/) / [intl](https://modelstudio.console.alibabacloud.com/)) or any supported provider (OpenAI, Anthropic, Google GenAI, and other compatible endpoints).
+- **Coding Plan**: subscribe to the Alibaba Cloud Coding Plan ([Beijing](https://bailian.console.aliyun.com/cn-beijing?tab=coding-plan#/efm/coding-plan-index) / [intl](https://modelstudio.console.alibabacloud.com/?tab=coding-plan#/efm/coding-plan-index)) for a fixed monthly fee with higher quotas.
 
-> **Note:** In non-interactive or headless environments (e.g., CI, SSH, containers), you typically **cannot** complete the OAuth browser login flow. In these cases, please use the API-KEY authentication method.
+> ⚠️ **Qwen OAuth was discontinued on April 15, 2026.** If you were previously using Qwen OAuth, please switch to one of the methods above. Run `qwen` and then `/auth` to reconfigure.
 
-#### API-KEY (flexible)
+#### API Key (recommended)
 
-Use this if you want more flexibility over which provider and model to use. Supports multiple protocols:
+Use an API key to connect to Alibaba Cloud Model Studio or any supported provider. Supports multiple protocols:
 
 - **OpenAI-compatible**: Alibaba Cloud ModelStudio, ModelScope, OpenAI, OpenRouter, and other OpenAI-compatible providers
 - **Anthropic**: Claude models
@@ -357,6 +349,74 @@ Use the `/model` command at any time to switch between all configured models.
 
 > **Security note:** Never commit API keys to version control. The `~/.qwen/settings.json` file is in your home directory and should stay private.
 
+#### Local Model Setup (Ollama / vLLM)
+
+You can also run models locally — no API key or cloud account needed. This is not an authentication method; instead, configure your local model endpoint in `~/.qwen/settings.json` using the `modelProviders` field.
+
+<details>
+<summary>Ollama setup</summary>
+
+1. Install Ollama from [ollama.com](https://ollama.com/)
+2. Pull a model: `ollama pull qwen3:32b`
+3. Configure `~/.qwen/settings.json`:
+
+```json
+{
+  "modelProviders": {
+    "openai": [
+      {
+        "id": "qwen3:32b",
+        "name": "Qwen3 32B (Ollama)",
+        "baseUrl": "http://localhost:11434/v1",
+        "description": "Qwen3 32B running locally via Ollama"
+      }
+    ]
+  },
+  "security": {
+    "auth": {
+      "selectedType": "openai"
+    }
+  },
+  "model": {
+    "name": "qwen3:32b"
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>vLLM setup</summary>
+
+1. Install vLLM: `pip install vllm`
+2. Start the server: `vllm serve Qwen/Qwen3-32B`
+3. Configure `~/.qwen/settings.json`:
+
+```json
+{
+  "modelProviders": {
+    "openai": [
+      {
+        "id": "Qwen/Qwen3-32B",
+        "name": "Qwen3 32B (vLLM)",
+        "baseUrl": "http://localhost:8000/v1",
+        "description": "Qwen3 32B running locally via vLLM"
+      }
+    ]
+  },
+  "security": {
+    "auth": {
+      "selectedType": "openai"
+    }
+  },
+  "model": {
+    "name": "Qwen/Qwen3-32B"
+  }
+}
+```
+
+</details>
+
 ## Usage
 
 As an open-source terminal agent, you can use Qwen Code in four primary ways:
@@ -459,6 +519,10 @@ Looking for a graphical interface?
 
 If you encounter issues, check the [troubleshooting guide](https://qwenlm.github.io/qwen-code-docs/en/users/support/troubleshooting/).
 
+**Common issues:**
+
+- **`Qwen OAuth free tier was discontinued on 2026-04-15`**: Qwen OAuth is no longer available. Run `qwen` → `/auth` and switch to API Key or Coding Plan. See the [Authentication](#authentication) section above for setup instructions.
+
 To report a bug from within the CLI, run `/bug` and include a short title and repro steps.
 
 ## Connect with Us

package/bundled/batch/SKILL.md

@@ -0,0 +1,303 @@
+---
+name: batch
+description: Execute batch operations on multiple files in parallel. Automatically discovers files, splits into chunks, and processes with parallel worker agents. Use `/batch` followed by operation and file pattern.
+allowedTools:
+  - task
+  - glob
+  - grep_search
+  - read_file
+  - edit
+  - write_file
+  - run_shell_command
+  - ask_user_question
+---
+
+# /batch - Parallel Batch Operations
+
+You are orchestrating a batch operation across multiple files. Your job is to:
+
+1. Parse the user's request to understand the target files and operation
+2. Discover matching files using glob
+3. Split files into chunks for parallel processing
+4. Launch multiple worker agents to process files concurrently
+5. Aggregate results and present a summary
+
+## Step 1: Parse Intent and Discover Files
+
+First, parse the user's request to identify:
+
+- **Target pattern**: glob pattern for files (e.g., `src/**/*.ts`, `**/*.js`)
+- **Operation**: what to do with each file (e.g., "add JSDoc comments", "convert to TypeScript")
+
+If the user didn't specify a pattern, infer it from context or ask for clarification.
+
+Use the `glob` tool to discover matching files.
+
+**If no files match the pattern**:
+
+- Inform the user that no files were found for the given pattern
+- Suggest checking the pattern or broadening the search scope
+- Do not proceed with an empty batch
+
+Apply these common exclusions automatically:
+
+- `node_modules/**`
+- `dist/**`
+- `build/**`
+- `.git/**`
+- `**/*.test.ts`, `**/*.test.js`
+- `**/*.spec.ts`, `**/*.spec.js`
+- `**/__tests__/**`
+- `**/test/**`, `**/tests/**`
+- `**/package-lock.json`
+- `**/yarn.lock`
+- `**/*.min.js`
+- Binary files (images, fonts, etc.)
+- Files larger than 500KB (check size if needed)
+
+**Important**: If more than 50 files match, inform the user with the exact count and the file list, then proceed. The user can cancel (Ctrl+C) if needed. If the count exceeds 100 files, warn the user and suggest a more specific pattern instead of proceeding.
+
+## Step 2: Chunk Files for Parallel Processing
+
+Split the discovered files into chunks based on these rules:
+
+| Total Files | Chunk Count | Files Per Chunk |
+| ----------- | ----------- | --------------- |
+| 1-5         | 1           | All files       |
+| 6-15        | 2           | 3-8 each        |
+| 16-30       | 3           | ~10 each        |
+| 31-50       | 4           | ~10-12 each     |
+| 51-75       | 5           | ~10-15 each     |
+| 76-100      | 5           | ~15-20 each     |
+
+**Chunking algorithm**:
+
+- Minimum chunk size: 3 files (avoid over-parallelization for small batches)
+- Maximum chunk size: 15 files (ensure reasonable work per agent)
+- Maximum parallel agents: 5 (API rate limit consideration)
+
+Example: 24 files → 3 chunks of ~8 files each
+
+## Step 3: Launch Parallel Worker Agents
+
+Launch worker agents **in parallel** by invoking the `task` tool (the Agent tool) multiple times in a **SINGLE message**.
+
+**Note**: The `task` tool in allowedTools is the Agent tool used to spawn worker agents.
+
+Each worker agent should receive:
+
+- The list of files to process (full paths)
+- The operation to perform
+- Clear instructions to report success/failure per file
+
+Use the `general-purpose` subagent type for workers.
+
+**CRITICAL**: All Agent tool calls MUST be in a single response to enable parallel execution. The system automatically runs multiple Agent calls concurrently.
+
+### Agent Prompt Template
+
+For each chunk, use this prompt format:
+
+```
+You are a worker agent processing a batch of files.
+
+**Operation**: [describe the operation, e.g., "Add JSDoc comments to all exported functions"]
+
+**Files to process**:
+- [file1.ts]
+- [file2.ts]
+- ...
+
+**Instructions**:
+1. Process each file independently
+2. For each file, report one of:
+   - SUCCESS: [file path] - [brief description of change]
+   - FAILED: [file path] - [reason for failure]
+   - SKIPPED: [file path] - [reason for skipping]
+3. If a file fails or is skipped, continue with the next file - do not abort
+4. At the end, provide a summary of what was done
+
+**Constraints**:
+- Do not modify test files unless explicitly requested
+- Preserve existing code style and formatting
+- Make minimal necessary changes to accomplish the operation
+```
+
+### Example Invocation Pattern
+
+```
+<Agent tool call 1>
+description: "Process batch chunk 1/3"
+prompt: "You are a worker agent... [full prompt as above]"
+subagent_type: "general-purpose"
+</Agent tool call 1>
+
+<Agent tool call 2>
+description: "Process batch chunk 2/3"
+prompt: "You are a worker agent... [full prompt as above]"
+subagent_type: "general-purpose"
+</Agent tool call 2>
+
+<Agent tool call 3>
+description: "Process batch chunk 3/3"
+prompt: "You are a worker agent... [full prompt as above]"
+subagent_type: "general-purpose"
+</Agent tool call 3>
+```
+
+## Step 4: Aggregate Results
+
+After all worker agents complete, aggregate their results into a clear summary.
+
+### Output Format
+
+```markdown
+### Batch Operation Complete
+
+**Operation**: [description of what was done]
+**Files discovered**: [total count]
+**Chunks processed**: [number of parallel agents]
+**Total time**: [duration if tracked]
+
+| Status  | Count |
+| ------- | ----- |
+| Success | [N]   |
+| Failed  | [N]   |
+| Skipped | [N]   |
+
+**Successful files**:
+
+- [file1.ts] - [brief description]
+- [file2.ts] - [brief description]
+  ...
+
+**Failed files** (if any):
+
+- [file.ts]: [reason for failure]
+
+**Skipped files** (if any):
+
+- [file.ts]: [reason for skipping]
+```
+
+### Handling Partial Failures
+
+If some files failed but others succeeded:
+
+- Clearly report which files succeeded
+- List failures with specific reasons
+- Suggest follow-up actions if appropriate
+
+If all files failed:
+
+- Report the common failure pattern
+- Suggest potential fixes
+
+## Step 5: Error Handling
+
+### During Batch Processing
+
+1. **Single file failure**: Don't abort the batch. The worker agent records the error and continues.
+2. **Agent failure**: If a worker agent fails completely (timeout, crash), note the chunk as failed with reason.
+3. **User cancellation**: If the user sends Ctrl+C, the system will cancel all pending agents gracefully.
+
+### Error Reporting
+
+For each failed file, include:
+
+- File path
+- Specific error message or reason
+- Suggested fix if obvious
+
+## Usage Examples
+
+### Example 1: Add License Headers
+
+```
+/batch Add Apache 2.0 license header to all .ts files in src/
+```
+
+**Flow**:
+
+1. glob `src/**/*.ts` → find 45 files
+2. Split into 4 chunks
+3. Launch 4 parallel agents
+4. Each agent adds the license header to its assigned files
+5. Summary: 45 files processed, 45 succeeded, 0 failed
+
+### Example 2: Convert JavaScript to TypeScript
+
+```
+/batch Convert all .js files in utils/ to TypeScript
+```
+
+**Flow**:
+
+1. glob `utils/**/*.js` → find 12 files
+2. Split into 2 chunks
+3. Launch 2 parallel agents
+4. Each agent converts files and renames to .ts
+5. Summary: 12 files processed, 10 succeeded, 2 failed (complex dynamic patterns)
+
+### Example 3: Fix Lint Errors
+
+```
+/batch Fix all @typescript-eslint/no-explicit-any errors in src/
+```
+
+**Flow**:
+
+1. Use `grep_search` to find files containing `: any` pattern in `src/`
+2. Filter to relevant files
+3. Split into chunks and launch parallel agents
+4. Each agent fixes the specific lint issue (replace `any` with proper types)
+5. Summary: 8 files fixed
+
+## Constraints and Limits
+
+| Constraint          | Value | Reason                       |
+| ------------------- | ----- | ---------------------------- |
+| Max files per batch | 100   | Prevent resource exhaustion  |
+| Max parallel agents | 5     | API rate limit consideration |
+| Min files per agent | 3     | Avoid over-parallelization   |
+| Max files per agent | 15    | Ensure meaningful work       |
+| File size limit     | 500KB | Avoid context overflow       |
+
+## Dry-Run Mode
+
+If the user wants to preview what will be changed without actually modifying files (e.g., "preview", "show me what would change", "dry run"):
+
+1. Discover and list all matching files with counts
+2. Show the planned operation for each file
+3. Display the chunking strategy
+4. Ask the user if they want to proceed with the actual changes
+5. If user confirms, execute the batch operation
+
+**Example**:
+
+```
+/batch preview adding JSDoc comments to src/**/*.ts
+```
+
+**Expected output**:
+
+```
+### Dry-Run Preview
+
+**Operation**: Add JSDoc comments to all .ts files in src/
+
+**Files discovered**: 24 files
+
+**Chunking plan**:
+| Chunk | Files |
+|-------|-------|
+| 1     | src/utils/a.ts, b.ts, c.ts, ... (8 files) |
+| 2     | src/components/x.ts, y.ts, ... (8 files) |
+| 3     | src/services/m.ts, n.ts, ... (8 files) |
+
+**Planned operation per file**:
+- Add JSDoc comments to all exported functions
+- Preserve existing code style
+
+Proceed? (y/n)
+```