OAI Compatible Provider for Copilot

Intercepts GitHub Copilot Chat's native model picker and injects custom OpenAI-compatible provider models (OpenAI, Anthropic, Ollama, Gemini, DeepSeek, etc.) as selectable options. Works by registering models via VS Code extension API and mapping them to configured API endpoints with per-model context windows, temperature, and token limits. Users switch between providers directly in Copilot Chat's UI without leaving the editor.

Provides a visual configuration panel (accessible via Command Palette or status bar) for managing multiple AI providers and models without editing JSON. Stores API keys securely in VS Code's encrypted secret storage, displays real-time token usage, and allows per-model customization of context length, max tokens, temperature, and top_p. Supports importing/exporting configurations for team sharing.

Exposes `temperature` and `top_p` parameters for per-model configuration, enabling control over response randomness and diversity. Users adjust these parameters to tune model behavior (e.g., temperature=0 for deterministic code generation, temperature=1.5 for creative writing). Parameters are applied at request time, affecting all responses from that model.

Allows the same model to be configured multiple times with different settings (e.g., GLM-4.6 with thinking enabled and GLM-4.6 without thinking). Each configuration is treated as a separate selectable option in Copilot Chat's model picker, enabling quick switching between variants without reconfiguring. Useful for comparing model behavior or using different settings for different tasks.

Integrates with VS Code's source control UI to generate commit messages using configured LLM providers. Analyzes staged changes and passes them to the selected model (via OpenAI-compatible API) to produce contextually relevant commit messages. Supports all configured providers and models, allowing users to choose which LLM generates each commit message.

Enables chat queries that include images by passing image data to vision-capable models (e.g., GPT-4V, Claude 3 Vision, Gemini Vision). Images are processed through the OpenAI-compatible API format, allowing users to ask questions about code screenshots, architecture diagrams, or UI mockups directly in Copilot Chat. Supports any provider that implements vision in their OpenAI-compatible API.

Exposes configuration options for reasoning and thinking models (e.g., OpenAI o1, Claude with extended thinking) through per-model settings. Allows users to enable/disable thinking modes, control reasoning depth, and configure related parameters without modifying API requests manually. Passes these flags to the provider's API, enabling access to advanced reasoning capabilities directly from Copilot Chat.

Implements a `read_file` tool that intelligently handles large files by avoiding small chunk reads and instead loading entire files or large semantic blocks. Optimizes context window usage by reducing overhead from fragmented file reads, enabling more efficient analysis of large codebases. Works transparently within Copilot Chat's tool-calling system.

Implements automatic retry logic with exponential backoff for transient API failures (HTTP 429 rate limit, 500/502/503/504 server errors). Retries failed requests without user intervention, improving reliability when providers experience temporary outages or rate limiting. Backoff strategy prevents overwhelming providers during recovery.

Tracks token consumption in real-time for each API call and displays cumulative usage in VS Code's status bar. Provides visibility into token usage across multiple providers and models, enabling cost monitoring and quota management. Token counting mechanism (client-side vs. server-side) not fully documented but integrated into the extension's core workflow.

Abstracts away provider-specific API differences by normalizing all requests to the OpenAI-compatible API format. Supports any provider implementing OpenAI's chat completion API (OpenAI, Anthropic, Ollama, Gemini, DeepSeek, SiliconFlow, ModelScope, Minimax, etc.) without provider-specific code. Maps provider-specific model IDs and parameters to a unified interface.

Allows fine-grained configuration of context window size and maximum output tokens for each model independently. Users specify `context_length` and `max_tokens` per model, enabling optimization for different use cases (e.g., large context for analysis, small context for fast completions). Configuration is applied at request time, controlling how much context the model receives and how long responses can be.