copilot-custom-endpoint 1.3.0 → 1.3.1

package/docs/models/minimax.md

@@ -0,0 +1,247 @@
+# MiniMax — VS Code Custom Endpoint Setup Guide
+
+> **TL;DR:** MiniMax-M3 works directly — no proxy needed. Use `thinking: { type: "adaptive" }` + `reasoning_split: true` in `requestBody` so the model can reason and the response arrives in a clean OpenAI format (`reasoning_details` field, separate from `content`). **Important:** `thinking: { type: "disabled" }` is **not** a hard override — the model still reasons internally and emits `<think>` tags / `reasoning_content` regardless.
+
+## At a Glance
+
+| Field                    | Value                                                   |
+| ------------------------ | ------------------------------------------------------- |
+| Mode                     | **Direct** (no proxy)                                   |
+| Vision                   | ✅ Yes (image + video)                                  |
+| Tool calling             | ✅ Yes                                                  |
+| Context                  | 1M (guaranteed 512K)                                    |
+| Max output               | 512K (recommended 128K)                                 |
+| Required `requestBody`   | `thinking: { type: "adaptive" }, reasoning_split: true` |
+| Endpoint (international) | `https://api.minimax.io/v1/chat/completions`            |
+| Endpoint (China)         | `https://api.minimaxi.com/v1/chat/completions`          |
+
+## Quick Start
+
+1. **Edit `chatLanguageModels.json`** — add the MiniMax block from [Setup](#setup) below.
+2. **Set your `MINIMAX_API_KEY`** via Command Palette → **Chat: Manage Language Models**.
+3. **Restart VS Code** and pick "MiniMax M3" in the chat picker.
+
+## Setup
+
+### 1. VS Code configuration
+
+Config file location:
+
+| OS      | Path                                                              |
+| ------- | ----------------------------------------------------------------- |
+| Windows | `%APPDATA%\Code\User\chatLanguageModels.json`                     |
+| macOS   | `~/Library/Application Support/Code/User/chatLanguageModels.json` |
+| Linux   | `~/.config/Code/User/chatLanguageModels.json`                     |
+
+```json
+{
+  "name": "MiniMax",
+  "vendor": "customendpoint",
+  "apiKey": "",
+  "apiType": "chat-completions",
+  "models": [
+    {
+      "id": "MiniMax-M3",
+      "name": "MiniMax M3",
+      "url": "https://api.minimax.io/v1/chat/completions",
+      "toolCalling": true,
+      "vision": true,
+      "streaming": true,
+      "maxInputTokens": 1048576,
+      "maxOutputTokens": 131072,
+      "requestBody": {
+        "thinking": { "type": "adaptive" },
+        "reasoning_split": true,
+        "temperature": 1,
+        "top_p": 0.95
+      }
+    }
+  ]
+}
+```
+
+### 2. API key
+
+1. Open the Command Palette (`Ctrl+Shift+P`).
+2. Run **Chat: Manage Language Models**.
+3. Find the **MiniMax** group → **Update API Key**.
+4. Paste your MiniMax API key.
+
+> After setting via the UI, VS Code replaces `"apiKey": ""` with a `${input:chat.lm.secret.<id>}` reference.
+
+### 3. Regional endpoints
+
+| Region        | Endpoint                                       |
+| ------------- | ---------------------------------------------- |
+| International | `https://api.minimax.io/v1/chat/completions`   |
+| China         | `https://api.minimaxi.com/v1/chat/completions` |
+
+> API keys are region-specific and cannot be used across regions.
+
+## Configuration Reference
+
+### Sampling parameters
+
+| Task type            | `temperature` | `top_p` |
+| -------------------- | ------------- | ------- |
+| Agentic / tool-use   | `1.0`         | `0.95`  |
+| Coding               | `1.0`         | `0.95`  |
+| General conversation | `1.0`         | `0.95`  |
+
+M3 accepts `temperature` in `[0, 2]` and `top_p` in `[0, 1]`.
+
+### Thinking mode
+
+| `thinking.type` | Behavior                                                                                                                                                          |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `adaptive`      | **Recommended.** Model decides whether to think.                                                                                                                  |
+| `disabled`      | Soft hint only — the model still reasons internally and emits `<think>` / `reasoning_content` regardless. Use only if you want a different response field layout. |
+
+When thinking is enabled (any mode), the server returns thinking in one of two formats:
+
+1. **Native** (default): thinking is embedded in `content` wrapped in `<think>` tags.
+2. **Interleaved Thinking** (`reasoning_split: true`): thinking is separated into a `reasoning_details` field for cleaner programmatic access.
+
+VS Code will most likely **ignore** the extra `reasoning_details` / `reasoning_content` / `delta.reasoning` fields it doesn't recognize, so `reasoning_split: true` is the cleanest way to keep `content` clean.
+
+### Capabilities
+
+- Streaming (SSE, standard OpenAI format).
+- Tool calling with `tool_choice: "auto"`.
+- Vision: image and video understanding (M3 only).
+- Native multimodal training from step zero.
+- Interleaved Thinking: model can reason between each round of tool interactions.
+- Automatic prompt caching (no configuration needed).
+- 1M context enables long-range agent tasks, long-horizon coding, and long-video understanding.
+
+### Rate limits
+
+| Model        | RPM | TPM        |
+| ------------ | --- | ---------- |
+| `MiniMax-M3` | 200 | 10,000,000 |
+
+> Input tokens above 512K are available in limited quantity for a limited time. Contact sales for access.
+
+### Model ID casing
+
+MiniMax model IDs are **case-sensitive**. Use exactly:
+
+- `MiniMax-M3` (not `minimax-m3` or `MINIMAX-M3`)
+
+## Troubleshooting
+
+| Symptom                        | Likely cause                                           | Fix                                                      |
+| ------------------------------ | ------------------------------------------------------ | -------------------------------------------------------- |
+| Model not in picker            | Config not reloaded, or wrong casing                   | Restart VS Code; verify model ID is exactly `MiniMax-M3` |
+| Reasoning leaks into `content` | Missing `reasoning_split`                              | Add `reasoning_split: true` to `requestBody`             |
+| 401 Unauthorized               | API key region mismatch                                | Use the endpoint that matches your key's region          |
+| 429 rate-limited               | Concurrent sessions exceeded 200 RPM / 10M TPM         | Reduce concurrent agent sessions                         |
+| Vision request returns 400     | Vision only supported on M3 (not the legacy M2.x line) | Use `MiniMax-M3`                                         |
+
+## Pricing
+
+For the cross-provider comparison, see [docs/pricing.md](../pricing.md). MiniMax-M3 pay-as-you-go rates:
+
+| Token range           | Input (Cache Hit) | Input (Cache Miss) | Output     |
+| --------------------- | ----------------- | ------------------ | ---------- |
+| ≤ 512K input tokens   | $0.12 / 1M        | $0.60 / 1M         | $2.40 / 1M |
+| > 512K input tokens\* | $0.24 / 1M        | $1.20 / 1M         | $4.80 / 1M |
+
+\* Input tokens above 512K are available in limited quantity for a limited time.
+
+> **Promo:** A 7-day 50% off promotion is available for new accounts, making the ≤ 512K tier effectively $0.30 / 1M input and $1.20 / 1M output for the first week.
+
+### Token Plan (subscription)
+
+MiniMax also offers monthly subscription plans with quota that resets each month (Plus $20/mo, Max $50/mo, Ultra $120/mo). All plans provide access to all models. See the [MiniMax Token Plan page](https://platform.minimax.io/docs/guides/pricing-token-plan) for details.
+
+---
+
+## Background & Findings
+
+> This appendix preserves the validation narrative for future reference. It is not required to use the model.
+
+### The `thinking` parameter is a soft hint
+
+The `thinking: { "type": "disabled" }` parameter does **not** suppress `<think>` tags or `reasoning_content` in responses — the model always reasons internally. The setting is a layout hint, not a behavioral override.
+
+This is the key insight behind the recommended config:
+
+- `thinking: { type: "adaptive" }` lets the model decide when to reason (which is "always" in practice).
+- `reasoning_split: true` tells the server to put the reasoning into a structured `reasoning_details` field, keeping `content` clean for VS Code.
+
+If you have an older config that uses `disabled` (e.g., to mirror the MiMo convention), it will still work — the difference vs `adaptive` is purely cosmetic (response field layout). The model remains stable in 3-turn tool loops under both settings.
+
+### Architecture
+
+- **Model:** MiniMax-M3 (multimodal frontier coding model).
+- **Architecture:** Novel MiniMax Sparse Attention (MSA) — designed for 1M context with low latency.
+- **Training:** Native multimodal training from step zero with 100T+ data, deep alignment between textual and visual semantic spaces.
+
+### Validation results (June 3, 2026)
+
+#### Phase 1 — Connectivity check
+
+| Check              | Result | Notes                                                                                 |
+| ------------------ | ------ | ------------------------------------------------------------------------------------- |
+| Non-streaming chat | ✅     | Model responded with `<think>` reasoning + greeting content                           |
+| Streaming (SSE)    | ✅     | Chunks arrive as `data: {...}` with incremental `delta.content` and `delta.reasoning` |
+| Tool calling       | ✅     | `finish_reason: "tool_calls"` with `get_weather({"location": "San Francisco"})`       |
+| Vision             | ✅     | Correctly identified Google logo colors (blue, red, yellow, green) from PNG URL       |
+
+**Key Phase 1 finding:** `thinking: {"type": "disabled"}` does not suppress reasoning — the model still emits `<think>` tags and `reasoning_content`. This is why the recommended config uses `adaptive` + `reasoning_split: true`.
+
+#### Phase 2 — VS Code in-editor validation
+
+The Copilot Chat panel in the validation session was running on `MiniMax M3`, making every response a live test.
+
+| Step                                    | Result | Evidence                                                                                                |
+| --------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------- |
+| Add config to `chatLanguageModels.json` | ✅     | `MiniMax M3` appears in the model picker                                                                |
+| Open VS Code and select the model       | ✅     | Screenshot confirms "MiniMax M3" selected                                                               |
+| Plain chat                              | ✅     | Coherent answer to "What do you mean by streaming in this context?"                                     |
+| Streaming                               | ✅     | Text appeared progressively in the chat panel                                                           |
+| Tool calling (agent mode)               | ✅     | `open_browser_page` invoked successfully → "Google" page title confirmed                                |
+| Vision                                  | ✅     | Facebook screenshot analyzed in detail (10 tabs, sidebar items, post content, birthdays, Reels section) |
+
+#### Phase 3 — Multi-turn tool loop test
+
+Asked the model to inspect a YouTube video (`https://www.youtube.com/watch?v=rAzT5lcezPs`) using videoMcp tools. The model chained three tool calls:
+
+| #   | Tool                                          | Result                                                                                                         |
+| --- | --------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| 1   | `mcp_videomcp_get_video_info`                 | ✅ 17 min 6 sec, 1280×720 @ 30 fps, h264, 96 MB                                                                |
+| 2   | `mcp_videomcp_analyze_video` (Gemini backend) | ✅ Identified presenter (PewDiePie), topic (Odysseus — local self-hosted AI workspace), key features, sponsors |
+| 3   | `mcp_videomcp_transcribe_video` (Deepgram)    | ✅ 17 KB transcript written to file                                                                            |
+
+**Findings:**
+
+- ✅ All three tool calls succeeded without errors.
+- ✅ Model chained calls logically (metadata → analysis → transcript) rather than asking the user to re-prompt.
+- ✅ Each tool result was incorporated into subsequent reasoning.
+- ✅ No `<think>` tag or `reasoning_content` degradation observed mid-conversation — the multi-turn loop did not visibly break the model, contradicting the original Phase 1 worry that `<think>` tags would cause problems.
+
+#### Phase 4 — Long-context test
+
+**Skipped.** The 1M context claim is well-supported by MiniMax's published benchmarks, and the curl test in Phase 1 confirmed single-turn support for multi-KB prompts. The long-context pressure-test is deferred until a real workload requires it.
+
+### Final verdict
+
+- Acceptable for plain chat: **yes**
+- Acceptable for streaming chat: **yes**
+- Acceptable for tool-enabled agent use: **yes**
+- Acceptable for vision: **yes**
+- Acceptable without a proxy: **yes**
+
+## References
+
+- MiniMax Official Website: `https://www.minimax.io/`
+- MiniMax API Documentation: `https://platform.minimax.io/docs/guides/models-intro`
+- MiniMax M3 Model Page: `https://www.minimax.io/models/text/m3`
+- MiniMax Text Generation Guide: `https://platform.minimax.io/docs/guides/text-generation`
+- MiniMax Tool Use & Interleaved Thinking: `https://platform.minimax.io/docs/guides/text-m3-function-call`
+- MiniMax Pricing: `https://platform.minimax.io/docs/pricing/overview`
+- MiniMax Pay as You Go: `https://platform.minimax.io/docs/guides/pricing-paygo`
+- MiniMax Token Plan: `https://platform.minimax.io/docs/guides/pricing-token-plan`
+- MiniMax Rate Limits: `https://platform.minimax.io/docs/guides/rate-limits`
+- MiniMax M3 for AI Coding Tools: `https://platform.minimax.io/docs/guides/text-ai-coding-tools`

package/docs/models/qwen.md

@@ -0,0 +1,320 @@
+# Qwen (DashScope) — VS Code Custom Endpoint Setup Guide
+
+> **TL;DR:** Direct path works for both `qwen3.6-plus` (vision) and `qwen3.7-max` (text-only) without a proxy. The optional `proxy/qwen-proxy.mjs` adds dynamic thinking suppression: reasoning stays ON in plain chat but turns OFF automatically when tools are invoked. Pick the mode that matches your tradeoff.
+
+## At a Glance
+
+| Field                           | Value                                                                     |
+| ------------------------------- | ------------------------------------------------------------------------- |
+| Mode                            | **Direct** (no proxy) **or** **Proxy** (optional, for dynamic thinking)   |
+| Vision                          | ✅ Yes (`qwen3.6-plus` only)                                              |
+| Tool calling                    | ✅ Yes                                                                    |
+| Context                         | 1M                                                                        |
+| Required `requestBody` (direct) | `enable_thinking: false`                                                  |
+| Required `requestBody` (proxy)  | none — proxy injects based on `tools` presence                            |
+| Endpoint                        | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions` |
+| Proxy endpoint                  | `http://127.0.0.1:3458/v1/chat/completions`                               |
+
+### Models at a glance
+
+| Model          | Vision | Role                                   |
+| -------------- | ------ | -------------------------------------- |
+| `qwen3.6-plus` | ✅ Yes | Primary model with image understanding |
+| `qwen3.7-max`  | ❌ No  | Larger text-only model                 |
+
+> The snapshot `qwen3.6-plus-2026-04-02` is also available; the floating `qwen3.6-plus` alias is preferred.
+
+## Quick Start — Direct Path (Recommended for Simplicity)
+
+1. **Edit `chatLanguageModels.json`** — add the Qwen block from [Setup § Direct](#direct-path) below.
+2. **Set your `DASHSCOPE_API_KEY`** via Command Palette → **Chat: Manage Language Models**.
+3. **Restart VS Code** and pick "Qwen 3.6 Plus" or "Qwen 3.7 Max".
+
+## Quick Start — With Proxy (Dynamic Thinking)
+
+1. **Start the proxy:** `npm run proxy:qwen`.
+2. **Edit `chatLanguageModels.json`** — use the proxy-path block from [Setup § Proxy](#proxy-path) below.
+3. **Set your DashScope API key** via the Language Models UI.
+4. **Restart VS Code.** Reasoning will be visible in plain chat and suppressed on tool turns.
+
+## Setup
+
+### Regional endpoints
+
+DashScope is region-specific — your API key only works on the endpoint it was created for:
+
+| Region                             | Endpoint                                                                  |
+| ---------------------------------- | ------------------------------------------------------------------------- |
+| **Singapore (used in this guide)** | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions` |
+| China (Beijing)                    | `https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions`      |
+| US (Virginia)                      | `https://dashscope-us.aliyuncs.com/compatible-mode/v1/chat/completions`   |
+
+### Direct path
+
+```json
+{
+  "name": "Qwen",
+  "vendor": "customendpoint",
+  "apiKey": "",
+  "apiType": "chat-completions",
+  "models": [
+    {
+      "id": "qwen3.7-max",
+      "name": "Qwen 3.7 Max",
+      "url": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions",
+      "toolCalling": true,
+      "vision": false,
+      "streaming": true,
+      "requestBody": {
+        "enable_thinking": false
+      }
+    },
+    {
+      "id": "qwen3.6-plus",
+      "name": "Qwen 3.6 Plus",
+      "url": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions",
+      "toolCalling": true,
+      "vision": true,
+      "streaming": true,
+      "requestBody": {
+        "enable_thinking": false
+      }
+    }
+  ]
+}
+```
+
+> **`enable_thinking: false`** suppresses the Qwen3 family's default thinking mode, which prevents `reasoning_content` issues during tool loops.
+
+### Proxy path
+
+#### 1. Start the proxy
+
+```bash
+node proxy/qwen-proxy.mjs
+```
+
+Expected output:
+
+```
+[qwen-proxy] listening on http://127.0.0.1:3458/v1/chat/completions
+[qwen-proxy] forwarding to https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions
+```
+
+Verify it's alive:
+
+```bash
+curl http://127.0.0.1:3458/healthz
+```
+
+Expected response:
+
+```json
+{
+  "ok": true,
+  "upstreamUrl": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions",
+  "port": 3458,
+  "disableThinkingWithTools": true
+}
+```
+
+#### 2. Update VS Code config — point URLs to the proxy and remove `requestBody.enable_thinking`
+
+```json
+{
+  "name": "Qwen",
+  "vendor": "customendpoint",
+  "apiKey": "",
+  "apiType": "chat-completions",
+  "models": [
+    {
+      "id": "qwen3.7-max",
+      "name": "Qwen 3.7 Max",
+      "url": "http://127.0.0.1:3458/v1/chat/completions",
+      "toolCalling": true,
+      "vision": false,
+      "streaming": true
+    },
+    {
+      "id": "qwen3.6-plus",
+      "name": "Qwen 3.6 Plus",
+      "url": "http://127.0.0.1:3458/v1/chat/completions",
+      "toolCalling": true,
+      "vision": true,
+      "streaming": true
+    }
+  ]
+}
+```
+
+> **Keep the proxy terminal open** while using Qwen via proxy.
+
+#### Proxy environment variables
+
+All can be set in a `.env` file at the repo root (both proxies `import 'dotenv/config'` automatically).
+
+| Variable                                 | Default                                                                   | Purpose                                            |
+| ---------------------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------- |
+| `QWEN_PROXY_PORT`                        | `3458` (falls back to `PORT`)                                             | Local listen port                                  |
+| `QWEN_UPSTREAM_URL`                      | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions` | Upstream DashScope endpoint                        |
+| `QWEN_PROXY_LOG`                         | `debug_log/qwen-proxy.ndjson` (relative to repo root)                     | Redacted NDJSON log path                           |
+| `QWEN_PROXY_DISABLE_THINKING_WITH_TOOLS` | `1`                                                                       | Set to `0` to skip tool-aware thinking suppression |
+
+#### Proxy request rewriting rules
+
+| Condition                                | Action                                                      |
+| ---------------------------------------- | ----------------------------------------------------------- |
+| `body.tools` is a non-empty array        | Set `body.enable_thinking = false`                          |
+| `body.tools` is missing, empty, or falsy | Delete `body.enable_thinking` (let model default to `true`) |
+
+> **Why delete rather than set `true`?** Omitting the key lets Qwen use its built-in default (`true`). Deletion is closer to "don't interfere."
+
+### API key
+
+1. Open the Command Palette (`Ctrl+Shift+P`).
+2. Run **Chat: Manage Language Models**.
+3. Find the **Qwen** group → **Update API Key**.
+4. Paste your DashScope API key.
+
+> After setting via the UI, VS Code replaces `"apiKey": ""` with a `${input:chat.lm.secret.<id>}` reference.
+
+## Configuration Reference
+
+### Thinking mode
+
+The Qwen3 hybrid-thinking models default to `enable_thinking: true`, producing `reasoning_content` in responses. This is **harmless in plain chat** (you see the model's reasoning) but **breaks agent/tool-calling loops**: VS Code may not preserve `reasoning_content` in follow-up tool-result messages, and the model may reject the continuation.
+
+| Mode                | Plain chat                      | Tool turns                    |
+| ------------------- | ------------------------------- | ----------------------------- |
+| Direct path         | Thinking OFF (always)           | Thinking OFF                  |
+| Proxy path          | Thinking ON (default preserved) | Thinking OFF (auto-injected)  |
+| No config (default) | Thinking ON                     | Risk: history may be rejected |
+
+### Vision (`qwen3.6-plus` only)
+
+- Image input via OpenAI-compatible `content` array format (base64 data URIs).
+- **External image URLs may fail** if DashScope's servers cannot reach them — base64-encoded images work reliably.
+
+### Capabilities
+
+- Streaming (SSE, `data: [DONE]` terminator).
+- Tool calling with `tools` array and `tool_calls` response.
+- Vision (image input) on `qwen3.6-plus` only.
+- Non-OpenAI extras: `enable_thinking`, `thinking_budget`, `enable_search` (via `extra_body`).
+
+## Troubleshooting
+
+| Symptom                                         | Likely cause                                 | Fix                                                                                                          |
+| ----------------------------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| "Connection refused" (proxy mode)               | Proxy not running                            | `npm run proxy:qwen`                                                                                         |
+| Tool loops fail with `reasoning_content` errors | Direct path missing `enable_thinking: false` | Add `enable_thinking: false` to `requestBody`                                                                |
+| Tool loops still fail with proxy                | Proxy not rewriting                          | Check `debug_log/qwen-proxy.ndjson` — verify `hasTools: true` requests have `rewrittenEnableThinking: false` |
+| Vision fails with external image URL            | DashScope couldn't reach the URL             | Use a base64 data URI instead                                                                                |
+| 401 Unauthorized                                | API key region mismatch                      | Match your key to the regional endpoint                                                                      |
+| Intermittent `net::ERR_CONNECTION_RESET`        | Transient VS Code / Electron transport       | Retry; not reproducible via `curl` or Node.js                                                                |
+| Want to switch back to direct                   | Proxy mode active                            | Revert `url` to DashScope endpoint and restore `requestBody.enable_thinking: false`                          |
+
+## Pricing
+
+For the cross-provider comparison, see [docs/pricing.md](../pricing.md). DashScope (international) rates for **non-thinking** mode:
+
+| Model          | Input (≤ 256K tokens) | Input (> 256K tokens) | Output (≤ 256K tokens) | Output (> 256K tokens) |
+| -------------- | --------------------- | --------------------- | ---------------------- | ---------------------- |
+| `qwen3.6-plus` | $0.50 / 1M            | $2.00 / 1M            | $3.00 / 1M             | $6.00 / 1M             |
+| `qwen3.7-max`  | $2.50 / 1M (≤ 1M)     | —                     | $7.50 / 1M (≤ 1M)      | —                      |
+
+> **Free quota:** DashScope offers 1M input + 1M output tokens per model, valid for 90 days after activating Model Studio.
+
+---
+
+## Background & Findings
+
+> This appendix preserves the validation narrative for future reference. It is not required to use the model.
+
+### Why a proxy is useful (and why a static `enable_thinking: false` is enough)
+
+Both work — pick based on your preference:
+
+- **Direct path** is the simplest: static `enable_thinking: false` suppresses reasoning in all requests. Tool loops stay stable. Trade-off: you never see the model's thought process.
+- **Proxy path** is dynamic: reasoning stays ON in plain chat (you see it), and the proxy automatically sets `enable_thinking: false` when `tools` is present (loops stay stable). Best of both worlds, at the cost of running a local process.
+
+### Validation results (June 1, 2026)
+
+#### Proxy validation (8 checks, all passed)
+
+| #   | Check                                    | Result                                                                           |
+| --- | ---------------------------------------- | -------------------------------------------------------------------------------- |
+| 1   | Proxy starts                             | ✅ `--help` prints correct usage and defaults                                    |
+| 2   | Health check                             | ✅ Returns `{"ok":true,"port":3458,...}`                                         |
+| 3   | Plain chat (no tools) → thinking ON      | ✅ Response contains `reasoning_content`; `enable_thinking` deleted              |
+| 4   | Tool chat (tools present) → thinking OFF | ✅ No `reasoning_content`; clean `tool_calls`; `enable_thinking: false` injected |
+| 5   | Streaming passthrough                    | ✅ SSE chunks arrive correctly with `text/event-stream`                          |
+| 6   | Error passthrough                        | ✅ Invalid JSON returns HTTP 400 with useful error message                       |
+| 7   | Auth passthrough                         | ✅ Missing key → 401; valid key → 200                                            |
+| 8   | Logging                                  | ✅ All entries redact `Authorization: Bearer <redacted>`                         |
+
+#### Direct-path validation — `qwen3.7-max`
+
+| Capability                                   | Result | Notes                                                                  |
+| -------------------------------------------- | ------ | ---------------------------------------------------------------------- |
+| Non-streaming chat (curl)                    | ✅     | HTTP 200, valid assistant message; `reasoning_content` present         |
+| Streaming chat (curl)                        | ✅     | HTTP 200, SSE chunks; `reasoning_content` streamed alongside `content` |
+| Tool-enabled chat (thinking on)              | ✅     | HTTP 200, `finish_reason: tool_calls` — `reasoning_content` present    |
+| Tool-enabled chat (`enable_thinking: false`) | ✅     | HTTP 200, clean OpenAI shape, no `reasoning_content`, 25 tokens vs 170 |
+| Model appears in VS Code picker              | ✅     | "Agent \| Qwen 3.7 Max" confirmed                                      |
+| Plain chat in VS Code                        | ✅     | Streaming output confirmed                                             |
+| Streaming in VS Code                         | ✅     | Token-by-token streaming confirmed                                     |
+| Tool / agent use in VS Code                  | ✅     | Browser tool invoked successfully                                      |
+
+#### Direct-path validation — `qwen3.6-plus`
+
+| Capability                                   | Result | Notes                                                                        |
+| -------------------------------------------- | ------ | ---------------------------------------------------------------------------- |
+| Non-streaming chat (curl)                    | ✅     | HTTP 200; `reasoning_content` present (727 reasoning tokens)                 |
+| Streaming chat (curl)                        | ✅     | SSE chunks with `reasoning_content` deltas streaming correctly               |
+| Tool-enabled chat (`enable_thinking: false`) | ✅     | Clean `tool_calls`, no `reasoning_content`, 25 tokens                        |
+| Vision: image + text (curl, base64)          | ✅     | Model correctly identified a 10×10 test pattern; `image_tokens: 66`          |
+| Vision: image + text (curl, external URL)    | ❌     | `Failed to download multimodal content` — DashScope couldn't reach Wikipedia |
+| Model appears in VS Code picker              | ✅     | "Agent \| Qwen 3.6 Plus" confirmed                                           |
+| Plain chat in VS Code                        | ✅     | Streaming output confirmed                                                   |
+| Streaming in VS Code                         | ✅     | Token-by-token streaming confirmed                                           |
+| Tool / agent use in VS Code                  | ✅     | Browser tool invoked to open Qwen docs and Google                            |
+| Vision in VS Code                            | ✅     | Image attachment analyzed correctly                                          |
+
+#### Intermittent `ERR_CONNECTION_RESET` investigation
+
+A `net::ERR_CONNECTION_RESET` was observed once during `qwen3.6-plus` validation, but did not reproduce on the same machine outside VS Code:
+
+- Direct `curl` POST to DashScope Singapore → HTTP 200.
+- Direct Node.js HTTPS POST → HTTP 200.
+- Direct Node.js HTTPS **streaming** POST with full `qwen3.6-plus.md` content embedded → HTTP 200.
+
+Conclusion: not a DashScope or Qwen model incompatibility. Evidence points to an intermittent VS Code / Electron transport issue or transient network interruption local to the editor process.
+
+### Final verdict
+
+| Criterion              | `qwen3.7-max`  | `qwen3.6-plus` |
+| ---------------------- | -------------- | -------------- |
+| Plain chat             | ✅             | ✅             |
+| Streaming chat         | ✅             | ✅             |
+| Tool-enabled agent use | ✅             | ✅             |
+| Vision                 | ❌ (text-only) | ✅             |
+| Without a proxy        | ✅             | ✅             |
+
+### Known limitations
+
+- GitHub Copilot inline completions and semantic-search features remain outside scope.
+- One intermittent VS Code-side `net::ERR_CONNECTION_RESET` was observed — not reproducible externally, treated as transient transport issue.
+- External image URLs may fail if DashScope's servers cannot reach them; base64-encoded images work reliably (`qwen3.6-plus`).
+- Vision is not supported on `qwen3.7-max` (text-generation model).
+- `maxInputTokens` / `maxOutputTokens` not yet confirmed from official DashScope documentation.
+- API keys are region-specific — a key created for one regional endpoint will not work with another.
+
+## References
+
+- VS Code custom endpoint docs: `https://code.visualstudio.com/docs/copilot/customization/language-models#_add-a-custom-endpoint-model`
+- DashScope OpenAI-compatible Chat Completions overview: `https://help.aliyun.com/zh/model-studio/compatibility-of-openai-with-dashscope`
+- DashScope model index: `https://help.aliyun.com/zh/model-studio/getting-started/models`
+- DashScope vision model guide: `https://help.aliyun.com/zh/model-studio/vision`
+- DashScope pricing: `https://www.alibabacloud.com/help/en/model-studio/billing-for-model-studio`
+- Kimi K2.6 validation record (separate provider): [kimi-k2.6.md](kimi-k2.6.md)