Mighty Max

MiniMax M-series language models for VS Code Chat (BYOK).

What this is

Mighty Max is a Visual Studio Code and VS Code Insiders extension that contributes the MiniMax M-series models (M3.1 Flash Preview, M3, M2.7, M2.5, M2, M1) to VS Code Chat via the Language Model Chat Provider API (finalized in VS Code 1.109). It registers under the minimax vendor and works as a complete drop-in backend for Ask, Edit, Inline Chat, Agent mode, custom and local agents, and utility tasks (commit messages, etc).

The defining feature is full agentic tool-calling parity: VS Code hands the model a tool set per request, Mighty Max translates that set into MiniMax's tool schema, streams tool calls back as the model emits them, feeds tool results back, and loops until the agent turn completes — without dropping, reordering, or garbling calls across many rounds.

It speaks the MiniMax OpenAI- and Anthropic-compatible endpoints on platform.minimax.io, streams responses incrementally, surfaces M3's native thinking blocks, supports image input, and reports accurate token usage so the context-window widget stays correct. Usage is billed by MiniMax and does not count against Copilot quotas.

Requirements

• VS Code 1.109 or later (Stable or Insiders)
• A MiniMax API key — set via the Mighty Max: Manage command

Installation

From Marketplace

1. Open VS Code or VS Code Insiders (version 1.109 or later)
2. Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
3. Search for "Mighty Max"
4. Click Install

Alternatively, install from Visual Studio Marketplace.

The extension ships as a single CommonJS bundle with no native dependencies or node_modules.

From VSIX

Download the .vsix file from the GitHub Releases page, then:

code --install-extension mighty-max.vsix

Getting Started

1. Get a MiniMax API Key

1. Sign up at platform.minimax.io
2. Navigate to your API keys section
3. Create a new API key (starts with sk-)
4. Copy the key — you'll need it in the next step

Billing: Usage is billed directly by MiniMax based on your subscription plan. It does not count against GitHub Copilot quotas.

2. Configure the Extension

1. Open the Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
2. Run "Mighty Max: Manage"
3. Select "Set API key"
4. Paste your MiniMax API key
5. The key is stored securely in VS Code's SecretStorage (never in settings)

3. Select a Model

1. Open the Chat panel (View → Chat or Ctrl+Alt+I / Cmd+Alt+I)
2. Click the model picker dropdown
3. Select a MiniMax model:
   • minimax:MiniMax-M3.1-Flash-Preview — Frontier Flash preview (1M context, multimodal, tunable thinking). M Plan / MiniMax Code tier.
   • minimax:MiniMax-M3 — Latest, with thinking blocks (1M context)
   • minimax:MiniMax-M2.7 — High performance (1M context)
   • minimax:MiniMax-M2.5 — Balanced (1M context)
   • minimax:MiniMax-M2 — Fast (196K context)
   • minimax:MiniMax-M1 — Lightweight (32K context)

4. Start Chatting

Use any Chat feature:

• Ask — Type questions in the Chat panel
• Edit — Select code, right-click → "Edit with Chat"
• Inline Chat — Press Ctrl+I / Cmd+I in the editor
• Agent mode — Enable tools, the model can edit files and run commands

Configuration

The API key never lives in settings — it is stored exclusively in context.secrets (SecretStorage) and entered through the Mighty Max: Manage command.

Multi-key management (flight deck)

Mighty Max can store up to three independent MiniMax API keys (one per slot). Open the manage command and pick 🔑 Manage keys (N slots) to see the per-slot view:

• Set — store or replace the key for a slot (validated against /v1/models like the single-key flow).
• Test — hit /v1/models to confirm the key works.
• Clear — remove the stored key for a slot.
• Make active — promote the slot to the user's preferred pick. Hidden when the slot is already active.
• Rename — give the slot a friendly label (e.g. "personal", "work"); the label persists across restarts in globalState and surfaces in both the manage UI and the status-bar dashboard.

When a stored key fails, the chat-provider marks that slot unhealthy for a kind-appropriate cooldown (auth 60s, rate-limit 30s, http 15s, network 10s, other 5s) and transparently retries the request with the next healthy slot. On success, the fallback winner is promoted to active (sticky rotation) so the next turn hits it instead of reverting to the failed slot — the chat-provider remembers the most-recent fallback in-memory and the status-bar dashboard surfaces "Last fallback: slot N · Mm ago".

The manage command's main menu is now organised around an aviator/flight-deck theme matching the existing mascot brand. A non-selectable status header at the top surfaces the current state ("Active: Slot N ★ ● ● ● Auto-rotate: ON" or "⚠ Active key (Slot N) was rejected Ns ago" when the active slot is in cooldown), then three CTAs:

• ➕ Add or rotate API key — set or replace the active slot's key. The label flips to ⚠ Rotate to a healthy key when the active slot is in cooldown, so the primary action is always the one that fixes the visible problem.
• 🔑 Manage keys (N slots) — opens the per-slot flight-deck view (Set / Test / Clear / Make active / Rename per slot).
• ⚙ Settings — opens the settings submenu:
  • Set base URL — change mightyMax.baseUrl.
  • Test all stored keys — run the connectivity probe against every slot, surfacing the per-slot result.
  • Configure utility models — one-click fix for the BYOK "No utility model is configured" warning (see One-click utility model configuration).
  • Log level — change mightyMax.logLevel. The current value shows inline on the row so you can see the active setting before picking.
  • Auto-rotate — flip mightyMax.enableAutoKeyRotation. The row label reflects the current state ("● … ON" / "○ … OFF").

Token plan usage indicator

Once a Subscription Key is stored, Mighty Max adds a status-bar item on the right side (the Mighty Max aviator glyph) carrying a flight-deck dashboard tooltip. The dashboard is a 5-section markdown layout that surfaces everything you need to know about your key pool at a glance:

▼ Mighty Max · Flight Deck
─────────────────────────
Slot 1 ● healthy ★ personal
Slot 2 ● healthy   work
Slot 3 ○ cooldown 47s
─────────────────────────
Auto-rotation: ON
Last fallback: slot 2 · 3m ago
─────────────────────────
5h window: 42% used ████░░░░░░
Weekly:    18% used ██░░░░░░░░
as of 16:24:03 · click for details

The headline percentage (next to the icon) drives the background tint:

• 0–79% — neutral foreground
• 80–99% — warning tint
• 100% — error tint (the console also pauses requests at 100%)

The item text gets a $(error) codicon suffix when the active slot is in cooldown so the failure mode is visible at a glance without hovering. Click (or run Mighty Max: Show MiniMax Usage) to open a compact panel with the same data, a refresh button, and a collapsible raw-response disclosure that helps diagnose schema drift.

The indicator refreshes every 5 minutes. Switching the API key via Mighty Max: Manage triggers an out-of-band refresh so the new quota shows immediately. Pay-as-you-go keys don't have a Token Plan bar — the adapter catches the 4xx and the status bar stays neutral with a "click for details" tooltip, never a red icon.

The endpoint is GET https://www.minimax.io/v1/token_plan/remains and is unauthenticated from MiniMax's published schema standpoint — it requires only the Subscription Key as a Bearer token. The same endpoint is consumed by the opencode TUI usage display, so the schema interpretation is battle-tested in production.

Utility model (commit messages, doc generation)

MiniMax models can serve as VS Code's utility model for commit message generation, doc string generation, and other short-completion tasks. Set this in your VS Code settings:

{
  "chat.utilityModel": "minimax:MiniMax-M3"
}

Replace MiniMax-M3 with any MiniMax model (M1, M2, M2.5, M2.7, M3, M3.1 Flash Preview). Utility requests are short, tool-less completions optimized for quick, focused responses.

One-click utility model configuration for BYOK agent mode

When you select a MiniMax model as your main agent model, Copilot Chat surfaces the warning

No utility model is configured for 'copilot-utility-small' while the selected main agent model is BYOK.

until chat.byokUtilityModelDefault (or chat.utilityModel + chat.utilitySmallModel) is set. Mighty Max offers a one-click fix via the Mighty Max: Configure Utility Models command (also reachable from the Manage Mighty Max QuickPick). The picker offers three options:

• Use MiniMax for utility tasks (recommended) — writes chat.utilityModel = "minimax/MiniMax-M3" and chat.utilitySmallModel = "minimax/MiniMax-M2.5". No extra quota; usage is billed to your MiniMax account.
• Use the main agent model — writes chat.byokUtilityModelDefault = "mainAgent". Copilot reuses the MiniMax model for utility tasks.
• Use Copilot's models (uses Copilot quota) — writes chat.byokUtilityModelDefault = "copilot". Utility tasks run on Copilot's hosted models.

Media generation (video + image)

Mighty Max wires two of MiniMax's non-chat media APIs — Hailuo-03 video (MiniMax-H3, MiniMax-H3-Max) and image-01 — as both an LM tool and a command palette entry.

Both share the same KeyProvider and MediaArtifactStore, so a video and an image generated in the same session land in the same directory with the same filename discipline. Both surface Open / Reveal / Copy path on success.

Use the command

1. Run Mighty Max: Generate Video (Hailuo-03) from the command palette.
2. Pick a model (H3 or H3-Max), pick a duration (6s or 10s), type a prompt.
3. Wait for the task to finish. MiniMax's Success state usually arrives within 30–120s; the tool polls every mightyMax.videoPollIntervalMs (default 5s) and gives up after mightyMax.videoTimeoutMs (default 10 minutes).
4. On success, a notification surfaces Open, Reveal, and Copy path actions so you can jump straight into the video player or your shell.

Use the chat tool

Any M-series chat model can call mightyMax_generateVideo or mightyMax_generateImage during a turn. Each chat-model invocation is gated by its own setting (mightyMax.allowVideoToolInChat, mightyMax.allowImageToolInChat, both default true) — flip one off to disable autonomous spend on that medium while keeping the command working. Both tools return a single text result with the absolute path of the saved file; the model describes it back to you.

Image shapes

• Aspect ratio — pass aspectRatio. Eight are supported: 1:1 (1024×1024), 16:9 (1280×720), 4:3 (1152×864), 3:2 (1248×832), 2:3 (832×1248), 3:4 (864×1152), 9:16 (720×1280), 21:9 (1344×576). Defaults to 1:1.
• Exact pixels — pass width and height together, each between 512 and 2048 and a multiple of 8. Cannot be combined with aspectRatio.
• Batch — count 1–9, default 1.
• Reproducible — pass seed; same seed plus same parameters gives the same image.

Reference shapes (video)

• Text-to-video — only prompt + durationSec. Both models.
• Image-to-video — also pass firstFrameImageUri. Both models.
• Start-end-to-video — also pass lastFrameImageUri. Both models.
• Subject-reference video — pass up to 4 referenceImageUris. H3-Max only. H3 rejects this with a clear error; H3-Max accepts it.

Where generated files land

By default, saved media lands in <extension-storage>/media/ — the VS Code per-extension directory you don't normally see. Set mightyMax.mediaOutputDir to redirect (e.g. /Users/me/Movies/mighty-max). Add the path to your workspace .gitignore; generated MP4s and PNGs are large and shouldn't be committed.

What this is NOT

• Not chat models. Both endpoints live on different API paths (/v2/video_generation and /v1/image_generation, not /anthropic/v1/messages) and neither has a streaming completion. They're wired as tools, not as model catalog entries.
• Not free. H3 / H3-Max and image-01 are pay-as-you-go. Set the API key in Mighty Max: Manage as usual — the same key covers chat and media.

Not video input

Video output (above) is supported. Video input — attaching a clip and asking a question about it — works on M3 and M3.1 Flash Preview only, because those are the models MiniMax documents as accepting video content blocks. On the M2.x family a video attachment is dropped with a warning rather than sent, since the API would reject the request outright.

Speech and music generation are not built. Speech is a streaming-audio shape that doesn't fit the synchronous media ports here; music generation is closed to new MiniMax users as of 2026-08-20.

Bundled agents & skills

Mighty Max ships with opt-in chat customizations that are surfaced alongside your personal agents in the VS Code Chat panel:

• max-planner — a read-only implementation planner pinned to M3 (MiniMax). It explores the codebase with search/codebase, search/usages, read/problems, and changes, then returns a numbered implementation plan (files to change, risks, open questions). It never edits files or runs commands. Use it when you want a second pair of eyes before starting a non-trivial change.

• max-review — an M3-pinned maintainer review agent with a fixed 🔴/🟡/✅ output contract, a ≥80%-confidence rule, and a hard cap of ten findings per run. It dispatches to language- and topic-specific skills (next bullet) instead of trying to encode every language's idioms in the agent body.

• 12 review skills — chat/skills/<name>/SKILL.md for ten languages, GitHub Actions / CI, and both OWASP lists. max-review selects a skill from its dispatch table based on the files under review; each skill carries the language- or domain-specific checklist. The skills, grouped:

  • Languages — code-review-dotnet (C# / .NET), code-review-rust (Rust), code-review-go (Go), code-review-typescript (TypeScript / JavaScript), code-review-python (Python), code-review-kotlin (Kotlin / JVM), code-review-swift (Swift / Apple platforms), code-review-powershell (PowerShell), code-review-bash (Bash / POSIX shell).
  • CI — code-review-github-actions (workflow .yml, action pinning, script-injection, least-privilege permissions:).
  • Security — owasp-top-10-2025 (A01–A10: access control, injection, supply chain, crypto, logging, exception handling…) and owasp-api-security-2023 (API1–API10: BOLA, broken auth, mass-assignment, SSRF, BFLA, …).

All assets live under chat/agents/, chat/prompts/, and chat/skills/ in the extension source. max-planner, max-review, /review-code, and all 12 review skills ship in the current release.

Mighty Max deliberately does not ship a chatInstructions contribution. chatInstructions injects prompt text into every request that uses a model from this provider — that is invisible to the user and easy to mis-tune. The agent / prompt / skill system is opt-in (you pick max-planner from the agent dropdown) and the prompt is auditable in the file. If you need a persistent system preamble, set mightyMax.systemPrompt in settings; it is redacted in logs and forwarded verbatim to MiniMax.

On VS Code older than the engine floor (1.109), the bundled agents and skills are silently absent — VS Code ignores contribution points it does not recognize — but the model provider and every other feature keep working.

What Mighty Max provides

Mighty Max covers every BYOK-supported surface in VS Code Chat:

What Mighty Max does NOT provide

The following features are outside the BYOK boundary and require a GitHub account with Copilot:

• Inline code completions (ghost text): This is not exposed to BYOK providers and requires the official GitHub Copilot extension.

• Semantic search and #codebase queries: Embeddings-backed features use GitHub's infrastructure and are not surfaced through the Language Model Chat Provider API.

• Other embeddings features: Similarity search, context retrieval, and other vector-backed operations remain GitHub Copilot-specific.

• Agents Window vendor-specific hosts (future): The new VS Code Agents Window may include vendor-specific agent implementations that remain coupled to official SDK providers. Standard agent mode (Chat panel, inline chat) and custom/local agents continue to work with BYOK.

Sub-agent rendering note

When our model spawns a sub-agent, the result renders as a single box in the chat widget — our custom minimax_subagent tool synthesizes the multi-part output into one <task> text block. Sub-agents you invoke directly via @-mention in the chat UI still use VS Code's built-in runSubagent, which renders as multiple boxes (one per emitted text/thinking/tool-call part); the LM provider API doesn't give us a path to rewrite those stored historical results. See tasks/T35-subagent-single-part-rendering.md for the full design note.

Workspace trust posture

Agent-mode tools (apply-edit, run-in-terminal) remain a real security boundary in untrusted workspaces. The manifest is the contract.

Development

npm ci
npm run typecheck
npm run compile
npm test
npm run lint

The build pipeline is tsc -p . (type-check + emit to out/) followed by esbuild out/extension.js (single-file CommonJS bundle to dist/extension.js). Production builds add --minify and disable sourcemaps.

Layout

src/
  extension.ts                 # composition root
  ports/                       # port interfaces (Logger, SecretStore, MiniMaxClient, ModelCatalog, UsageClient, KeyProvider)
  adapters/                    # port implementations (I/O lives here; StatusBarAdapter + UsageTransportAdapter for the usage panel; KeyProviderAdapter for multi-key)
  providers/                   # VS Code LanguageModelChatProvider
  commands/                    # command handlers (manage, flight-deck-view, configure-utility-models, show-usage, quickpick-header)
  lib/                         # domain layer (no vscode, no HTTP)
    domain/                    # pure catalog, mapping, capability, key-pool, slot-labels, flight-deck-tooltip, usage-normalization rules
    *.test.ts                  # unit tests (vanilla mocha, no host)
  test/                        # integration tests (run in the VS Code host)
assets/
  fonts/mightymax.woff         # status-bar glyph (PUA codepoint, contributed via `contributes.icons`)
  img/mightymax-glyph.svg      # source vector for regenerating the .woff

License

MIT