copilot-custom-endpoint 1.0.0

package/README.md

@@ -0,0 +1,470 @@
+# Github Copilot Custom Endpoints
+
+> **TL;DR** — As of **June 1, 2026**, GitHub Copilot switched to usage-based billing (AI Credits), making every chat and agent session consume from your monthly allowance. Frontier models like GPT-5.5 and Opus 4.8 burn credits fast. This repo documents a practical workaround: use **cheaper, non-GitHub models** (DeepSeek, Kimi, Qwen) inside VS Code's Copilot chat — often at **5–55× lower cost** while retaining agent mode, tool calling, and streaming. We keep validated, copy-paste-ready configs and a small local proxy that smooths out provider quirks.
+
+## What is this?
+
+VS Code lets you add your own language-model endpoint ("Bring Your Own Key"). In practice, many providers claim "OpenAI-compatible" APIs but reject the exact request shapes that VS Code sends. This repo is a growing collection of **real, tested setups** — not just hopeful `curl` snippets.
+
+Each provider/model gets one durable record under `docs/models/` plus any local proxy code it needs under `proxy/`.
+
+### Why custom endpoints instead of OpenRouter?
+
+[OpenRouter](https://openrouter.ai) is a popular unified gateway, but it is **not always an option**:
+
+- **Corporate firewalls often block OpenRouter** (and many other cloud AI gateways) by default. If your employer's network blocks OpenRouter, you cannot use it — full stop. A custom endpoint lets you talk directly to a provider that _is_ allowed, or run a small local proxy on `localhost` that forwards through an approved egress path.
+- **Provider-specific features** (Kimi's thinking mode, vision quirks, etc.) often need request rewriting that a generic aggregator does not support.
+- **Cost or contract reasons** may mean your organisation already has a direct relationship with a specific provider and does not want traffic routed through a third party.
+
+This repo is for those situations: validated, copy-paste-ready configs when OpenRouter is blocked, too expensive, or simply the wrong tool for the job.
+
+## Quick start
+
+| Provider                      | Model          | Needs proxy?                       | Plain chat | Streaming | Tool calling | Vision |
+| ----------------------------- | -------------- | ---------------------------------- | ---------- | --------- | ------------ | ------ |
+| **Moonshot (Kimi)**           | `kimi-k2.6`    | Yes — `proxy/kimi-proxy.mjs`       | ✅         | ✅        | ✅           | ✅     |
+| **Alibaba Cloud (DashScope)** | `qwen3.6-plus` | Optional — `proxy/qwen-proxy.mjs`¹ | ✅²        | ✅        | ✅           | ✅     |
+| **Alibaba Cloud (DashScope)** | `qwen3.7-max`  | Optional — `proxy/qwen-proxy.mjs`¹ | ✅²        | ✅        | ✅           | ❌     |
+| **DeepSeek**                  | `deepseek-v4`  | No — uses a VS Code extension      | ✅         | ✅        | ✅           | ✅¹    |
+
+¹ Proxy is optional: direct path works with static `enable_thinking: false`. Proxy adds dynamic thinking suppression (thinking ON in plain chat, OFF in tool loops).  
+² With proxy: reasoning visible in plain chat. Without proxy: always suppressed.
+
+¹ Vision is supported through a proxy model (Claude, GPT-4o) that describes the image before sending to DeepSeek.
+
+Pick the model you want and follow the corresponding section below.
+
+### Config file location
+
+The Kimi and Qwen setups require editing the same VS Code config file:
+
+| OS      | Path                                                              |
+| ------- | ----------------------------------------------------------------- |
+| Windows | `%APPDATA%\Code\User\chatLanguageModels.json`                     |
+| macOS   | `~/Library/Application Support/Code/User/chatLanguageModels.json` |
+| Linux   | `~/.config/Code/User/chatLanguageModels.json`                     |
+
+### Kimi K2.6 (Moonshot)
+
+#### 1. Grab a Moonshot API key
+
+Sign up at [platform.moonshot.ai](https://platform.moonshot.ai) and create an API key.
+
+#### 2. Start the local proxy
+
+The proxy rewrites VS Code's requests into shapes Kimi actually accepts (fixed `temperature`, `top_p`, and disabling "thinking" during tool calls).
+
+```bash
+# from this repo — Kimi only
+npm run proxy:kimi
+# from this repo — both proxies concurrently
+npm run proxy
+# or with npx (after npm publish)
+npx copilot-custom-endpoint kimi
+npx copilot-custom-endpoint       # starts both proxies
+# or directly
+node proxy/kimi-proxy.mjs
+```
+
+You should see:
+
+```
+[kimi-proxy] listening on http://127.0.0.1:3457/v1/chat/completions
+```
+
+Check it's alive:
+
+```bash
+curl http://127.0.0.1:3457/healthz
+```
+
+Expected response:
+
+```json
+{
+  "ok": true,
+  "upstreamUrl": "https://api.moonshot.ai/v1/chat/completions",
+  "port": 3457,
+  "forcedTemperature": 1,
+  "forcedTopP": 0.95
+}
+```
+
+> **Keep this terminal open** while you use Kimi in VS Code.
+
+#### 3. Register the model in VS Code
+
+Open (or create) your user config file (see [Config file location](#config-file-location) above) and paste this entry (replace `<your-moonshot-key>`):
+
+```json
+{
+  "name": "Kimi",
+  "vendor": "customendpoint",
+  "apiKey": "<your-moonshot-key>",
+  "apiType": "chat-completions",
+  "models": [
+    {
+      "id": "kimi-k2.6",
+      "name": "Kimi K2.6",
+      "url": "http://127.0.0.1:3457/v1/chat/completions",
+      "requestBody": {
+        "temperature": 1
+      },
+      "toolCalling": true,
+      "vision": true,
+      "streaming": true,
+      "maxInputTokens": 262144,
+      "maxOutputTokens": 32768
+    }
+  ]
+}
+```
+
+> **Note:** The `requestBody.temperature` here is a hint to VS Code, but the proxy will enforce the exact values Kimi requires regardless.
+
+#### 4. Chat!
+
+- Open the Copilot chat panel (`Ctrl+Alt+I` / `Cmd+Ctrl+I`).
+- Click the model picker (top-right of the chat input).
+- Choose **Kimi K2.6**.
+- Ask something. Streaming, tool use, and vision all work.
+
+#### Troubleshooting (Kimi)
+
+| Symptom                                 | Fix                                                                                                                                                           |
+| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| "Connection refused" or no response     | Make sure `node proxy/kimi-proxy.mjs` is still running.                                                                                                       |
+| `invalid temperature` / `invalid top_p` | You're talking directly to Moonshot instead of through the proxy. Double-check the `url` in `chatLanguageModels.json`.                                        |
+| Tool calls fail after first turn        | This happens if "thinking" stays enabled during tool loops. The proxy normally disables it automatically; ensure you're on the latest `proxy/kimi-proxy.mjs`. |
+
+---
+
+### Qwen 3.6 Plus or Qwen 3.7 Max (DashScope)
+
+These models work with the optional `proxy/qwen-proxy.mjs` for dynamic thinking suppression (reasoning visible in plain chat, suppressed in tool loops). They also work **without a proxy** using a static `enable_thinking: false` — see the [direct path alternative](#direct-path-no-proxy) below.
+
+#### 1. Grab a DashScope API key
+
+Sign up at [dashscope.aliyun.com](https://dashscope.aliyun.com) and create an API key.
+
+#### 2. Start the optional local proxy (recommended)
+
+The proxy dynamically enables thinking in plain chat and disables it during tool calls:
+
+```bash
+# from this repo — Qwen only
+npm run proxy:qwen
+# from this repo — both proxies concurrently
+npm run proxy
+# or with npx (after npm publish)
+npx copilot-custom-endpoint qwen
+npx copilot-custom-endpoint       # starts both proxies
+# or directly
+node proxy/qwen-proxy.mjs
+```
+
+You should see:
+
+```
+[qwen-proxy] listening on http://127.0.0.1:3458/v1/chat/completions
+```
+
+Check 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
+}
+```
+
+#### 3. Register the models in VS Code
+
+Open (or create) your user config file (see [Config file location](#config-file-location) above) and paste this entry (replace `<your-dashscope-key>`). Point URLs at the proxy and omit `requestBody` — the proxy handles thinking dynamically:
+
+```json
+{
+  "name": "Qwen",
+  "vendor": "customendpoint",
+  "apiKey": "<your-dashscope-key>",
+  "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 these models.
+
+#### 4. Chat!
+
+- Open the Copilot chat panel (`Ctrl+Alt+I` / `Cmd+Ctrl+I`).
+- Click the model picker (top-right of the chat input).
+- Choose **Qwen 3.6 Plus** (with vision) or **Qwen 3.7 Max** (text only).
+- Ask something. Streaming, tool use, and vision (3.6 Plus) all work.
+
+> **Regional endpoints:** If connecting directly (no proxy), DashScope offers endpoints for several regions. The proxy uses `dashscope-intl.aliyuncs.com` (Singapore) by default, configurable via `QWEN_UPSTREAM_URL`.
+>
+> - **China (Beijing):** `https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions`
+> - **US (Virginia):** `https://dashscope-us.aliyuncs.com/compatible-mode/v1/chat/completions`
+> - **Singapore:** `https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions` (proxy default)
+>
+> API keys are region-specific.
+
+#### Direct path (no proxy)
+
+If you prefer not to run the proxy, Qwen models work **directly** with DashScope by using the upstream URL and a static `enable_thinking: false` in `requestBody`:
+
+```json
+{
+  "name": "Qwen",
+  "vendor": "customendpoint",
+  "apiKey": "<your-dashscope-key>",
+  "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
+      }
+    }
+  ]
+}
+```
+
+> **Trade-off:** `enable_thinking: false` suppresses reasoning in all requests (both plain chat and tool loops). Tool loops stay stable, but you never see the model's thought process. The proxy path avoids this trade-off.
+
+#### Troubleshooting (Qwen)
+
+| Symptom                                      | Fix                                                                                     |
+| -------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `reasoning_content` errors during tool loops | Ensure `enable_thinking: false` is present in `requestBody` for every Qwen model.       |
+| Vision images fail to upload                 | Use base64-encoded images; external image URLs may fail if DashScope cannot reach them. |
+
+---
+
+### DeepSeek V4 (VS Code Extension)
+
+DeepSeek V4 Pro & Flash are available via a **dedicated VS Code extension** rather than a raw custom endpoint. The extension plugs DeepSeek directly into Copilot Chat's model picker while preserving agent mode, tool calling, skills, and MCP support.
+
+> **How this differs:** Unlike Kimi and Qwen (which use VS Code's built-in `chatLanguageModels.json` custom endpoint mechanism), DeepSeek uses a VS Code extension that registers itself with Copilot. The experience is the same — pick the model in chat — but the setup path goes through the extension.
+
+#### 1. Install the Extension
+
+- VS Code 1.116 or later.
+- A [GitHub Copilot subscription](https://github.com/features/copilot) (Free / Pro / Enterprise all work).
+- Install **[DeepSeek V4 for Copilot Chat](https://marketplace.visualstudio.com/items?itemName=Vizards.deepseek-v4-for-copilot)** from the VS Code Marketplace ([source](https://github.com/Vizards/deepseek-v4-for-copilot)).
+
+#### 2. Get a DeepSeek API Key
+
+Go to [platform.deepseek.com/api_keys](https://platform.deepseek.com/api_keys) and create an API key (starts with `sk-`).
+
+#### 3. Configure the API Key
+
+Open the Command Palette (`Ctrl+Shift+P`) and run **DeepSeek: Set API Key**, then paste your key. The key is stored in your OS keychain.
+
+#### 4. Select the Model and Start Chatting
+
+- Open Copilot Chat (`Ctrl+Shift+I`).
+- Click the model picker (top-right of the chat panel).
+- Choose **DeepSeek V4 Pro** or **DeepSeek V4 Flash**.
+- Agent mode, tool calling, skills, and MCP all work out of the box.
+
+#### Optional: Configure Thinking Effort
+
+In the model picker, click the gear icon next to a DeepSeek model to choose:
+
+- **None** — fastest, no reasoning.
+- **High** — balanced (default).
+- **Max** — deep reasoning for complex tasks.
+
+#### Optional: Vision Support
+
+DeepSeek V4 is text-only, but the extension handles images automatically — drop a screenshot into chat and it proxies through another installed Copilot model (Claude, GPT-4o) to describe the image first. Run **DeepSeek: Set Vision Proxy Model** to pick which model handles image descriptions.
+
+> For the full official guide, see: [github.com/deepseek-ai/awesome-deepseek-agent/blob/main/docs/github_copilot.md](https://github.com/deepseek-ai/awesome-deepseek-agent/blob/main/docs/github_copilot.md)
+
+For the full research notes, tested values, and known limitations, see:
+
+- [`docs/models/kimi-k2.6.md`](docs/models/kimi-k2.6.md)
+- [`docs/models/qwen.md`](docs/models/qwen.md)
+
+## Pricing comparison
+
+> **⏰ June 1, 2026 — GitHub Copilot switched to usage-based billing (AI Credits) today.**
+>
+> Before this change, Copilot was a flat subscription — no per-turn metering, so you could use chat and agent mode as much as you wanted within rate-limit bounds. Now **every interaction burns AI credits** from your monthly allowance. Agent mode and complex multi-file tasks consume significantly more tokens than simple Q&A, which means your 7,000 Pro+ credits can disappear fast if you're using frontier models.
+>
+> **The practical workaround:** use cheaper alternative models (DeepSeek V4 Flash, Kimi K2.6, Qwen) that are still powerful enough for coding — often at **5–55× less cost** than the Copilot defaults. The tables below show the exact comparison.
+>
+> 1 AI credit = $0.01 USD. All paid plans include a monthly credit allowance:
+>
+> | Plan | Price/mo | Base credits | Flex allotment | Total monthly |
+> | ---- | -------- | ------------ | -------------- | ------------- |
+> | Pro  | $10      | 1,000        | 500            | **1,500**     |
+> | Pro+ | $39      | 3,900        | 3,100          | **7,000**     |
+> | Max  | $100     | 10,000       | 10,000         | **20,000**    |
+>
+> Code completions remain unlimited and **not** billed. Auto model selection gets a 10% discount.
+
+All prices below are in **USD per 1M tokens** (non-cached). To convert to AI credits, multiply by 100 (e.g., $5.00/1M = 500 credits/1M).
+
+### Default GitHub Copilot models
+
+These are the models available through GitHub Copilot's model roster as of June 1, 2026.
+
+| Model                 | Provider  | Tier        | Input (per 1M) | Cached input | Output (per 1M) | Context |
+| --------------------- | --------- | ----------- | -------------- | ------------ | --------------- | ------- |
+| **GPT-5.5**           | OpenAI    | Powerful    | $5.00          | $0.50        | $30.00          | —       |
+| **Claude Opus 4.8**   | Anthropic | Powerful    | $5.00          | $0.50        | $25.00          | 1M      |
+| **Claude Opus 4.7**   | Anthropic | Powerful    | $5.00          | $0.50        | $25.00          | 1M      |
+| **GPT-5.4**           | OpenAI    | Versatile   | $2.50          | $0.25        | $15.00          | —       |
+| **GPT-5.3-Codex**     | OpenAI    | Powerful    | $1.75          | $0.175       | $14.00          | —       |
+| **Claude Sonnet 4.6** | Anthropic | Versatile   | $3.00          | $0.30        | $15.00          | 1M      |
+| **Gemini 3.1 Pro**    | Google    | Powerful    | $2.00¹         | $0.20        | $12.00¹         | 1M      |
+| **Claude Haiku 4.5**  | Anthropic | Versatile   | $1.00          | $0.10        | $5.00           | 1M      |
+| **Gemini 3.5 Flash**  | Google    | Lightweight | $1.50          | $0.15        | $9.00           | 1M      |
+| **Gemini 2.5 Pro**    | Google    | Powerful    | $1.25¹         | $0.125       | $10.00¹         | 1M      |
+| **GPT-5.4 mini**      | OpenAI    | Lightweight | $0.75          | $0.075       | $4.50           | —       |
+| **Gemini 3 Flash**    | Google    | Lightweight | $0.50          | $0.05        | $3.00           | 1M      |
+| **Raptor mini**       | GitHub    | Versatile   | $0.25          | $0.025       | $2.00           | —       |
+
+¹ Gemini 3.1 Pro and 2.5 Pro pricing applies to prompts ≤200K tokens.
+
+### Custom-endpoint alternatives
+
+| Model                 | Provider  | Input (per 1M)                | Output (per 1M)                         | Context window |
+| --------------------- | --------- | ----------------------------- | --------------------------------------- | -------------- |
+| **DeepSeek V4 Flash** | DeepSeek  | $0.14                         | $0.28                                   | 1M             |
+| **Kimi K2.6**         | Moonshot  | $0.16                         | $0.95 (non-thinking) / $4.00 (thinking) | 256K           |
+| **DeepSeek V4 Pro**   | DeepSeek  | $1.74                         | $3.48                                   | 1M             |
+| **Qwen 3.6 Plus**     | DashScope | $0.50 (≤256K) / $2.00 (>256K) | $3.00 (≤256K) / $6.00 (>256K)           | 1M             |
+| **Qwen 3.7 Max**      | DashScope | $2.50 (≤1M)                   | $7.50 (≤1M)                             | 1M             |
+
+> **Notes:**
+>
+> - **DeepSeek V4** input pricing shown is the **cache miss** price. Cache hits are significantly cheaper ($0.0028/M for Flash, $0.0145/M for Pro).
+> - **Gemini 3 Flash** is priced at $0.50/MTok input (text/image/video) and $1.00/MTok input for audio.
+> - **Anthropic (Claude)** models also have a cache write cost ($6.25/MTok for Opus, $3.75/MTok for Sonnet, $1.25/MTok for Haiku). Opus 4.7+ use a new tokenizer that may use up to 35% more tokens for the same text.
+> - **OpenAI** models support cached input at 0.1× base input rate.
+> - **Qwen** models use **tiered pricing** — determined by total input tokens per request. Prices above are for non-thinking mode.
+> - **Kimi K2.6** pricing is from the **Moonshot platform** (direct). Via DashScope: $0.89 input / $3.71 output.
+> - **DashScope** offers a **free quota** of 1M input + 1M output tokens per model, valid for 90 days.
+> - For typical Copilot chat usage (short-to-medium prompts), you'll almost always fall in the lowest pricing tier.
+
+**Quick cost comparison for a typical coding session** (~10K input + ~2K output tokens per turn, 50 turns):
+
+| Model                    | Estimated session cost | Copilot Pro+ credits |
+| ------------------------ | ---------------------- | -------------------- |
+| DeepSeek V4 Flash 🏆     | ~$0.10                 | —                    |
+| Kimi K2.6 (non-thinking) | ~$0.18                 | —                    |
+| Raptor mini              | ~$0.33                 | ~33                  |
+| Kimi K2.6 (thinking)     | ~$0.48                 | —                    |
+| Gemini 3 Flash           | ~$0.55                 | ~55                  |
+| Qwen 3.6 Plus            | ~$0.55                 | —                    |
+| GPT-5.4 mini             | ~$0.83                 | ~83                  |
+| Claude Haiku 4.5         | ~$1.00                 | ~100                 |
+| DeepSeek V4 Pro          | ~$1.22                 | —                    |
+| Qwen 3.7 Max             | ~$1.33                 | —                    |
+| Gemini 2.5 Pro           | ~$1.63                 | ~163                 |
+| Gemini 3.5 Flash         | ~$1.65                 | ~165                 |
+| Gemini 3.1 Pro           | ~$2.20                 | ~220                 |
+| GPT-5.3-Codex            | ~$2.28                 | ~228                 |
+| GPT-5.4                  | ~$2.75                 | ~275                 |
+| Claude Sonnet 4.6        | ~$3.00                 | ~300                 |
+| Claude Opus 4.8 / 4.7    | ~$5.00                 | ~500                 |
+| GPT-5.5                  | ~$5.50                 | ~550                 |
+
+> **How long does 7,000 credits last?** A Pro+ subscriber running 50-turn sessions could afford roughly **13 GPT-5.5 sessions**, **23 Opus sessions**, or **212 Raptor mini sessions** per month — or mix and match.
+
+> Prices last verified: June 1, 2026. Always check the official pages for the latest rates:
+>
+> - [GitHub Copilot models & pricing](https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing)
+> - [OpenAI pricing](https://openai.com/api/pricing/)
+> - [Anthropic (Claude) pricing](https://platform.claude.com/docs/en/about-claude/pricing)
+> - [Google Gemini pricing](https://ai.google.dev/pricing)
+> - [DashScope pricing](https://www.alibabacloud.com/help/en/model-studio/billing-for-model-studio)
+> - [DeepSeek pricing](https://api-docs.deepseek.com/quick_start/pricing)
+
+## Repo layout
+
+```
+.
+├── docs/models/<provider>-<model>.md   # One merged record per model
+├── proxy/                              # Local compatibility shims (Kimi only)
+├── tests/                              # Test assets (images, etc.)
+└── debug_log/                          # Runtime logs (git-ignored)
+```
+
+## Adding a new model
+
+Want to validate Qwen, GLM, Mimo, or something else?
+
+1. Create `docs/models/<provider>-<model>.md`.
+2. If the provider needs request rewriting, add a proxy script under `proxy/`.
+3. Recommended sections for the record:
+   1. Summary
+   2. Compatibility assessment
+   3. Final working configuration
+   4. Validation summary
+   5. Known limitations
+   6. Final verdict
+   7. Sources
+
+## Limitations
+
+- This repo covers **chat only**. GitHub Copilot features like inline completions, semantic search, and next-edit suggestions still require a GitHub-hosted model.
+- Each proxy is tuned for a specific provider family. Don't point the Kimi proxy at an arbitrary OpenAI-compatible endpoint and expect it to work.
+
+---
+
+## Support
+
+If you find this project helpful, please consider supporting its development:
+
+[![GitHub Sponsors](https://img.shields.io/badge/Sponsor-GitHub-pink?logo=github)](https://github.com/sponsors/tugudush)
+
+**Solana (SOL)**
+
+```
+CWZccD3Ny3XotFZtnkcyzP3hapmu3ExknN1PF4rEvP3u
+```

package/cli.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import { fork } from 'node:child_process'
+import { rmSync } from 'node:fs'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const sub = process.argv[2]
+
+const usage = `Usage: copilot-custom-endpoint [all|kimi|qwen|clean]
+
+Start a local proxy for VS Code Copilot custom endpoints.
+
+  copilot-custom-endpoint all     Start both proxies concurrently (default)
+  copilot-custom-endpoint kimi    Start the Kimi K2 proxy on port 3457
+  copilot-custom-endpoint qwen    Start the Qwen 3.x proxy on port 3458
+  copilot-custom-endpoint clean   Remove the debug_log/ directory
+
+Environment variables: see --help for each proxy.
+`
+
+if (sub === 'clean') {
+  rmSync(resolve(process.cwd(), 'debug_log'), { recursive: true, force: true })
+  console.log('debug_log/ removed')
+  process.exit(0)
+}
+
+if (sub && sub !== 'kimi' && sub !== 'qwen' && sub !== 'all') {
+  console.error(usage)
+  process.exit(1)
+}
+
+const targets = sub === 'all' || !sub ? ['kimi', 'qwen'] : [sub]
+
+// Spawn all target proxies and wait for all to exit.
+// This keeps both proxies alive in "all" mode instead of exiting
+// when the first one terminates.
+const children = targets.map((name) => {
+  const proxyFile = resolve(__dirname, 'proxy', `${name}-proxy.mjs`)
+  return fork(proxyFile, process.argv.slice(3), { stdio: 'inherit' })
+})
+
+const exitCodes = await Promise.all(
+  children.map(
+    (child) =>
+      new Promise((resolve) => {
+        child.on('exit', (code) => {
+          resolve(code ?? 0)
+        })
+      })
+  )
+)
+
+process.exit(exitCodes.some((code) => code !== 0) ? 1 : 0)

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "copilot-custom-endpoint",
+  "version": "1.0.0",
+  "description": "Local proxies for VS Code Copilot custom endpoints — Kimi K2 & Qwen 3.x",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "copilot-custom-endpoint": "cli.mjs",
+    "copilot-custom-endpoint-kimi": "proxy/kimi-proxy.mjs",
+    "copilot-custom-endpoint-qwen": "proxy/qwen-proxy.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "proxy/"
+  ],
+  "scripts": {
+    "proxy": "concurrently --names kimi,qwen --prefix-colors cyan,green \"npm run proxy:kimi\" \"npm run proxy:qwen\"",
+    "proxy:kimi": "node proxy/kimi-proxy.mjs",
+    "proxy:qwen": "node proxy/qwen-proxy.mjs",
+    "clean:logs": "node -e \"import{rmSync}from'node:fs';rmSync('debug_log',{recursive:true,force:true});console.log('debug_log/ removed')\"",
+    "test": "node --test tests/**/*.test.mjs",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "lf": "npm run lint && npm run format:fix"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tugudush/copilot-custom-endpoints.git"
+  },
+  "keywords": [
+    "copilot",
+    "vscode",
+    "custom-endpoint",
+    "kimi",
+    "qwen",
+    "moonshot",
+    "dashscope",
+    "proxy"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "concurrently": "^10.0.1",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3"
+  }
+}

package/proxy/kimi-proxy.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url'
+import { createProxy } from '../lib/create-proxy.mjs'
+
+/**
+ * Supported model scope for this proxy:
+ * - Validated in this repo with `kimi-k2.6`.
+ * - Expected to work for `kimi-k2.5`, because Kimi documents the same fixed
+ *   sampling and thinking behavior for `kimi-k2.6` / `kimi-k2.5`.
+ * - Not intended for `moonshot-v1` models or non-Kimi providers, because this
+ *   proxy rewrites requests to K2-family-specific values:
+ *   - thinking mode temperature = 1.0
+ *   - non-thinking mode temperature = 0.6
+ *   - top_p = 0.95
+ *   - tool-enabled requests force `thinking: { type: 'disabled' }`
+ */
+const upstreamUrl =
+  process.env.KIMI_UPSTREAM_URL ?? 'https://api.moonshot.ai/v1/chat/completions'
+const port = Number.parseInt(process.env.PORT ?? '3457', 10)
+const forcedTemperature = Number(
+  process.env.KIMI_PROXY_FORCE_TEMPERATURE ?? '1'
+)
+const forcedNonThinkingTemperature = Number(
+  process.env.KIMI_PROXY_FORCE_NON_THINKING_TEMPERATURE ?? '0.6'
+)
+const forcedTopP = Number(process.env.KIMI_PROXY_FORCE_TOP_P ?? '0.95')
+const disableThinkingWithTools =
+  (process.env.KIMI_PROXY_DISABLE_THINKING_WITH_TOOLS ?? '1') !== '0'
+const defaultLogPath = fileURLToPath(
+  new URL('../debug_log/kimi-proxy.ndjson', import.meta.url)
+)
+const logPath = process.env.KIMI_PROXY_LOG ?? defaultLogPath
+
+if (process.argv.includes('--help')) {
+  console.log(`Kimi proxy
+
+Starts a local HTTP proxy that rewrites the outbound chat-completions request body to use Kimi-compatible sampling values.
+
+Environment variables:
+  PORT                         Local listen port. Default: 3457
+  KIMI_UPSTREAM_URL            Upstream Moonshot chat-completions URL.
+                               Default: https://api.moonshot.ai/v1/chat/completions
+  KIMI_PROXY_FORCE_TEMPERATURE Temperature to force into the request body. Default: 1
+  KIMI_PROXY_FORCE_NON_THINKING_TEMPERATURE
+                               Temperature to force when thinking is disabled. Default: 0.6
+  KIMI_PROXY_FORCE_TOP_P       top_p to force into the request body. Default: 0.95
+  KIMI_PROXY_DISABLE_THINKING_WITH_TOOLS
+                               Force thinking={"type":"disabled"} when tools are present.
+                               Default: 1
+  KIMI_PROXY_LOG               Path to the redacted NDJSON log file.
+
+Suggested VS Code model URL:
+  http://127.0.0.1:3457/v1/chat/completions
+`)
+  process.exit(0)
+}
+
+if (!Number.isFinite(forcedTemperature)) {
+  throw new Error(
+    `Invalid KIMI_PROXY_FORCE_TEMPERATURE: ${process.env.KIMI_PROXY_FORCE_TEMPERATURE ?? ''}`
+  )
+}
+
+if (!Number.isFinite(forcedNonThinkingTemperature)) {
+  throw new Error(
+    `Invalid KIMI_PROXY_FORCE_NON_THINKING_TEMPERATURE: ${process.env.KIMI_PROXY_FORCE_NON_THINKING_TEMPERATURE ?? ''}`
+  )
+}
+
+if (!Number.isFinite(forcedTopP)) {
+  throw new Error(
+    `Invalid KIMI_PROXY_FORCE_TOP_P: ${process.env.KIMI_PROXY_FORCE_TOP_P ?? ''}`
+  )
+}
+
+// ---- Provider-specific rewrite logic ----
+
+function summarizePayload(payload, hasTools, rewriteInfo) {
+  const messages = Array.isArray(payload.messages) ? payload.messages : []
+  const tools = Array.isArray(payload.tools) ? payload.tools : []
+
+  return {
+    model: payload.model,
+    stream: payload.stream,
+    ...rewriteInfo,
+    maxTokens:
+      payload.max_tokens ??
+      payload.max_completion_tokens ??
+      payload.max_output_tokens,
+    toolChoice: payload.tool_choice,
+    toolCount: tools.length,
+    hasTools,
+    messageCount: messages.length,
+    messageRoles: messages.map((message) => message?.role).slice(0, 16),
+    topLevelKeys: Object.keys(payload).sort()
+  }
+}
+
+function rewriteKimi(payload) {
+  const incomingTemperature = payload.temperature
+  const incomingTopP = payload.top_p
+  const incomingThinkingType = payload?.thinking?.type
+  const hasTools = Array.isArray(payload.tools) && payload.tools.length > 0
+  const useNonThinkingMode = disableThinkingWithTools && hasTools
+  const rewrittenTemperature = useNonThinkingMode
+    ? forcedNonThinkingTemperature
+    : forcedTemperature
+
+  // Capture incoming state before mutation
+  payload.__incomingThinkingType = incomingThinkingType
+
+  // Apply rewrites
+  payload.temperature = rewrittenTemperature
+  payload.top_p = forcedTopP
+
+  if (useNonThinkingMode) {
+    payload.thinking = { type: 'disabled' }
+  }
+
+  const rewrittenThinkingType = payload.thinking?.type
+  const rewriteInfo = {
+    incomingTemperature,
+    rewrittenTemperature,
+    incomingTopP,
+    rewrittenTopP: forcedTopP,
+    incomingThinkingType,
+    rewrittenThinkingType
+  }
+
+  const summary = summarizePayload(payload, hasTools, rewriteInfo)
+
+  const consoleMsg = `temperature ${String(incomingTemperature)} -> ${String(rewrittenTemperature)}, top_p ${String(incomingTopP)} -> ${String(forcedTopP)}, thinking ${String(incomingThinkingType)} -> ${String(rewrittenThinkingType)}`
+
+  // Clean up internal key before forwarding
+  delete payload.__incomingThinkingType
+
+  return { summary, consoleMsg }
+}
+
+// ---- Create and start ----
+
+const { start } = createProxy({
+  upstreamUrl,
+  port,
+  logPath,
+  label: 'kimi-proxy',
+  healthCheckExtras: { forcedTemperature, forcedTopP },
+  rewriteRequest: rewriteKimi,
+  startupMessages: (_port, _upstreamUrl) => [
+    `[kimi-proxy] listening on http://127.0.0.1:${_port}/v1/chat/completions`,
+    `[kimi-proxy] forwarding to ${_upstreamUrl}`,
+    `[kimi-proxy] forcing temperature=${forcedTemperature}, non-thinking temperature=${forcedNonThinkingTemperature}, and top_p=${forcedTopP}`,
+    `[kimi-proxy] disable thinking with tools=${disableThinkingWithTools}`,
+    `[kimi-proxy] writing redacted request summaries to ${logPath}`
+  ]
+})
+
+start()

package/proxy/qwen-proxy.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url'
+import { createProxy } from '../lib/create-proxy.mjs'
+
+/**
+ * Supported model scope for this proxy:
+ * - Validated with `qwen3.6-plus` and `qwen3.7-max`.
+ * - Expected to work for any Qwen3 hybrid-thinking model (qwen3-* series)
+ *   that supports the `enable_thinking` top-level field on DashScope's
+ *   OpenAI-compatible surface.
+ * - Not intended for non-Qwen providers, because the rewrite assumes
+ *   DashScope's `enable_thinking` behavior (no nested `thinking` object).
+ */
+const upstreamUrl =
+  process.env.QWEN_UPSTREAM_URL ??
+  'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions'
+const port = Number.parseInt(process.env.PORT ?? '3458', 10)
+const disableThinkingWithTools =
+  (process.env.QWEN_PROXY_DISABLE_THINKING_WITH_TOOLS ?? '1') !== '0'
+const defaultLogPath = fileURLToPath(
+  new URL('../debug_log/qwen-proxy.ndjson', import.meta.url)
+)
+const logPath = process.env.QWEN_PROXY_LOG ?? defaultLogPath
+
+if (process.argv.includes('--help')) {
+  console.log(`Qwen proxy
+
+Starts a local HTTP proxy that conditionally injects enable_thinking: false
+when the request includes a tools array, letting Qwen hybrid-thinking models
+show reasoning in plain chat while keeping tool loops stable.
+
+Environment variables:
+  PORT                         Local listen port. Default: 3458
+  QWEN_UPSTREAM_URL            Upstream DashScope chat-completions URL.
+                               Default: https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions
+  QWEN_PROXY_DISABLE_THINKING_WITH_TOOLS
+                               Inject enable_thinking: false when tools are present.
+                               Default: 1
+  QWEN_PROXY_LOG               Path to the redacted NDJSON log file.
+
+Suggested VS Code model URL:
+  http://127.0.0.1:3458/v1/chat/completions
+`)
+  process.exit(0)
+}
+
+// ---- Provider-specific rewrite logic ----
+
+function summarizePayload(payload, hasTools, rewriteInfo) {
+  const messages = Array.isArray(payload.messages) ? payload.messages : []
+  const tools = Array.isArray(payload.tools) ? payload.tools : []
+
+  return {
+    model: payload.model,
+    stream: payload.stream,
+    hasTools,
+    toolCount: tools.length,
+    toolChoice: payload.tool_choice,
+    ...rewriteInfo,
+    maxTokens:
+      payload.max_tokens ??
+      payload.max_completion_tokens ??
+      payload.max_output_tokens,
+    messageCount: messages.length,
+    messageRoles: messages.map((message) => message?.role).slice(0, 16),
+    topLevelKeys: Object.keys(payload).sort()
+  }
+}
+
+function rewriteQwen(payload) {
+  const hasTools = Array.isArray(payload.tools) && payload.tools.length > 0
+  const incomingEnableThinking = payload.enable_thinking
+
+  if (disableThinkingWithTools && hasTools) {
+    // Tool-enabled request: suppress thinking to avoid reasoning_content issues
+    payload.enable_thinking = false
+  } else {
+    // Plain chat: remove enable_thinking so the model uses its default (true)
+    delete payload.enable_thinking
+  }
+
+  const rewrittenEnableThinking =
+    disableThinkingWithTools && hasTools ? false : undefined
+
+  const summary = summarizePayload(payload, hasTools, {
+    incomingEnableThinking,
+    rewrittenEnableThinking
+  })
+
+  const consoleMsg = `tools=${String(hasTools)} enable_thinking=${String(incomingEnableThinking)} -> ${
+    hasTools && disableThinkingWithTools ? 'false' : '<deleted>'
+  }, model=${payload.model ?? '?'}`
+
+  return { summary, consoleMsg }
+}
+
+// ---- Create and start ----
+
+const { start } = createProxy({
+  upstreamUrl,
+  port,
+  logPath,
+  label: 'qwen-proxy',
+  healthCheckExtras: { disableThinkingWithTools },
+  rewriteRequest: rewriteQwen,
+  startupMessages: (_port, _upstreamUrl) => [
+    `[qwen-proxy] listening on http://127.0.0.1:${_port}/v1/chat/completions`,
+    `[qwen-proxy] forwarding to ${_upstreamUrl}`,
+    `[qwen-proxy] disable thinking with tools=${disableThinkingWithTools}`,
+    `[qwen-proxy] writing redacted request summaries to ${logPath}`
+  ]
+})
+
+start()