Spark
Sign In
MCP Connector

Detect AI Models in VS Code

VS Code AI Model Detector is a VS Code extension that identifies the current GitHub Copilot AI model from native storage.

Get from source
Works with vscodegithubcopilot
Romar J
Own this? Claim it
91
Spark score
out of 100
Updated 10 months ago
Fresher alternatives ↓
Source checked Sep 10, 2026
Version 2.1.0
Models
gpt 4gpt 4oclaude 3 5 sonnetclaude 3 5 haiku
Add to Favorites

Why it matters

Gain clarity on the AI models powering your VS Code environment. This extension accurately identifies and classifies AI models used by extensions like GitHub Copilot, providing insights into their family, vendor, and capabilities.

Outcomes

What it gets done

01

Real-time detection of active AI models within VS Code.

02

Classification of models by family, vendor, and capabilities.

03

Monitoring of AI model changes as they occur.

04

Support for various VS Code installations and AI providers.

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Capabilities

Tools your agent gets

detect_ai_model

Detects the current AI model being used in VS Code with real-time accuracy.

monitor_model_changes

Monitors AI model changes in real-time with customizable intervals.

get_model_capabilities

Retrieves model capabilities and metadata for specific AI models.

identify_model_metadata

Identifies model family, vendor, token limits, and context windows.

Overview

vscode-ai-model-detector MCP Server

VS Code AI Model Detector reads VS Code's native SQLite storage to identify the AI model currently active in GitHub Copilot Chat, classifying its vendor, family, token limits, and capabilities against a registry of 41+ models. Use it when a tool or workflow needs to know exactly which AI model a VS Code session is using, for usage auditing or model-dependent behavior.

What it does

VS Code AI Model Detector is a Visual Studio Code extension that provides real-time detection and classification of the AI model currently in use by GitHub Copilot and other AI-powered extensions. It reads directly from VS Code's application storage - specifically its SQLite storage database (state.vscdb) and the chat.currentLanguageModel.panel key - to identify the active model with high confidence, then cross-references that identifier against a dynamic registry of 41+ known model IDs to classify family, vendor, and capabilities.

When to use - and when NOT to

Use this when a tool, dashboard, or workflow needs to know precisely which AI model a VS Code session is currently configured to use - for usage auditing, cost tracking by model, or building tooling that behaves differently depending on the active model's capabilities. It is scoped to VS Code's own native storage and Chat Participant API, so it detects models used through VS Code's Copilot Chat integration specifically, across VS Code Stable, Insiders, and VSCodium installs, rather than models used by an entirely separate application.

Inputs and outputs

The extension's API exposes detectCurrentModel(), returning the currently detected model; startModelMonitoring(intervalMs) and stopModelMonitoring(sessionId) for continuous polling of model changes at a given interval; and getModelCapabilities(modelId) for capability metadata on a specific model. Detected model information includes an id, display name, vendor (OpenAI, Anthropic, Google, etc.), family (GPT, Claude, Gemini, etc.), max token limit, supported capabilities, version, and an accuracy/confidence level. The registry covers OpenAI's GPT and O-series models, Anthropic's Claude 3.5/3.7 Sonnet through Opus 4.1 and Sonnet 4.5, Google's Gemini 2.0/2.5 series, DeepSeek Chat, and Grok Code Fast 1, with model IDs and formats matched directly against the official microsoft/vscode-copilot-chat configuration source.

Integrations

Installed from the VS Code Marketplace by searching "AI Model Detector" in Extensions (Ctrl+Shift+X), or directly via its marketplace listing. It requires VS Code 1.85.0 or later and the GitHub Copilot extension for Copilot model detection specifically, since it depends on an active AI extension using VS Code's Chat Participant API. No manual configuration is required beyond installation - detection works automatically from VS Code's native storage. The project is licensed under the MIT License.

Who it's for

Developers, extension authors, and teams who need to know which AI model a given VS Code session is actually using - for usage auditing, per-model behavior, or building on top of Copilot Chat's model selection rather than assuming a fixed default.

const detector = vscode.extensions.getExtension('thisis-romar.vscode-ai-model-detector');
const api = await detector.activate();
const result = await api.detectCurrentModel();
Source README

VS Code AI Model Detector

A Visual Studio Code extension that provides real-time detection and classification of AI models used in GitHub Copilot and other AI-powered extensions. Supports accurate model identification using VS Code's native storage and settings.

Version
VS Code
License

Features

  • 🔍 Real-Time Model Detection: Accurately identifies current AI model from VS Code's application storage
  • 🧠 Dynamic Model Registry: Supports 41+ model IDs across major AI providers
  • ⚡ High Performance: Direct integration with VS Code's SQLite storage
  • 📊 Comprehensive Classification: Detects model family, vendor, and capabilities
  • 🔄 Live Updates: Monitor model changes in real-time
  • 🎯 High Confidence Detection: Uses actual VS Code settings and Chat Participant API
  • 🛡️ Multi-Installation Support: Works with VS Code Stable, Insiders, and VSCodium

Supported Models

Source: Model IDs and formats match official VS Code Chat Model enums from microsoft/vscode-copilot-chat configurationService.ts

OpenAI GPT Series

OpenAI O-Series

Anthropic Claude Series

Google Gemini Series

Other Models

Installation

  1. Open VS Code
  2. Go to Extensions (Ctrl+Shift+X)
  3. Search for "AI Model Detector"
  4. Click Install

Or install from VS Code Marketplace: AI Model Detector Extension

Usage

Basic Detection

const detector = vscode.extensions.getExtension('thisis-romar.vscode-ai-model-detector');
const api = await detector.activate();

const result = await api.detectCurrentModel();
console.log('Current Model:', result.currentModel);

Monitor Model Changes

// Start monitoring with 5 second intervals
const sessionId = await api.startModelMonitoring(5000);

// Later, stop monitoring
await api.stopModelMonitoring(sessionId);

Get Model Capabilities

const modelInfo = await api.getModelCapabilities('claude-3.5-sonnet');
console.log('Capabilities:', modelInfo.capabilities);

How It Works

Model Detection Process

  1. Queries VS Code's SQLite storage database (state.vscdb)
  2. Looks for chat.currentLanguageModel.panel key
  3. Parses model identifier to determine family and provider
  4. Cross-references with dynamic registry of 41+ models
  5. Returns comprehensive model information with high confidence

Dynamic Registry

  • Real-time updates for new model versions
  • Format normalization (dots vs hyphens)
  • Comprehensive metadata including:
    • Token limits
    • Special capabilities
    • Context windows
    • Model families
    • Vendor information

Model Metadata

Each detected model includes:

interface ModelInfo {
  id: string;           // Unique model identifier
  name: string;         // Display name
  vendor: ModelVendor;  // OpenAI, Anthropic, Google, etc.
  family: ModelFamily;  // GPT, Claude, Gemini, etc.
  maxTokens: number;    // Maximum context length
  capabilities: ModelCapability[]; // Supported features
  version?: string;     // Model version if available
  accuracy?: string;    // Detection accuracy level
}

Configuration

No configuration required for basic usage. The extension automatically detects models from VS Code's native storage.

Requirements

  • Visual Studio Code >= 1.85.0
  • GitHub Copilot extension (for Copilot model detection)
  • Active AI extension using VS Code's Chat Participant API

Attribution

This project follows the GIT-ATT-001 v1.1.0 standard for AI attribution. All commits should include proper AI attribution blocks:

AI-Attribution:
- Model: <model-id> (Vendor)
- Session: <chat-session-uuid or manual-commit-timestamp>
- Context: <development context>

Co-authored-by: <Platform-Name> (<model-id>) <admin+llm-[normalized-id]@emblemprojects.com>

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.