VS Code AI Normalizer

One local proxy. Many VS Code AI surfaces. Route Copilot Chat, Agent mode, and inline chat through your own OpenAI-compatible endpoints—even when the upstream model speaks inline XML tools instead of JSON tool_calls.

AI Normalizer runs a lightweight local proxy, translates tool formats via pluggable adapters, discovers models from each upstream GET /v1/models, and syncs them into VS Code BYOK chatLanguageModels.json.

Who this is for

• You use a custom or proxied API (Gemini non-customtools, OpenRouter, vLLM, corporate gateway) with VS Code Copilot BYOK.
• Upstream returns XML / text tool calls but VS Code expects OpenAI-style JSON tools.
• You want one config for endpoints, per-model overrides, and automatic model list refresh—without hand-editing every model id.

Requirements

How it works

Copilot Chat / Agent
        │
        ▼
http://127.0.0.1:3847/v1/chat/completions  (AI Normalizer proxy)
        │
        ├── adapter: inline-xml-tools  → XML ↔ JSON tool_calls
        └── adapter: openai-pass-through → unchanged
        │
        ▼
Your upstream API (Gemini proxy, OpenRouter, etc.)

On activate, the extension:

1. Discovers models per endpoint (GET /v1/models or custom modelsUrl).
2. Caches results in models-cache.json (global storage).
3. Merges with aiNormalizer.modelOverrides and optional manual models[].
4. Reloads the proxy and syncs chatLanguageModels.json.

Installation

From source (development):

pnpm install
pnpm run build

Press F5 to launch an Extension Development Host (.vscode preLaunch runs pnpm run build, which compiles TypeScript and builds bin/normalizer-proxy). Or package a VSIX with pnpm run build then npx @vscode/vsce package — see docs/PUBLISHING.md.

End users: Install AI Endpoint Normalizer from the Marketplace (enable Pre-release until stable) or install the VSIX from GitHub Releases. Configure endpoints below, run AI Normalizer: Sync Language Models, reload the window if models do not appear. The extension ships bin/normalizer-proxy (platform-specific); override with aiNormalizer.proxyBinaryPath if needed.

Questions & bugs: GitHub Issues

Configuration reference

Per endpoint:

discoverModels:

Models URL derivation (override with discoverModels.modelsUrl if needed):

Quick start (Gemini OpenAI-compatible)

1. Add endpoint settings (no API key in JSON):

{
  "aiNormalizer.endpoints": [
    {
      "id": "gemini",
      "displayName": "Gemini",
      "upstreamUrl": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
      "adapter": "openai-pass-through",
      "discoverModels": { "enabled": true }
    }
  ]
}

2. Command Palette → AI Normalizer: Set Endpoint API Key → paste your Gemini API key.
3. AI Normalizer: Refresh Model Catalog → AI Normalizer: Sync Language Models → reload VS Code window.
4. Pick AI Normalizer model in Chat; if prompted for a BYOK secret, enter local (see API keys below).

Configuration examples

Gemini Google OpenAI-compatible (/v1beta/openai/)

Official compat base uses /v1beta/openai/ (not /v1/). Use full chat completions URL; models URL is derived automatically.

{
  "aiNormalizer.endpoints": [
    {
      "id": "gemini",
      "upstreamUrl": "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
      "adapter": "openai-pass-through",
      "discoverModels": { "enabled": true }
    }
  ]
}

Run Set Endpoint API Key (stores under aiNormalizer.endpoint.gemini by default). For XML-tool proxies, use inline-xml-tools + gemini-non-customtools profile instead.

Gemini (non-customtools, XML tools)

Upstream returns <tool_use> blocks; Copilot needs JSON tool_calls.

{
  "aiNormalizer.endpoints": [
    {
      "id": "gemini-locked",
      "displayName": "Gemini (normalized)",
      "upstreamUrl": "https://your-proxy.example/v1/chat/completions",
      "adapter": "inline-xml-tools",
      "adapterProfile": "gemini-non-customtools",
      "discoverModels": {
        "enabled": true,
        "ttlMinutes": 120
      }
    }
  ]
}

Run AI Normalizer: Set Endpoint API Key after saving settings.

Tool prompts (inline-xml-tools profiles)

For endpoints using inline-xml-tools and a named adapterProfile, the proxy can inject extra guidance for upstreams that mishandle tools:

Example tuning:

{
  "aiNormalizer.profiles": {
    "gemini-non-customtools": {
      "additionalSystemPrompts": [
        "When the user requests an action, call a tool instead of only describing steps."
      ]
    }
  }
}

This does not remove or replace system messages already sent by Copilot.

OpenAI-compatible pass-through (OpenRouter, vLLM)

No tool translation; discovery still works.

{
  "aiNormalizer.endpoints": [
    {
      "id": "openrouter",
      "upstreamUrl": "https://openrouter.ai/api/v1/chat/completions",
      "adapter": "openai-pass-through",
      "discoverModels": { "enabled": true }
    }
  ]
}

Auto-discovery only (no manual model list)

Leave models omitted or []. Overrides tune discovered ids:

{
  "aiNormalizer.endpoints": [
    {
      "id": "local-llm",
      "upstreamUrl": "http://127.0.0.1:1234/v1/chat/completions",
      "adapter": "openai-pass-through",
      "discoverModels": {
        "enabled": true,
        "modelsUrl": "http://127.0.0.1:1234/v1/models"
      }
    }
  ],
  "aiNormalizer.modelOverrides": {
    "local-llm/llama3": {
      "name": "Llama 3 Local",
      "toolCalling": true,
      "maxInputTokens": 32768,
      "maxOutputTokens": 4096
    }
  }
}

Per-model overrides (Agent vs chat)

Disable tools for a model that does not support Agent mode:

{
  "aiNormalizer.modelOverrides": {
    "openrouter/meta-llama/llama-3-70b-instruct": {
      "toolCalling": false,
      "name": "Llama 3 70B (chat only)"
    }
  }
}

Keys are always endpointId/modelId where modelId matches the upstream list id.

Extra override keys are preserved in synced chatLanguageModels.json model objects. Useful fields include thinking, streaming, and provider-specific metadata.

Endpoints without tool calling

If upstream security policy strips/blocks tool calls, use a chat-only route:

{
  "aiNormalizer.endpoints": [
    {
      "id": "corp-chat",
      "upstreamUrl": "https://gateway.example/v1/chat/completions",
      "adapter": "openai-pass-through",
      "toolsPolicy": "strip",
      "adapterProfile": "chat-only"
    }
  ],
  "aiNormalizer.modelOverrides": {
    "corp-chat/model-id": {
      "toolCalling": false,
      "thinking": true
    }
  }
}

toolsPolicy: "strip" removes outbound tools/tool_choice, normalizes tool-role history to plain text, and strips assistant tool_calls. This keeps chat usable when agent/tool protocols are filtered.

Manual pin + discovery

Keep a manual entry to force capabilities for one id; discovery fills the rest:

{
  "aiNormalizer.endpoints": [
    {
      "id": "gemini-locked",
      "upstreamUrl": "https://your-proxy.example/v1/chat/completions",
      "adapter": "inline-xml-tools",
      "adapterProfile": "gemini-non-customtools",
      "discoverModels": { "enabled": true },
      "models": [
        {
          "id": "gemini-2.5-pro",
          "toolCalling": true,
          "maxInputTokens": 1048576,
          "maxOutputTokens": 65536
        }
      ]
    }
  ]
}

Merge order: discovered → profile defaults → modelOverrides → manual models[] (manual wins on conflicts).

Multi-endpoint

All models appear under one BYOK provider group (default name AI Normalizer):

{
  "aiNormalizer.endpoints": [
    {
      "id": "gemini-locked",
      "upstreamUrl": "https://gemini-proxy.example/v1/chat/completions",
      "adapter": "inline-xml-tools",
      "adapterProfile": "gemini-non-customtools",
      "discoverModels": { "enabled": true }
    },
    {
      "id": "openrouter",
      "upstreamUrl": "https://openrouter.ai/api/v1/chat/completions",
      "adapter": "openai-pass-through",
      "discoverModels": { "enabled": true }
    }
  ]
}

Custom XML tool profile

{
  "aiNormalizer.profiles": {
    "my-gateway-xml": {
      "toolFormatProfile": {
        "toolCallOpen": "<invoke>",
        "toolCallClose": "</invoke>",
        "toolResultOpen": "<result>",
        "toolResultClose": "</result>",
        "nameAttribute": "tool",
        "idAttribute": "call_id"
      },
      "capabilityDefaults": {
        "toolCalling": true,
        "maxInputTokens": 200000,
        "maxOutputTokens": 8192
      }
    }
  },
  "aiNormalizer.endpoints": [
    {
      "id": "gateway",
      "upstreamUrl": "https://gateway.example/v1/chat/completions",
      "adapter": "inline-xml-tools",
      "adapterProfile": "my-gateway-xml",
      "discoverModels": { "enabled": true }
    }
  ]
}

External profiles file

{
  "aiNormalizer.profilesPath": "C:\\Users\\you\\.config\\ai-normalizer\\profiles.json"
}

Sync provider name

{
  "aiNormalizer.syncTargets": [
    {
      "id": "chatLanguageModels",
      "enabled": true,
      "options": { "providerName": "My Company AI" }
    }
  ]
}

Inline editor chat

After sync, run AI Normalizer: Set Inline Chat Default Model or set:

{
  "inlineChat.defaultModel": "gemini-2.5-pro"
}

(use the exact model id from the picker).

Experimental ghost-text completions

Copilot ghost-text does not use BYOK. Optional FIM via the extension:

{
  "aiNormalizer.inlineCompletion": {
    "enabled": true,
    "modelId": "codestral-latest",
    "completionsPath": "/v1/completions"
  }
}

API keys

There are two separate keys. Most setup friction is from mixing them up.

1. Upstream API key (required for discovery and proxy → provider)

Used as Authorization: Bearer … when the extension discovers models and when the proxy calls Gemini/OpenRouter/etc.

To remove a key: AI Normalizer: Clear Endpoint API Key.

Keys are never written to settings.json or chatLanguageModels.json.

2. Copilot BYOK key (VS Code → local proxy)

Synced models use "apiKey": "${input:chat.lm.secret.<id>}" where <id> is aiNormalizer.copilotByokSecretId (default aiNormalizer).

When you first use a synced model, VS Code may prompt for this secret. The local proxy usually does not validate it — enter any placeholder such as local or none. Only use a real value if you add auth on the proxy later.

Never commit API keys in git-tracked files.

Commands

Status bar (cloud icon): click to sync language models.

Model cache file

Default location: extension global storage models-cache.json.

Shape:

{
  "version": 1,
  "updatedAt": "2026-05-29T12:00:00.000Z",
  "endpoints": {
    "gemini-locked": {
      "fetchedAt": "2026-05-29T11:00:00.000Z",
      "sourceUrl": "https://your-proxy.example/v1/models",
      "models": [{ "id": "gemini-2.5-pro", "name": "Gemini 2.5 Pro" }]
    }
  }
}

Override path with aiNormalizer.modelCachePath. Per-model tuning stays in aiNormalizer.modelOverrides (user settings), not in the cache file.

Multiple VS Code windows

One shared proxy listens on aiNormalizer.proxyPort (default 3847). Shared files: chatLanguageModels.json, extension globalStorage (models-cache.json, proxy-config.json).

• The first window to start the proxy owns the process (PID recorded in proxy-owner.json).
• Additional windows attach to the existing proxy, push config via /admin/reload, and do not spawn a second process.
• Stop Proxy in an attached window only detaches locally; it does not kill the shared proxy.
• Closing a window only stops the proxy if that window spawned it.

Run Refresh Model Catalog or Sync Language Models from any window after changing settings.

Troubleshooting

Limitations

Proxy routes

Development

The extension is ESM (package.json "type": "module"). TypeScript uses moduleResolution: "bundler" with .ts import paths; esbuild bundles src/extension.ts → dist/extension.js (single file, vscode external).

pnpm run build         # proxy binary + esbuild extension bundle
pnpm run compile       # esbuild only
pnpm run watch         # esbuild --watch
pnpm run lint          # tsc --noEmit
pnpm run test          # Rust + TS (tsx) + proxy integration
pnpm run test:ts       # unit tests via tsx (no VS Code host)
pnpm run test:integration

Manual pre-publish checklist (Copilot BYOK, multi-window): docs/TESTING.md.
Releases, Marketplace, and Open VSX: docs/PUBLISHING.md.

Security

AI Normalizer runs a local native proxy and handles upstream API keys. Please read SECURITY.md before installing in sensitive environments.

Review the AI Normalizer output channel when debugging; treat upstream keys like production credentials.

License

MIT