Coding Plans for Copilot

Switch between multiple AI model vendors with one click, breaking Copilot plan limitations.

Supports domestic major vendors like Zhipu, Kimi, iFlytek, Volcengine, MiniMax, Baidu Qianfan, Tencent Cloud, JD Cloud, Kuaishou KAT, X-AIO, Compshare, Alibaba Cloud, Xiaomi MiMo, DeepSeek, as well as any vendor that follows OpenAI Chat, OpenAI Responses, or Anthropic protocol styles. No need to change usage habits; call them directly in VS Code Copilot Chat.

This extension is a general protocol adapter, not a clone of Copilot's private endpoint protocol. It sends public OpenAI/Anthropic-compatible fields and avoids Copilot-private request fields; as a result, it can work with Codex, Claude Code, and similar reverse-proxied APIs that native VS Code/Copilot Chat endpoint requests usually cannot call directly.

VS Code for the Web

Coding Plans runs in VS Code for the Web, including vscode.dev and github.dev. The language model provider, vendor configuration and Secret Storage API keys, model refresh, model-configuration copy, usage status, and commit-message commands remain available when the host provides Copilot Chat and an SCM/Git provider.

• Browser extension hosts cannot run a local Git executable. When coding-plans.commitMessage.useRecentCommitStyle is enabled, the web host skips only the optional recent-commit style samples; commit generation still uses the current SCM diff.
• Requests originate in the browser extension host. Each configured API endpoint, including /models and optional usage endpoints, must allow the required cross-origin requests (CORS). Use a CORS-enabled vendor endpoint or proxy when the upstream API does not support browser requests.

Core Features

• Multi-Protocol Unified Access: Supports OpenAI Chat (/chat/completions), OpenAI Responses (/responses), and Anthropic (/messages) three protocol styles, adapting to any compatible vendor.
• General Request Format: Avoids Copilot-private request fields and sends public compatible fields, enabling Codex, Claude Code, and similar reverse-proxied OpenAI/Anthropic-style APIs.
• Anthropic Protocol First: Built-in vendors default to Anthropic-style endpoints (/messages).
• Zero Learning Curve: Fully integrated into VS Code Copilot Chat without changing any operational habits.
• Flexible Model Management: Supports dynamic fetching from /models endpoint, or custom model lists.
• Intelligent Commit Generation: Automatically generates Conventional Commits-compliant commit messages based on Git changes.
• Coding Plans Dashboard: Visit GitHub Pages Dashboard to view monthly fees and benefits from multiple coding plans, as well as OpenRouter vendor performance metrics. The dashboard updates daily with automated scraping, multi-dimensional filtering, and URL state sync.
• Key Security: API Keys are stored locally using VS Code Secret Storage, not uploaded to the cloud or shared.

Quick Start

Installation

Recommended Method: Search "Coding Plans" or Coding Plans for Copilot directly in the VS Code Marketplace.

Method 1: Install within VS Code (Recommended)

1. Open VS Code
2. Press Ctrl+Shift+X to open the Extensions panel
3. Type Coding Plans for Copilot in the search box
4. Click Install to install
5. After installation, press Ctrl+Shift+P and type Coding Plans to see related commands

Method 2: Command Line Installation

code --install-extension techfetch-dev.coding-plans-for-copilot

Method 3: Install from Marketplace Page

👉 VS Code Marketplace Direct Link

Click the Install button on the marketplace page, which will automatically open the extension in VS Code and install it.

Prerequisites: Requires VS Code ≥ 1.120.0 and the GitHub Copilot extension installed.

Configuration

1. Press Ctrl+Shift+P, type Coding Plans: Manage Vendor Configuration
2. Pick the platform you've registered with from the vendor picker (e.g., Zhipu, Kimi, Volcengine, etc.)
3. Select "Set API Key" and paste your API Key; the extension stores it and refreshes models
4. Open Copilot Chat (Ctrl+L) and choose a model provided by Coding Plans in the model picker
5. Set Thinking Effort per request from the model row More Actions menu. OpenAI Chat-compatible models support none / low / medium / high / xhigh / max, and also show Thinking Type (enabled / disabled / default, default: default; default omits the thinking field and only sends reasoning_effort, matching native Custom Endpoint). Choose enabled to also send thinking.enabled. OpenAI Responses models support low / medium / high / xhigh / max (default: max). Copilot Chat may pass reasoningEffort instead of thinkingEffort; the adapter maps that alias. More Actions is thinking-only. Vendor temperature / topP keys remain in settings but are not sent.
6. When a vendor has useModelsEndpoint enabled, run Coding Plans: Update Coding Plans Models List to request /models, write the result back to coding-plans.vendors[].models, and refresh the VS Code model picker. By default, saving settings only refreshes currently configured models; it does not automatically request /models or write back the model list. Set coding-plans.autoRefreshModels to false to stop settings/API-key changes from automatically refreshing runtime models and the VS Code model picker; manual refresh commands still work.
   • During refresh, the extension prefers models.dev catalog.json and falls back to api.json to enrich newly discovered models by model ID/name with description, capabilities, contextSize, apiStyle, and price. Matching ignores tags after : in the final model path segment, such as :free. The description shows id | Lab | Family | Weights | ReleaseDate, where Lab comes from the model ID prefix. capabilities.thinking maps to models.dev reasoning. New model apiStyle is inferred only from the model source: OpenAI and Grok/xAI use openai-responses, Anthropic uses anthropic, and all others default to openai-chat. Grok models that still have the legacy openai-chat value are automatically upgraded to openai-responses during refresh. Prices use the median across all matching model sources and do not match the local vendor name to a models.dev provider. If the catalog cannot be fetched or matched, it keeps the upstream /models data and built-in defaults. Existing manual model entries are not overwritten; extension-generated fallback descriptions such as vendor model: model can be upgraded to the models.dev structure. You can also directly edit settings.json; the extension will open settings and navigate to coding-plans.vendors.

Built-in Vendor Endpoints

The following vendors come with built-in default configurations and are ready to use after installation:

To switch to OpenAI-compatible endpoints, modify the vendor's baseUrl and defaultApiStyle. The built-in Zhipu default uses the dedicated GLM Coding Plan endpoint https://open.bigmodel.cn/api/coding/paas/v4. If you want the Claude Code-compatible entrypoint instead, switch baseUrl to https://open.bigmodel.cn/api/anthropic and set defaultApiStyle to anthropic. The built-in Xiaomi MiMo default uses the Token Plan endpoint. If you want pay-as-you-go API access instead, switch baseUrl to https://api.xiaomimimo.com/anthropic (https://api.xiaomimimo.com/v1 for OpenAI compatibility) and use the matching API key.

Configuration Examples

Moonshot/Kimi note: some Anthropic-compatible entrypoints require a non-standard reasoning_content field on assistant tool-call history messages when thinking is enabled and a tool continuation occurs. They may return thinking is enabled but reasoning_content is missing in assistant tool call message. This project does not send that field by default on the Anthropic path. When using Moonshot/Kimi Anthropic entrypoints, disable thinking from the model row More Actions; if you need thinking, prefer the OpenAI Chat-compatible API and set apiStyle to openai-chat. See Moonshot Anthropic Thinking Tool-Call Compatibility.

Anthropic Style Example

{
  "coding-plans.vendors": [
    {
      "name": "my-anthropic-vendor",
      "baseUrl": "https://api.example.com/anthropic",
      "defaultApiStyle": "anthropic",
      "useModelsEndpoint": false,
      "models": [
        {
          "name": "my-model",
          "enabled": true,
          "capabilities": { "tools": true, "vision": false },
          "maxInputTokens": 128000,
          "maxOutputTokens": 30000
        }
      ]
    }
  ]
}

OpenAI Chat Style

{
  "coding-plans.vendors": [
    {
      "name": "my-openai-vendor",
      "baseUrl": "https://api.example.com/v1",
      "defaultApiStyle": "openai-chat",
      "useModelsEndpoint": true,
      "models": []
    }
  ]
}

OpenAI Responses Style

{
  "coding-plans.vendors": [
    {
      "name": "openai-responses-demo",
      "baseUrl": "https://api.openai.com/v1",
      "defaultApiStyle": "openai-responses",
      "useModelsEndpoint": false,
      "models": [
        {
          "name": "gpt-5",
          "apiStyle": "openai-responses",
          "enabled": true,
          "editTools": ["apply-patch"],
          "price": {
            "inputCost": 4,
            "cacheCost": 1,
            "outputCost": 12
          },
          "maxInputTokens": 400000,
          "maxOutputTokens": 128000,
          "reasoningEffortFormat": "responses",
          "streaming": true,
          "supportsReasoningEffort": ["high", "xhigh", "max"],
          "capabilities": { "tools": true, "vision": false, "thinking": true },
          "toolCalling": true,
          "vision": false,
          "zeroDataRetentionEnabled": false
        }
      ]
    }
  ]
}

Configurable Items

Coding Plans uses VS Code's native log channel. coding-plans.logLevel synchronizes the channel's native level, and Set Log Level in the Output panel can temporarily override it. At Trace, the first 1,000 characters of each system/user/assistant message are logged and may contain sensitive context; tool content and image data are excluded from this preview.

API keys should be stored through "Set API Key" in VS Code Secret Storage. coding-plans.vendors[].apiKey is kept only as a deprecated temporary entry; when non-empty, it takes precedence over Secret Storage. If the current vendor has no key, the extension falls back to another vendors[].apiKey with the same baseUrl.

Context Window Display

Limited by VS Code's public API, this extension additionally implements context window display:

• System Instructions: System-class prompts occupy (system prompts, mode descriptions, strategy prompts, etc.), counted as prompt tokens.
• Tool Definitions: Tool definitions occupy (tool names, descriptions, parameter JSON Schema), counted as prompt tokens.
• Reserved Output: Output token budget reserved for this round of response, not the actual generated reply content.
• Context Window: When contextSize is configured, runtime splits the total window into 80% input and 20% output. When contextSize is not configured, it uses explicit maxInputTokens/maxOutputTokens, and the total window follows the native custom endpoint convention of maxInputTokens + maxOutputTokens. The current public API does not provide an interface to return upstream usage breakdown to the native Context Window, so this extension maintains the numerator display of the context window itself.
• Status bar displays a unified CodingPlans entry: the body shows a concise percentage of plan usage and context ratio; hover to view detailed information.
• If the vendor has usageUrl configured, it additionally displays plan quota percentage.

Advanced Features

Intelligent Commit Message Generation

1. Press Ctrl+Shift+P, type Coding Plans: Generate Commit Message
2. The extension analyzes current Git changes and automatically generates a Conventional Commits-compliant commit message
3. You can select the model to use (defaults to the currently configured vendor)

Multi-Workspace Independent Configuration

Vendor configurations can be saved per workspace/folder; API Keys should be stored in VS Code Secret Storage (local) by vendor name.

📊 GitHub Pages Dashboard

The Coding Plans Dashboard is a real-time data panel deployed on GitHub Pages, aggregating monthly fees and benefits from mainstream domestic AI coding plans, as well as OpenRouter vendor performance metrics. Data is automatically scraped daily via scheduled tasks — no manual maintenance required.

Dashboard Overview

Features

Data Pipeline

graph TB
    subgraph Scheduled["⏰ Scheduled Tasks (GitHub Actions)"]
        direction LR
        T1["pricing:fetch"]
        T2["metrics:fetch"]
        T3["openrouter:plans:fetch"]
    end

    subgraph DataFiles["📁 assets/"]
        D1["provider-pricing.json"]
        D2["openrouter-provider-metrics.json"]
        D3["openrouter-provider-plans.json"]
    end

    subgraph Dashboard["🌐 GitHub Pages Dashboard"]
        P1["📦 Domestic Plans"]
        P2["🌍 Overseas Plans"]
        P3["📊 Provider Metrics"]
    end

    T1 --> D1
    T2 --> D2
    T3 --> D3
    D1 --> P1
    D2 --> P3
    D3 --> P2

Tab Details

📦 Domestic Plans

• Coverage: Zhipu, Kimi, iFLYTEK, Volcengine, MiniMax, Baidu Qianfan, Tencent Cloud, JD Cloud, Kuaishou KAT, X-AIO, Compshare, Alibaba Cloud, Infini, Xiaomi MiMo, Moore Threads, StepFun, China Unicom Cloud, National Supercomputing Internet, and 20+ more vendors
• Currency: Chinese Yuan (CNY)
• Filtering Rules: Standard monthly plans only (excluding annual, quarterly, and first-month promotional prices)
• Display: Plan name, price, included quota, validity period, purchase links
• Error Handling: Failed scraping items displayed in a collapsible section at the bottom

🌍 Overseas Plans

• Coverage: Cerebras Code, Synthetic, Chutes, Kilo Pass, and other OpenRouter vendors
• Currency: US Dollar (USD)
• Data Sources: OpenRouter API + vendor website Playwright scraping
• Display: Plan name, price, included quota, OpenRouter link, official pricing page
• Error Handling: Access-restricted or parsing-failed items placed in Pending collapsible section

📊 Provider Performance Metrics

• Availability: Vendor success request ratio over the last 30 minutes
• Latency Metrics:
  • p50: Median latency (50% of requests complete within this value)
  • p90: 90th percentile latency
  • p99: Tail latency (slowest 1% of requests)
• Throughput Metrics: Requests processed per second (RPS)
• Filtering Dimensions:
  • By model vendor (DeepSeek, Qwen, MoonshotAI, ByteDance, etc.)
  • By model name (deepseek-chat, qwen-max, etc.)
  • By provider (Cerebras, Chutes, Kilo, etc.)
  • By cache discount (with/without prompt cache discount)

Local Development

# Install dependencies
npm install

# Fetch latest data (execute in order)
npm run pricing:fetch          # Fetch domestic vendor pricing
npm run metrics:fetch          # Fetch OpenRouter performance metrics
npm run openrouter:plans:fetch # Fetch overseas vendor plans

# Start local preview server
npm run serve:page
# Visit http://127.0.0.1:4173

# Run extension tests
npm test
# Or only run the VS Code Desktop smoke suite (downloads a test VS Code on first run)
npm run test:desktop

Data File Structure

The dashboard uses the following core data files (located in the assets/ directory):

// provider-pricing.json — Domestic vendor monthly plans
{
  "generatedAt": "2026-05-06T12:00:00+08:00",
  "providers": [
    {
      "provider": "zhipu-ai",
      "sourceUrls": ["https://bigmodel.cn/glm-coding"],
      "plans": [
        { "name": "GLM Coding Plan", "price": 199, "currency": "¥", ... }
      ]
    }
  ],
  "failures": []
}

// openrouter-provider-metrics.json — Vendor performance metrics
{
  "generatedAt(Beijing)": "2026-05-06 12:00:00",
  "captureWindow": "30 minutes",
  "models": [
    {
      "id": "deepseek/deepseek-chat",
      "organization": "deepseek",
      "providers": [
        { "provider_name": "Cerebras", "uptime": 99.9, "latency_p50": 120, ... }
      ]
    }
  ]
}

// openrouter-provider-plans.json — Overseas vendor plans
{
  "providers": [ ... ],
  "pending": [ ... ],
  "summary": { "total": 12, "withPricing": 10 },
  "generatedAt(Beijing)": "2026-05-06 16:00:00"
}

"captureWindow": "30 minutes", "models": [ { "id": "deepseek/deepseek-chat", "organization": "deepseek", "providers": [ { "provider_name": "Cerebras", "uptime": 99.9, "latency_p50": 120, ... } ] } ] }

---

## Development

Detailed development documentation can be found in [DEV.md](https://github.com/jqknono/coding-plans-for-copilot/blob/HEAD/DEV.md). Test layers and commands are documented in [docs/testing.md](https://github.com/jqknono/coding-plans-for-copilot/blob/HEAD/docs/testing.md).

---

## Feedback

- **Feature Suggestions**: Submit [Issue](https://github.com/jqknono/coding-plans-for-copilot/issues)
- **Usage Questions**: Include error logs and relevant `settings.json` configuration snippets (with sensitive information redacted) in the Issue
- **Vendor Integration**: Pull Requests are welcome

---

## License

MIT License

---

## Contribution Guidelines

1. Fork this repository
2. Create a feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request