gRouter — AI Coding, Debugging & Planning for VS Code

Four modes. One gateway. Zero API-key sprawl.

gRouter puts a chat assistant, an autonomous coding agent, a durable planner, and a real debugger inside VS Code — all running through the gRouter model gateway, so one key gives you every frontier model instead of one key per provider.

@grouter /agent fix the failing tests         ← autonomous coding, every edit approved
@grouter /plan add OAuth login                ← durable plan, approve it step by step
@grouter /debug why does auth.spec.ts fail?   ← real debugger state + test output
@grouter what does this repo do?              ← chat with visible reasoning

Why gRouter

Most AI coding extensions lock you to one vendor, hide the reasoning, and burn tokens on context you don't need. This one doesn't.

Powered by the gRouter gateway

gRouter runs on gRouter — Premium AI API Gateway: an OpenAI-compatible endpoint (9Router engine) that fronts the major model providers behind a single URL and a single key.

• One key, every model — https://prod.grouter.web.id/v1, drop-in OpenAI-compatible
• Switch models per task — a cheap model for refactors, a reasoning model for hard bugs
• Track spend in one place — usage and limits on a single page
• No provider sprawl — no per-vendor billing accounts, no per-vendor keys

[!NOTE] Published on the VS Code Marketplace as grouter.grouter-code. Install straight from the Marketplace, or grab the VSIX below for a manual, offline install.

Install

From the VS Code Marketplace (recommended)

code --install-extension grouter.grouter-code

Or open the Marketplace page, or search gRouter in the Extensions view.

From VSIX (offline / pinned version)

1. Download grouter-code-0.3.2.vsix
2. Install:

code --install-extension grouter-code-0.3.2.vsix

Or in VS Code: Extensions view → ··· menu → Install from VSIX…

3. Set your API key — command palette → gRouter: Set API Key, or edit ~/.grouter/config.json. Get one from the gRouterBot on Telegram — buy a plan with QRIS and the key is delivered automatically. Usage and limits are on check-usage.

   Your key is stored in ~/.grouter/config.json in your home directory — never inside a repository, never committed.

4. Chat — open the Chat view (Ctrl+Alt+I) and type @grouter hello.

📖 Documentation

→ Read the full user guide — step-by-step, written for people using VS Code for the first time. Install, get an API key, and your first chat, with nothing assumed.

New to this? Start with the user guide. It assumes nothing — no terminal experience, no prior extension installs — and gets you from a bare machine to a working chat.

Verified against the live gateway

These are real terminal captures from this build, run against the production gateway at https://prod.grouter.web.id — not mockups.

Test suite — 24 files, 154 tests, all passing Extension-host suite — 13 tests running inside a real VS Code instance (npm run test:host)

GET /v1/models — 38 models reachable with a single key

POST /v1/chat/completions — live completion

Honest scope: these verify the gateway integration (auth, model listing, chat completions, the SSE-trailer fix) and the test suite. The extension's in-editor UI — chat view, approval prompts, plan panel, debugger integration — has not yet been exercised in a packaged VS Code install. Treat the API layer as validated and the UI as untested.

Commands

Palette commands: Set API Key · Select Model · Test Connection · Open Config · Show Diagnostics · Start MCP Server · Reconnect MCP Servers · Open Plan

Select Model lists every model your gRouter plan can reach — swap models mid-session without touching a config file or adding another key.

Features

Chat with reasoning

Streams answers with the model's thinking shown in a collapsible block (when the model supports it). Context comes from your active file/selection, #-referenced files, and workspace diagnostics — with an explicit token budget and omission notes.

Coding agent with approvals

Every mutating action (file writes, terminal commands, git operations) requires confirmation. Read-only tools run freely. Destructive commands (rm -rf, git reset --hard, force push, curl | sh) can never be auto-approved. In untrusted workspaces, all mutations are disabled.

Planning mode

Plans are durable artifacts stored in SQLite with step-by-step execution, per-step approval, skip/abort, and in-session resume via LangGraph checkpointing (checkpoints are in-memory; after a window reload the plan resumes at the step level from SQLite).

Debug mode

Reads real runtime state via the debug adapter: threads, stack frames, scopes, and variables at a breakpoint. Runs your test suite (auto-detects npm/pytest/cargo/go) and parses failures from vitest/jest/mocha/pytest/cargo output. Evidence-first: reproduce → read state → one hypothesis → fix root cause → verify.

Sub-agent specialists

Delegate focused work to isolated specialists: explorer (map unfamiliar code), researcher (investigate dependencies), reviewer (independent diff review), tester (run verification). All read-only; the parent agent owns every mutation.

25 built-in skills

Markdown playbooks in ~/.grouter/skills/ — each with an objective, goals, and triggers. Matched automatically by your prompt and injected into the agent's context.

Debugging · Code Review · Refactoring · Test Writing · Planning · API Integration · Error Handling · Security Review · Performance · TypeScript Strict · Git Workflow · Code Exploration · Dependency Management · Async & Concurrency · Data Modeling · CLI Development · Frontend & UI · Documentation · Release Management · Incident Response · Log & Output Analysis · Context Management · Tool Orchestration · Prompt Engineering · Skill Authoring

Skills are plain markdown — edit them, delete them, or ask the agent to create new ones (create_skill tool). The agent also learns reusable procedures from completed sessions automatically.

MCP — both directions

Consume external MCP servers — add them to .vscode/mcp.json, .mcp.json, or ~/.grouter/mcp.json:

{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

Expose gRouter's tools as an MCP server — two modes via gRouter: Start MCP Server:

• In-editor (recommended) — a localhost HTTP endpoint (http://127.0.0.1:3987/mcp) where every mutating tool prompts you in VS Code through the approval gate before running.
• Standalone (auto-approves) — spawns dist/mcp-server.js in a terminal with no approval prompts; use only in trusted workspaces. External clients can also connect directly:

{
  "mcpServers": {
    "grouter": {
      "command": "node",
      "args": ["<extension-path>/dist/mcp-server.js", "--workspace", "<your-repo>"]
    }
  }
}

Prefer the in-editor mode for interactive use — it enforces approvals. The standalone mode is for trusted, automated scenarios.

Built-in tools (25 in-editor, 12 in the standalone MCP server)

Read: read_file · list_dir · search_text · find_files · get_workspace_tree · get_diagnostics · get_open_editors · get_selection · git_status · git_diff · get_debug_state · list_breakpoints · fetch_url · list_skills · read_skill Mutating (approval required): apply_patch · write_file · run_command · run_tests · set_breakpoint · remove_breakpoint · launch_debug · create_skill · delete_skill · delegate_to_specialist

Configuration

All settings live in ~/.grouter/config.json:

{
  "apiKey": "gRouter-...",
  "baseUrl": "https://prod.grouter.web.id/v1",
  "model": "DeepSeek-V4-Flash",
  "maxOutputTokens": 8192,
  "reasoning": { "show": true, "effort": "high" },
  "agent": { "maxIterations": 25, "autoApprove": [], "learnSkills": true },
  "tools": { "truncateKB": 64 },
  "telemetry": { "enabled": false }
}

baseUrl defaults to the gRouter gateway, so a stock install talks to https://prod.grouter.web.id/v1 with nothing but your key. Point it at any other OpenAI-compatible endpoint if you prefer.

VS Code settings (Settings UI → search "grouter"):

Storage

~/.grouter/
├── config.json          ← settings + API key
├── grouter.db           ← SQLite: sessions, messages, memory, knowledge, tool usage, plans
├── sessions/<id>/
│   └── state.json       ← per-session JSON state (counters, active plan, files changed)
├── skills/*.md          ← skill playbooks (edit freely)
└── mcp.json             ← optional global MCP server config

Sessions resume automatically for the same workspace (within 12 hours) across window reloads. Session scratch files go to your OS temp dir (%TEMP%/grouter/<id>/) and are cleaned up on deactivate, never touching the workspace.

Requirements

• VS Code 1.140+
• A gRouter API key (grx_...) — buy one from the Telegram bot (paid via QRIS, delivered automatically). There is no free signup or self-service dashboard.

Troubleshooting

Diagnostics: gRouter: Show Diagnostics opens the output channel with version, model, config path, and recent errors.

License

MIT