router-for-me/CLIProxyAPI
48.7
Weak · 13 November 2026
318k
lines of production code
Go
primary language
6
measurements over time
What this system is
Features
Add AI Studio and Antigravity executor implementations
This change introduces two new executor implementations in the runtime executor package: the AI Studio executor, which routes requests through a websocket-backed transport for the AI Studio provider, and the Antigravity executor, which proxies requests to the Antigravity upstream using OAuth credentials. The AI Studio executor includes logic for translating requests, handling thinking configuration normalization, and managing session contexts, while the Antigravity executor handles proxying to the Antigravity service with specific base URL configurations. Both executors are accompanied by comprehensive test suites validating their request translation, thinking level normalization, and session handling behaviors.
internal/runtime/executor · high confidence
Add Antigravity provider for thinking configuration
Users can now configure thinking behavior for models via the Antigravity API format. This new provider normalizes thinking budgets and levels, specifically enforcing constraints for Claude models (such as ensuring the budget is less than max\_tokens) and handling the inclusion of thought visibility settings.
internal/thinking/provider/antigravity · high confidence
Add Antigravity provider support and benchmark translation performance
The translator now supports the Antigravity provider, with new translation routes added for converting between Antigravity and other providers (Claude, Gemini, Interactions, OpenAI Chat Completions, and OpenAI Responses). Additionally, comprehensive benchmarks have been added to measure request and response translation performance across large conversation histories and large payloads, ensuring that history turns and content are preserved during translation.
internal/translator · high confidence
Add Antigravity translation logic for OpenAI Chat Completions
Users can now route OpenAI Chat Completions API requests to the Antigravity backend. This new translator converts OpenAI request formats—including multimodal content (images, video, files), reasoning effort, and structured output settings—into Antigravity-compatible JSON, and translates Antigravity streaming and non-streaming responses back into the OpenAI Chat Completions format. The implementation includes handling for tool calls, reasoning content, and finish reasons, ensuring compatibility with existing OpenAI clients.
internal/translator/antigravity/openai/chat-completions · high confidence
Add Antigravity translation support for OpenAI Responses API
Users can now route OpenAI Responses API requests to Antigravity models. This change introduces a new translator that converts OpenAI Responses payloads into the Antigravity schema, handling specific capabilities such as native web search (including domain filtering and system instruction injection), reasoning effort and thinking summary visibility, and namespace-aware custom tool calls. It also ensures correct handling of Claude reasoning signatures and drops incompatible thought blocks, while mapping Antigravity responses back to the OpenAI Responses format for streaming and non-streaming outputs.
internal/translator/antigravity/openai/responses · high confidence
Add Antigravity-to-Gemini request and response translation
The translator now supports converting Antigravity API requests and responses to the Gemini API format. Request translation handles model extraction, system instruction mapping, content role normalization, tool declaration deduplication, and signature sanitization (including specific handling for Claude and Gemini thought signatures). Response translation manages streaming chunks, restores usage metadata, rewrites disambiguated function names, and synthesizes terminal finish reasons when omitted by the upstream provider.
internal/translator/antigravity/gemini · high confidence
Add Claude (Anthropic) OAuth2 authentication support
This change introduces a new authentication provider for Anthropic's Claude API, implementing a complete OAuth2 flow with PKCE. Users can now authenticate via a local callback server, with the system handling token exchange, refresh, and storage. The implementation mirrors the native Claude Code client's behavior, including specific OAuth endpoints, TLS fingerprinting, and device identity management. It also includes support for organization-hashed credential filenames and legacy migration paths to ensure existing credentials are handled correctly.
internal/auth/claude · high confidence
Add Claude-to-Interactions translator with thinking and tool-pairing support
A new translator implementation in the \internal/translator/interactions/claude\ package enables converting Claude API requests and responses into the internal Interactions format. The request converter maps Claude-specific fields such as \thinking\ blocks (including compatibility mode for preserving empty thinking steps), \tool\_choice\, and system messages into Interactions steps, while ensuring tool calls and results are correctly paired even when separated by intervening system messages. The response converter handles both streaming and non-streaming Interactions outputs, translating step deltas, tool use signatures, and finish reasons back into Claude-compatible JSON structures. Comprehensive unit tests verify message mapping, tool schema translation, out-of-order result alignment, and error propagation. Also in this area: Global GitHub token configuration and OAuth system prompt fixes.
internal/translator/interactions · high confidence
Add Codex-to-Interactions translator
Users can now route requests between the Codex and Interactions protocols. This change introduces a new translator in the interactions package that converts Interactions requests into Codex format and translates Codex responses back into Interactions format, handling streaming and non-streaming modes, system instructions, generation config (including reasoning effort and summary), tool calls, and various media content types. The translator is registered automatically via init() and includes comprehensive tests for request conversion, response parsing, and edge cases like unrepresentable attachments.
internal/translator/codex/interactions · high confidence
Add Devin provider authentication and quota integration
Users can now authenticate with the Devin provider using a PKCE-based OAuth flow that supports both browser-based and headless manual code login. The implementation handles token exchange, user profile retrieval, and Connect-RPC seat management to fetch plan details and quota status, ensuring credential records are safely generated with sanitized filenames and enriched with usage signals.
internal/auth/devin · high confidence
Add Google Interactions translator for Claude
Users can now translate requests and responses between the Google Interactions format and Claude. This new translator handles system instructions, generation configuration (including thinking/reasoning levels and tool choices), and message history, including grouping consecutive role turns and mapping tool calls. It also manages media content by converting supported images and documents while refusing unsupported media types like video or audio, and correctly reports unsendable user turn attachments.
internal/translator/claude/interactions · high confidence
Add Kimi (Moonshot AI) authentication support
Users can now authenticate with Kimi (Moonshot AI) services using the RFC 8628 OAuth2 Device Authorization Grant flow. This change introduces the \internal/auth/kimi\ package, which handles token storage, domain resolution (supporting both kimi.com and kimi.ai), and concurrent refresh token deduplication to prevent race conditions. It also includes logic to preserve custom authentication file metadata during token refreshes and relogins, ensuring that user-defined attributes are retained across sessions.
internal/auth/kimi · high confidence
Add Meta (Muse Code) OAuth provider with device flow and API key minting
Users can now authenticate with Meta Muse accounts using the RFC 8628 OAuth Device Authorization Grant flow. The new \internal/auth/meta\ package handles the device code exchange, polls for token issuance, and mints an LLM API key via the \/muse-code/key\ endpoint. Credentials, including access tokens, minted API keys, and user metadata, are persisted to JSON files with support for custom metadata preservation and graceful fallback if key minting fails.
internal/auth/meta · high confidence
Add OpenAI Responses API translator with namespace-aware tool handling
This change introduces a new translator module in \internal/translator/openai/openai/responses\ that converts between OpenAI Chat Completions and the OpenAI Responses API formats. It enables support for the Responses API, including video input handling, reasoning state tracking, and structured tool outputs. A key feature is the recovery of omitted tool namespaces and the qualification of function names with namespaces to ensure correct tool routing and identity preservation during bidirectional translation.
internal/translator/openai/openai/responses · high confidence
Add OpenAI thinking configuration support
Users can now configure the 'thinking' behavior for OpenAI and Codex models. The new Applier in the internal/thinking/provider/openai package maps the system's thinking configuration to the OpenAI-specific 'reasoning\_effort' field in the request body, supporting discrete levels (low, medium, high, xhigh) and modes like Level, None, Auto, and Budget.
internal/thinking/provider/openai · high confidence
Add Vertex AI Gemini authentication support with credential normalization and namespacing
Users can now authenticate with Google Vertex AI Gemini using service account credentials. The system introduces a new credential storage structure that includes a prefix field for per-file model namespacing (e.g., teamA/gemini-2.0-flash) and preserves custom metadata during token refresh. Additionally, a new utility normalizes service account JSON payloads, ensuring private keys are converted to a valid RSA PEM format regardless of their original encoding (PKCS\#1, PKCS\#8, or malformed), and validates the file structure upon import.
internal/auth/vertex · high confidence
Add bidirectional translation between Gemini and Claude Code APIs
This change introduces a new translator module that enables seamless interoperability between Google's Gemini API and Anthropic's Claude Code API. For requests, it converts Gemini API payloads into the format expected by Claude Code, handling model mapping, system instructions, message contents, tool declarations, and adaptive thinking configurations (including level mapping and budget clamping). It also normalizes tool call IDs to ensure deterministic pairing between function calls and results, and correctly drops hidden thought parts and temperature parameters where unsupported. For responses, it translates Claude Code streaming and non-streaming events back into Gemini-compatible JSON, preserving tool use IDs, assembling partial JSON deltas for tool calls, and handling thinking/reasoning content with appropriate signature mapping. The implementation includes comprehensive unit tests covering ID preservation, role turn grouping, schema normalization, and signature handling.
internal/translator/claude/gemini · high confidence
Add bidirectional translation between Google Interactions and Gemini formats
The translator now supports converting requests and responses between the Google Interactions format and the Gemini format. This includes mapping system instructions, generation configurations, tool calls, and file data (such as URIs and inline data) between the two schemas, while handling streaming and non-streaming responses. The implementation also normalizes thinking configurations and preserves thought signatures during conversion, ensuring that complex interactions like function calls and file attachments are correctly translated or refused when unsupported.
internal/translator/gemini/interactions · high confidence
Add bidirectional translation support for Google Interactions chat completions
This change introduces a new translator module in \internal/translator/openai/interactions/chat-completions\ that enables converting requests and responses between the OpenAI Chat Completions format and the Google Interactions format. The implementation registers bidirectional conversion functions, handling the mapping of messages, tool calls, and generation configurations, while also normalizing file content with MIME types and sanitizing generation configs for Antigravity models. Comprehensive tests verify the correct translation of streaming and non-streaming payloads, including tool call sequencing, reasoning content, and environment context propagation. Also in this area: Global GitHub token configuration and OAuth system prompt fixes.
internal/translator/openai/interactions/chat-completions · high confidence
Add custom provider and HTTP request examples
The examples directory now includes a custom provider example (examples/custom-provider/main.go) that demonstrates how to implement a custom AI provider executor, register custom translators, and integrate with the CLI Proxy API server. Additionally, an HTTP request example (examples/http-request/main.go) shows how to use coreauth.Manager.HttpRequest to execute arbitrary HTTP requests with provider credentials injected.
examples/custom-provider · high confidence
Add support for translating OpenAI Responses API requests and responses to Codex
The translator now supports the OpenAI Responses API format for the Codex model. Incoming OpenAI Responses requests are converted to the Codex format by normalizing the input structure, mapping system roles to developer roles, and stripping unsupported fields such as prompt cache breakpoints, token limits, and the user field. Outgoing Codex responses are translated back into OpenAI Responses SSE events, preserving the original request model in response.created and response.in\_progress events.
internal/translator/codex/openai/responses · high confidence
Add xAI (Grok) OAuth2 authentication with device flow and token persistence
Users can now authenticate with xAI using the OAuth2 device authorization grant (RFC 8628). The new \internal/auth/xai\ module handles OIDC discovery, device-code login, and token refresh, persisting credentials to local JSON files. It supports custom base URLs for API access and includes safeguards like deduplicated concurrent refresh requests and metadata preservation during token updates.
internal/auth/xai · high confidence
Added cross-platform browser opening utility
A new \internal/browser\ package has been introduced to provide a unified interface for opening URLs in the user's default web browser. This component abstracts away operating-system-specific command execution, supporting macOS, Windows, and Linux by attempting a platform-agnostic library first and falling back to native commands (such as \open\, \rundll32\, or \xdg-open\) if necessary. It also includes utilities to check browser availability and retrieve platform-specific details.
internal/browser · high confidence
Added example plugin generation script
A new Python script (\generate\_examples.py\) has been added to the \examples/plugin/scripts\ directory. This tool generates example plugin implementations in Go, covering capabilities such as model serving, authentication, execution, request/response translation, thinking, usage tracking, CLI commands, and management APIs.
python · high confidence
CLIProxy SDK v7 with Antigravity model probing and execution tracking
The CLIProxy SDK has been upgraded to v7, introducing the Antigravity provider integration which probes model capabilities (such as web search) with concurrent request deduplication, caching, and hard timeouts to prevent blocking. The service builder now supports credential weight validation, configurable model display names, and max context length overrides. Additionally, a new execution registry tracks in-flight Home-dispatched executions with observation barriers and release sequences, while a discovery advertiser manager handles mDNS service advertisement with IP change detection.
sdk/cliproxy · high confidence
Claude models now support adaptive thinking and stricter budget constraints
The Claude provider now implements a new \Applier\ that supports both manual thinking (via \budget\_tokens\) and adaptive thinking (via \output\_config.eeffort\ for Claude 4.6 models). When adaptive thinking is enabled, the provider sets \thinking.type\ to \adaptive\ and configures the effort level. For manual thinking, the provider ensures that \max\_tokens\ is strictly greater than \budget\_tokens\ to comply with Anthropic API constraints, automatically adjusting the budget or setting \max\_tokens\ if necessary. The provider also handles mode conversion, mapping level-based configurations to budget-based ones for non-adaptive models, and ensures that empty \output\_config\ objects are removed from the request body.
internal/thinking/provider/claude · high confidence
Codex client model catalog now supports apply\_patch tool capabilities
The internal client model catalog for Codex clients now exposes the \apply\_patch\ tool capability. This change introduces logic to determine which models support the \apply\_patch\ tool based on their text support and modality metadata, ensuring that non-text models (like image or video models) do not advertise this capability. The implementation includes a new \apply\_patch.go\ file with the core capability logic and extensive tests in \apply\_patch\_test.go\ to verify correct behavior across various model types and client versions. This allows Codex clients to properly advertise and utilize the apply\_patch tool for supported text models.
internal/client/codex/models · high confidence
Comprehensive request and response logging middleware with streaming support
The API middleware now includes a new request logging system that captures detailed request and response data, including headers and bodies. It supports deferred body capture for large payloads in error-only logging modes, ensuring that large request bodies are spooled to disk rather than held in memory. The middleware also handles streaming responses by capturing the first chunk timestamp (TTFB) and asynchronously logging chunks without blocking the client response. Additionally, it supports WebSocket timeline capture for API websockets, allowing for detailed logging of streaming interactions.
internal/api/middleware · high confidence
Executor introduces context tracking, lifecycle management, and WebSocket transport support
The executor now supports duplex streaming for Codex websockets and manages request context more precisely. New context keys track whether a request originates from a downstream websocket, requires an upstream websocket to preserve incremental context, and whether an upstream attempt has been made. A new execution lifecycle interface allows binding resources that are closed exactly once, even if binding fails. The executor also supports execution-scoped request proxy overrides and defines types for WebSocket response events and observers, enabling plugins to intercept and observe upstream WebSocket traffic. Additionally, a new error type signals when an upstream websocket is no longer reusable and requires a full HTTP replay. Also in this area: Guardian reviews inherit parent session affinity and SIWC credentials are now tracked separately; Fixes concurrent auth updates during batch model registration.
sdk/cliproxy/executor · high confidence
Expose build metadata via HTTP headers
The server now includes compile-time build information—specifically the version, git commit SHA, and build date—in HTTP responses. This metadata is exposed through dedicated HTTP headers, allowing users and operators to easily identify the exact binary version and build timestamp of the running service instance.
internal/buildinfo · high confidence
Gemini thinking configuration support for budget and level modes
The Gemini provider now applies thinking configuration to request bodies, supporting both the numeric \thinkingBudget\ format (used by Gemini 2.5) and the string \thinkingLevel\ format (used by Gemini 3.x). The implementation automatically selects the correct format based on the model's capabilities and the user's mode (Auto, Budget, Level, or None). It also normalizes field names to handle both camelCase and snake\_case variants (e.g., \includeThoughts\ vs \include\_thoughts\) and ensures that conflicting fields are removed to prevent invalid request structures.
internal/thinking/provider/gemini · high confidence
Gemini-to-Gemini request normalization and passthrough support
The Gemini provider now supports direct Gemini-to-Gemini translation, allowing requests to be normalized and passed through without conversion to other formats. The new request normalizer ensures incoming v1beta requests meet schema requirements by adding default roles to content items, renaming \functionDeclarations\ to \function\_declarations\, and mapping \parameters\ to \parametersJsonSchema\. It also backfills empty \functionResponse\ names from preceding \functionCall\ names to prevent API rejections, renames \generationConfig.responseSchema\ to \responseJsonSchema\, and attaches default safety settings. Response handling is implemented as a passthrough, forwarding both streaming and non-streaming responses unchanged while supporting token counting.
internal/translator/gemini/gemini · high confidence
Initial v6 release scaffolding and Docker support
This change introduces the foundational project structure for the v6 release, including a new Dockerfile, docker-compose configurations, and local build scripts for Windows and Linux/macOS. It adds a comprehensive .gitignore and .dockerignore to exclude build artifacts, local data, and IDE files, while providing example configuration files (config.example.yaml, .env.example) and multi-language READMEs (English, Chinese, Japanese) to guide users on setup, providers, and sponsorship.
(repo-wide) · high confidence
Introduce Antigravity OAuth2 authentication service
Added a new \internal/auth/antigravity\ package that implements the Antigravity OAuth2 authentication flow, including token exchange, user info validation, and credential file management. The service handles project ID resolution by querying the code-assist API with a fallback to the onboard-user API, ensures upstream HTTP status codes are preserved in error responses, and aligns the User-Agent header with the CLI short form. Tests verify correct header usage, project ID extraction, and status code propagation.
internal/auth/antigravity · high confidence
Introduce Codex Live WebRTC media relay and session handling
The internal client now supports Codex Live real-time sessions by adding a new handler in the live package that manages WebRTC session bootstrapping, hangup forwarding, and local client-secret authentication. It includes a TCP proxy for WebRTC media relay, allowing audio and data channels to be bridged between the client and the upstream service, and ensures that session state and authorization are correctly propagated through the usage reporting queue.
internal/client/codex/live · high confidence
Introduce Home control plane integration with Redis, mTLS, and concurrency management
This change adds the internal/home package, establishing a new control plane integration for the Home service. It introduces a Redis-backed client for cluster discovery, configuration, and usage statistics, secured via mTLS certificate bootstrapping from JWTs with CA fingerprint verification. The client also implements a new credential concurrency release mechanism with a flusher and retry logic, supports auth dispatch requests with a count field and retry-round contract, and enables plugin status reporting and in-flight credential snapshots.
internal/home · high confidence
Introduce WebSocket relay for proxying HTTP and streaming requests
The internal wsrelay package now provides a WebSocket endpoint (default /v1/ws) that proxies HTTP requests to connected clients. It supports both non-streaming responses via the NonStream method and streaming responses via the Stream method, handling message types for HTTP requests/responses, stream chunks, and errors. The Manager handles session lifecycle, including concurrent connection handling, graceful shutdown, and provider routing.
internal/wsrelay · high confidence
Introduce WebSocket transport executors for Codex and xAI
The runtime now supports executing Codex and xAI requests over WebSocket connections, providing a persistent session transport alongside the existing HTTP fallback. A new \CodexWebsocketsExecutor\ and \XAIWebsocketsExecutor\ handle session state, ID mapping, and transcript continuity, while \CodexAutoExecutor\ automatically routes requests to the WebSocket path when the downstream client and selected authentication enable it. This change also introduces a global model capability cache (\antigravity\_models.go\) to probe and cache available models per account, and refactors the auth management layer by renaming \manager.go\ to \conductor.go\ and introducing a \ResultPolicy\ interface for post-auth execution hooks.
github.com/router-for-me/CLIProxyAPI/v8 · high confidence
Introduce automatic management panel asset synchronization
The system now automatically downloads and updates the management control panel (management.html) from a GitHub repository. A background updater checks for new assets every 3 hours, respecting the new disable-auto-update-panel configuration flag and skipping updates when cluster mode is active. The updater supports proxy settings, authenticates GitHub API requests using the GITHUB\_TOKEN environment variable, enforces a 10 MB download size limit, and allows overriding the storage directory via the MANAGEMENT\_STATIC\_PATH environment variable.
internal/managementasset · high confidence
Introduce flexible authentication provider configuration and registry
The SDK now supports a configurable authentication system where users can define multiple providers via an \AccessConfig\ structure, including built-in inline API key validation and extensible third-party providers. A new global registry allows providers to be registered by type, with support for restricting authentication to a single exclusive provider. The \Manager\ component coordinates these providers, evaluating them in order to authenticate requests and returning specific error codes for missing or invalid credentials.
sdk/access · high confidence
Introduce internal translator wrapper for AI API format conversion
The internal/translator/translator package now provides a centralized wrapper around the SDK translator registry, enabling the system to translate requests and responses between different AI API formats (such as OpenAI, Claude, and Gemini). This change introduces specific functions for registering new translators, translating requests, and handling both streaming and non-streaming response conversions, effectively acting as the core logic layer for interoperability between various AI provider formats.
internal/translator/translator · high confidence
Introduce remote-refreshable model catalogs for Codex and Devin clients
The registry now supports dynamic, network-updated model definitions for the Codex and Devin client integrations. For Codex, a new catalog is embedded from \models/codex\_client\_models.json\ and periodically refreshed from remote URLs, with strict validation of fields like slugs, context windows, and reasoning levels. For Devin, model definitions are loaded from an embedded \models/devin\_models.json\ file and can be updated remotely, with automatic namespacing of model IDs under the \devin/\ prefix. Both catalogs include background updaters that fetch updates every 3 hours, falling back to the embedded data if remote fetches fail, and expose revision tracking and snapshot APIs for consistency.
internal/registry · high confidence
Introduce standalone terminal management interface
A new terminal-based management UI (TUI) is now available for standalone operation, allowing users to manage configuration, API keys, auth files, and OAuth sessions directly from the command line. The interface features a tabbed layout (Dashboard, Config, Auth Files, API Keys, OAuth, Logs) with interactive editing, real-time log streaming, and internationalization support for English and Chinese.
internal/tui · high confidence
Introduces a built-in translator registry and pipeline for cross-schema conversion
The SDK now includes a built-in translator registry and pipeline that allows requests and responses to be converted between different provider schemas (such as OpenAI, Claude, Gemini, and Antigravity). This change adds a structured translation pipeline with middleware support, a registry for managing format-specific transforms, and helper functions to check for and execute translations by format name. Users can now seamlessly route requests through the proxy regardless of the target provider's native schema, with the system handling the necessary JSON transformations for both streaming and non-streaming responses.
sdk/translator · high confidence
Introduces in-memory usage statistics queue with configurable retention and refresh notifications
The \internal/redisqueue\ package now provides an in-memory queue for usage statistics, replacing direct logging or synchronous processing. It supports configurable retention periods (defaulting to 60 seconds, capped at 3600 seconds) and allows enabling/disabling usage tracking via a toggle. The queue broadcasts usage records to subscribers in real-time and supports refresh notifications, ensuring downstream consumers receive updates promptly. Usage records include detailed metadata such as token breakdowns, service tiers, session hierarchy, and request context, enabling comprehensive usage analytics without blocking the main request path.
internal/redisqueue · high confidence
Introduces provider and format identifier constants
A new constant file defines string identifiers for supported AI providers (Gemini, Codex, Claude, OpenAI) and specific response formats (OpenAI response, Antigravity, Interactions). This centralizes naming conventions to ensure consistency across the application when referencing these services.
internal/constant · high confidence
New Antigravity-to-Claude translator for Claude Code API compatibility
Added a new translator package at internal/translator/antigravity/claude that converts Claude Code API requests and streaming responses into the Antigravity backend format. This enables Claude Code clients to proxy through Antigravity by handling thinking signature resolution and caching, stripping Claude Code attribution headers from system instructions, merging message-level system/developer roles into user-visible reminders, and bridging Claude web\_search tools to native Google Search grounding with proper citation and buffering behavior.
internal/translator/antigravity/claude · high confidence
New CLI command to fetch and save Antigravity model lists
A new \fetch\_antigravity\_models\ command has been added to the CLI, allowing users to retrieve the current list of available Antigravity models from the upstream API and save them to a local JSON file for inspection or offline use. The command supports configuration via flags (such as \--auths-dir\, \--config\, and \--output\) and automatically resolves authentication credentials from the specified directory. It implements a robust fetching strategy that prioritizes the daily base URL, retries failed requests up to two times per endpoint, and falls back to alternative endpoints or authentication sources if the initial attempt fails, ensuring reliable model list retrieval even when upstream services are temporarily unavailable.
_cmd/fetch\_antigravity\models · high confidence
New CLI commands to fetch and validate Codex model catalogs
Added the \fetch\_codex\_models\ command, which connects to the Codex API using stored authentication credentials to retrieve the dynamic model catalog and save it to a JSON file for offline inspection or use. The command supports specifying the output path, client version, and authentication directory. Additionally, a \validate\_codex\_models\ command was introduced to verify the integrity of a Codex client model catalog JSON file against the internal registry schema. These tools enable users to manage and inspect the available Codex models independently of the main proxy runtime.
_cmd/fetch\_codex\models · high confidence
New CLI login commands and LAN discovery for multiple AI providers
The CLI now includes dedicated login commands for Anthropic Claude, Antigravity, Devin, Kimi (Moonshot AI), Meta, xAI, and OpenAI Codex (including a device-code flow), all managed through a centralized authentication manager. Additionally, a new LAN discovery command scans the local network for AI gateways using mDNS, supporting custom service types, interface filtering, and JSON output.
internal/cmd · high confidence
New CLI tool to fetch and aggregate Devin model catalogs
A new command-line tool, \fetch\_devin\_models\, has been added to connect to the Devin/Codeium Connect-RPC API, authenticate using stored credentials, and retrieve the dynamic model catalog. The tool aggregates raw model variants (such as different thinking levels) into a consolidated JSON output, which can be saved to a file for inspection or offline catalog updates. It supports flags to customize the auth directory, config file, output path, and whether to dump raw or aggregated data.
_cmd/fetch\_devin\models · high confidence
New Codex-to-Claude translator with compatibility mode for reasoning signatures
A new translator has been added to convert requests and responses between the Codex API and the Claude Code API. The request converter (\ConvertClaudeRequestToCodex\) handles system messages, tool calls, and thinking blocks, while the response converter (\ConvertCodexResponseToClaude\) translates streaming events including text, reasoning, and function calls into Claude-compatible Server-Sent Events. A key addition is the \ConvertClaudeRequestToCodexWithCompat\ function, which preserves assistant thinking blocks with empty or unknown-format signatures for configured compatibility endpoints, ensuring that reasoning content is correctly mapped to Codex's \reasoning\ item type with encrypted content. The implementation includes comprehensive tests for parallel function calls, message flushing, and signature handling across various edge cases.
internal/translator/codex/claude · high confidence
New Gemini-to-Claude translator with thinking block and signature compatibility
A new translator has been added to convert Gemini API requests and responses into the Claude API format, enabling the use of Gemini models (such as deepseek-v4 and gemini-3-flash-preview) through the Claude wire protocol. The implementation handles complex content mapping, including converting Gemini's 'thought' blocks and 'thoughtSignature' fields into Claude-compatible 'thinking' content blocks and signature deltas. It also normalizes system instructions, strips Claude Code attribution headers, and applies default safety settings to ensure compatibility. The translator supports both streaming and non-streaming responses, preserving message structure and tool call alignments while ensuring that empty thinking blocks and signature-only parts are handled correctly without opening invalid content blocks.
internal/translator/gemini/claude · high confidence
New Gemini↔OpenAI request and response translators
The system now includes a new translation layer in the \internal/translator/openai/gemini\ package that converts Gemini API requests to OpenAI Chat Completions format and OpenAI responses back to Gemini format. This enables proxying between the two APIs, handling features such as tool call ID matching (FIFO order, deterministic IDs, and explicit ID preservation), thinking/reasoning content blocks, system instructions with parts and inline data, and multi-choice response merging. The implementation registers the translator via \init()\ and includes comprehensive tests for request conversion, response streaming, and edge cases like null finish reasons.
internal/translator/openai/gemini · high confidence
New OpenAI Chat Completions to Claude Code translator
A new translator has been added to the \internal/translator/claude/openai/chat-completions\ package that converts OpenAI Chat Completions API requests into the Claude Code API format and translates Claude Code responses back to OpenAI-compatible JSON. This includes handling of message roles (system, developer, user, assistant, tool), adaptive thinking/reasoning effort mapping, tool call deduplication and ID sanitization, and usage token tracking (including cache creation and read tokens). A compatibility mode (\ConvertOpenAIRequestToClaudeWithCompat\) is also provided to preserve assistant reasoning content as unsigned thinking blocks. The translator is registered via \init()\ in \init.go\ and includes comprehensive unit tests for request conversion, response streaming, and usage aggregation.
internal/translator/claude/openai/chat-completions · high confidence
New OpenAI-compatible API handlers for Codex, Responses, and Image models
The \sdk/api/handlers/openai\ package now provides dedicated HTTP handlers for the OpenAI-compatible API surface, introducing support for Codex client model catalogs, the Responses API (including streaming, compaction, and robust SSE framing), and image generation endpoints (GPT Image and xAI Grok Imagine). For Codex clients, the model listing endpoint (\/v1/models\) now respects the \client\_version\ query parameter to filter reasoning levels and multi-agent capabilities, ensuring older clients receive compatible model metadata. The Responses handler implements strict SSE frame boundary preservation, filtering of private telemetry events, and proper error emission for stream failures. Image handlers validate supported models (e.g., \gpt-image-1.5\, \gpt-image-2.5\, \grok-imagine-image-2.0\) and handle aspect ratios and resolutions for xAI models. These changes are accompanied by comprehensive tests for streaming error propagation, compact request handling, and model validation.
sdk/api/handlers/openai · high confidence
New OpenAI-to-Gemini Chat Completions translator
A new translator has been added to bridge OpenAI Chat Completions requests to the Gemini API. This component converts OpenAI request formats (including messages, tool calls, reasoning content, and multimodal inputs like images, audio, and video) into Gemini-compatible JSON structures, and translates Gemini responses back into OpenAI streaming and non-streaming formats. It handles specific mappings such as OpenAI modalities to Gemini response modalities, reasoning effort to thinking configuration, and file data normalization, ensuring compatibility for users proxying OpenAI clients to Gemini models.
internal/translator/gemini/openai/chat-completions · high confidence
New SDK API package for embedding CLIProxyAPI management and server configuration
The \sdk/api\ package is introduced to allow external projects to embed CLIProxyAPI without importing internal implementation details. It exposes a \ManagementTokenRequester\ interface that provides endpoints for requesting tokens from providers such as Anthropic, Codex, Antigravity, and Kimi, along with methods for managing OAuth sessions (registration, completion, validation) and checking authentication status. Additionally, it offers server configuration helpers (\ServerOption\) to customize the embedded Gin HTTP server, including middleware injection, router customization, and local management password settings.
sdk/api · high confidence
New SDK handler layer with structured error responses and plugin interceptors
The API handler logic has been reorganized into a new \sdk/api/handlers\ package, introducing a standardized OpenAI-compatible JSON error format that includes specific error types, codes, and retryability flags. This layer now supports a plugin interceptor system that allows request and response interception before and after authentication, as well as stream chunk observation. It also adds context-based routing capabilities, such as prepared model routes and execution session tracking, to support advanced features like session affinity and plugin-based execution.
sdk/api/handlers · high confidence
New auth subsystem files for credits, model routing, and auto-refresh
The auth package introduces several new capabilities: a credits fallback mechanism for Antigravity providers that injects enabled credit types into request payloads when quotas are exhausted; API-key model aliasing and capability routing that resolves configured model names, aliases, and specific settings (such as thinking levels and compatibility flags) to the correct upstream models; an auto-refresh loop that manages token renewal with concurrency limits, timer capping, and handling of blocked or full queues; and an auth change watcher that notifies consumers of structural credential mutations. These changes are accompanied by comprehensive unit tests covering the new logic.
sdk/cliproxy/auth · high confidence
New authentication providers and unified token storage
The SDK now supports authentication for Antigravity, Claude, Codex, and Devin providers, each with their own OAuth flows (including Codex device-code login and Devin headless manual paste). These providers persist credentials via a new FileTokenStore that replaces the previous filestore logic, introducing support for a disabled flag, credential weight validation, and normalized metadata keys.
sdk/auth · high confidence
New backend stores for configuration, authentication, and cooldown state
The internal store layer now supports three new persistence backends: a Git-backed token store that respects configured branches and follows the remote default, an S3-compatible object storage store for mirroring configuration and auth files, and a PostgreSQL-backed store for configuration, authentication metadata, and runtime cooldown state. These additions expand the available storage options for credentials and settings beyond the previous file-based approach.
internal/store · high confidence
New bidirectional translator between Codex and Gemini APIs
A new translator component in \internal/translator/codex/gemini\ enables seamless proxying between the Codex and Gemini API formats. It handles request conversion (mapping system instructions, messages, and tool declarations) and response conversion (transforming streaming and non-streaming events, including text, tool calls, and image generation). The implementation ensures deterministic function call ID pairing, preserves custom IDs, drops hidden thought parts, and supports inline data (images, audio, files) and image generation outputs.
internal/translator/codex/gemini · high confidence
New built-in translator registry and example usage
The SDK now includes a built-in translator registry that automatically registers available format translators via side-effect imports, allowing users to easily check for and apply translations between formats (e.g., Gemini to OpenAI) without manual setup. An example application demonstrates how to use the new registry and translation helpers to convert requests and responses between different API formats.
examples/translator, sdk/translator/builtin · high confidence
New centralized logging infrastructure with credential redaction and CPA trace correlation
The internal logging module has been replaced with a new, centralized system. It introduces a custom Logrus formatter that enforces a strict field order and quotes sensitive values like credentials and connection details. A new diagnostic utility automatically redacts tokens, API keys, and URL userinfo from log messages while preserving critical signals like 'access token expired'. For HTTP requests, a new Gin middleware (\GinLogrusLogger\) captures request/response details and adds request IDs only for AI API paths (e.g., \/v1\, \/backend-api/codex\). Additionally, a new CPA trace ID middleware injects a correlation header (\X-CPA-TRACE-ID\) into responses to link requests with selected credentials, and a \HomeAppLogForwarder\ enables forwarding application logs to the Home client.
internal/logging · high confidence
New example plugins demonstrating host callbacks and management API integration
Added C and Rust example plugins for the host-callback and management-api scenarios. The host-callback examples show how plugins can invoke host-side actions like logging and HTTP requests via the host API, while the management-api examples demonstrate registering and handling custom management resources (such as a /status endpoint) through the plugin interface.
(repo-wide) · high confidence
New example plugins for auth, CLI, executor, and model capabilities
Added example plugin implementations in C and Rust for authentication, command-line execution, model execution, and model provider capabilities. These examples demonstrate how to implement the plugin ABI, including registration, configuration, and specific capability handlers like auth parsing, command execution, and model static registration.
(repo-wide) · high confidence
New internal utility helpers for Claude and Gemini compatibility
The internal/util package now includes a suite of new helper functions to improve provider compatibility and performance. These include schema sanitization for Claude tool inputs and Gemini tool calling, logic to strip Claude Code billing attribution blocks, utilities to detect Claude thinking models and sanitize tool IDs, and a no-copy GJSON parsing helper for efficient handling of large payloads. Comprehensive unit tests are added for all new functionality.
internal/util · high confidence
New management API endpoints for API key usage, generic API calls, and batch auth file operations
The management API now exposes several new capabilities for administrators. You can retrieve API key usage statistics via the new GET /v0/management/api-key-usage endpoint, which groups success and failure counts by provider and base URL. A new POST /v0/management/api-call endpoint allows making generic HTTP requests on behalf of a specific credential, supporting proxy overrides and automatic $TOKEN$ replacement in headers and request bodies. Auth file management has been enhanced with batch operations: you can now upload multiple auth files in a single multipart request and delete multiple files by name in one call. Additionally, the auth file listing endpoint now supports pagination via page and page\_size query parameters.
internal/api/handlers/management · high confidence
New plugin examples for Claude Code web search, request lifecycle, and host callbacks
The \examples/plugin\ directory now includes a comprehensive set of dynamic library plugin examples for Go, C, and Rust. Key additions include a \claude-web-search-router\ plugin that detects Claude Code web search requests and orchestrates fallback execution across antigravity, codex, xAI, and Tavily backends; a \request-lifecycle\ plugin demonstrating concurrency control, HTTP termination, and slot management; and \host-callback\ examples (\host-callback-auth-files\, \host-model-callback\) showing how plugins can interact with host authentication and model execution APIs. The directory also provides a \Makefile\ to build all examples and updated documentation explaining configuration, error handling with HTTP status codes, and scheduler capabilities.
examples/plugin · high confidence
New plugin host SDK with quota, auth, and model discovery APIs
The \sdk/pluginhost\ package now exposes a public SDK surface for embedding the plugin host, allowing applications to manage plugin lifecycle, discover auth-bound models, and handle credential quotas. Embedders can now query active quota providers and their associated plugin IDs, fetch and reset usage quotas for specific credentials, and start or poll authentication login flows with metadata support. The SDK also provides methods to parse credential payloads into multiple auth records and discover models associated with specific providers or authenticated users, ensuring that plugin capabilities like thinking disable types are correctly propagated to the public API.
sdk/pluginhost · high confidence
New proxy utility library with SOCKS5h and HTTPS proxy support
The sdk/proxyutil package introduces a new library for managing HTTP transport proxies, supporting inherit, direct, and explicit proxy modes. It adds support for the socks5h scheme (resolving hostnames via the proxy) alongside existing socks5, http, and https schemes. For HTTPS proxies, it enforces HTTP/1.1 ALPN and configures TLS dial contexts to ensure correct handshake behavior. The implementation preserves default transport settings (such as timeouts and HTTP/2 preferences) when cloning transports for proxy configurations.
sdk/proxyutil · high confidence
New reasoning replay caches for Claude, Codex, Kimi, and Antigravity models
The internal cache layer now includes dedicated replay mechanisms for several model families, enabling stateful continuity across multi-turn sessions. New modules—\claude\_thinking\_replay\_cache\, \codex\_reasoning\_replay\_cache\, \kimi\_thinking\_replay\_cache\, and \antigravity\_reasoning\_replay\_cache\—store and retrieve signed assistant content or reasoning items, supporting both in-memory storage and a persistent Home KV backend with compare-and-swap logic to prevent race conditions. A generic \bounded\_lru\ component is also introduced to manage eviction of least-recently-used entries. These caches ensure that complex reasoning chains and thinking blocks are preserved and correctly replayed for subsequent turns, improving session reliability and reducing redundant processing.
internal/cache · high confidence
New session identity and affinity system with Merkle LCP support
The session management layer in \sdk/cliproxy/session\ has been replaced with a new architecture that derives stable conversation identities and handles hierarchical session relationships. This change introduces \identity.go\ and \info.go\ to extract session metadata from various client protocols (Claude, Codex, OpenAI, Gemini, etc.) and normalize them into canonical UUIDv8s, while \lcp.go\ implements a Merkle-prefix matcher for session affinity based on conversation turn fingerprints. The system now supports complex session topologies, including parent-child lineage, forks, and subagent delegation, and replaces the previous in-memory tree store with a flat KV affinity model for better scalability.
sdk/cliproxy/session · high confidence
New translator for OpenAI Chat Completions to Codex API
A new translator has been added to the \internal/translator/codex/openai/chat-completions\ package that converts OpenAI Chat Completions requests into the OpenAI Responses API format used by Codex, and translates Codex responses back into OpenAI Chat Completions streaming and non-streaming formats. This enables the proxy to route Chat Completions requests to the Codex backend, handling tool calls, multimodal inputs, reasoning content, and usage metadata.
internal/translator/codex/openai/chat-completions · high confidence
Plugin store introduces authentication, rate limiting, and direct installation support
The plugin store now supports authenticating requests to registries, metadata endpoints, and artifact downloads using bearer tokens, basic auth, custom headers, and GitHub tokens, with credentials resolved from environment variables and securely cleared after use. It enforces HTTPS-only matches and validates artifact URLs to prevent credential leakage. GitHub API interactions are protected by a shared rate limiter that respects Retry-After headers, X-RateLimit-Remaining, and secondary rate limits, with exponential backoff for headerless 429 responses. Plugins can now be installed via a direct install type using pinned artifact URLs and SHA-256 checksums, in addition to the existing GitHub release flow. A new home sync mechanism allows manifest-based plugin synchronization with schema versioning and expiration.
internal/pluginstore · high confidence
Protocol multiplexer and Redis queue support for usage tracking
The internal API server now multiplexes incoming TCP connections to route both HTTP and Redis RESP protocol traffic over the same port. This enables a new Redis Pub/Sub and queue interface for usage statistics, allowing external consumers to subscribe to usage channels and poll queue items via standard Redis commands. The multiplexer also fixes a previous issue where idle TCP connections could block the accept loop by dispatching connection handling to separate goroutines and enforcing a read deadline during protocol sniffing.
internal/api · high confidence
Public SDK configuration API for external embedding
The SDK now exposes a public configuration package that re-exports internal server configuration types and helper functions, allowing external projects to embed CLIProxyAPI without importing internal packages. This change provides a stable interface for loading, parsing, and saving configuration files, as well as accessing specific configuration structures for streaming, TLS, discovery, OAuth, and various provider keys.
sdk/config · high confidence
Request-scoped HTTP transport decorator for observation
The SDK now allows attaching a decorator to an HTTP client via context to observe final requests and response bodies without replacing the underlying transport, proxy routing, or connection pools. Users can use \WithDecorator\ to attach an observation function and \Decorate\ to apply it to a client, ensuring that existing client policies (timeouts, redirects) and the selected transport are preserved. This provides a safe, additive seam for monitoring or logging HTTP traffic at the request level.
sdk/httptransport · high confidence
Support for Google Interactions protocol in Antigravity translator
The Antigravity translator now supports the Google Interactions protocol, enabling bidirectional translation between Interactions and Antigravity formats. Requests are converted by normalizing OpenAI-style file content with MIME types, mapping and deduplicating tool names to handle collisions, and translating generation configuration fields such as thinking levels and summaries. Responses are translated into Interactions-specific streaming events (created, status updates, step deltas, completed) and non-streaming step structures, while restoring original function names in responses. This allows users to interact with Antigravity models using the Interactions interface. Also in this area: Global GitHub token configuration and OAuth system prompt fixes.
internal/translator/antigravity/interactions · high confidence
Support for OpenAI Responses API translation to Gemini
Added a new translator module that converts OpenAI Responses API requests and streaming responses into the Gemini API format. This enables proxying OpenAI Responses clients to Gemini models, including support for web search tools, reasoning thought signatures, and parallel function calls.
internal/translator/gemini/openai/responses · high confidence
Unified thinking configuration processing with provider-specific support
The internal/thinking package now provides a centralized system for applying and validating 'thinking' (reasoning effort) configurations across multiple AI providers. This change introduces a unified entry point (ApplyThinking) that handles model capability detection, budget-to-level conversion, and cross-family effort mapping (e.g., mapping 'xhigh' to 'max' for Claude). It adds native support for Kimi (Moonshot AI) and xAI, extending the existing provider appliers for Claude, Gemini, OpenAI, and Codex. The system also introduces model-name suffix parsing (e.g., \model-name(16384)\ or \model-name(high)\) to allow users to override thinking settings directly in the model name, with suffixes taking priority over request body parameters. Additionally, it standardizes reasoning summary visibility handling across protocols and ensures that thinking configurations are correctly stripped or applied based on provider-specific requirements.
internal/thinking · high confidence
Removals
Removal of legacy internal client implementation
The legacy internal client implementation (\internal/client/client.go\) has been removed from the codebase. This deletion eliminates the previous logic for user onboarding, project management, and direct API request handling (including specific endpoints like \loadCodeAssist\ and \onboardUser\), indicating a structural shift in how the application interacts with backend services.
internal/client · high confidence
Architecture
Extracted auth synthesis logic into a dedicated synthesizer package
The authentication file processing logic has been refactored into a new \internal/watcher/synthesizer\ package, separating concerns into \ConfigSynthesizer\ (for API key-based auth) and \FileSynthesizer\ (for OAuth JSON files). This change introduces a unified \AuthSynthesizer\ interface and a \SynthesisContext\ to manage configuration, directory paths, and plugin parsing. The new implementation supports per-credential overrides such as \disable\_cooling\, \request\_retry\, and \priority\, and handles model exclusions and fingerprint profiles for providers like Gemini, Claude, Codex, xAI, and Meta. Comprehensive tests have been added to verify ID generation stability, excluded model merging, and metadata handling.
internal/watcher/synthesizer · high confidence
Behavioural changes
135 commits (46 fixes) modifying internal/pluginhost
A change to existing behaviour in internal/pluginhost — 135 commits (46 fixs), 90 files: “feat(pluginhost): expose token modality details in usage.handle”; “feat(pluginhost): expose outbound HTTP wire profile to plugin requests”; “fix(cliproxy): delegate OpenAI-compatible OAuth refresh to plugin auth providers”; and 132 more (refs \#6973, \#4480, \#3865).
internal/pluginhost · medium confidence · unverified
19 commits (8 fixes) modifying internal/client/codex/optimize-multi-agent-v2
A change to existing behaviour in internal/client/codex/optimize-multi-agent-v2 — 19 commits (8 fixs), 4 files: “Handle encrypted collaboration message schemas”; “feat(codex): support orphan delegation compatibility via orphan-delegation-compatibility”; “feat: migrate CLIProxyAPI to version 8”; and 16 more.
internal/client/codex/optimize-multi-agent-v2 · medium confidence · unverified
2 commits (0 fixes) modifying examples/realtime-openai-go
A change to existing behaviour in examples/realtime-openai-go — 2 commits, 4 files: “refactor: migrate gjson, sjson, and base64 to MoeForge/moego”; “feat(codex): add realtime hangup forwarding and local client-secret support”.
examples/realtime-openai-go · medium confidence · unverified
2 commits (1 fix) modifying internal/client/codex/apply-patch
A change to existing behaviour in internal/client/codex/apply-patch — 2 commits (1 fix), 2 files: “fix(interactions): bridge apply\_patch tool calls in responses translation”; “refactor: migrate gjson, sjson, and base64 to MoeForge/moego”.
internal/client/codex/apply-patch · medium confidence · unverified
29 commits (3 fixes) modifying sdk/pluginabi
A change to existing behaviour in sdk/pluginabi — 29 commits (3 fixs), 2 files: “feat(plugin): add host session affinity lookup callback”; “feat(pluginhost): refactor and enhance plugin system with new execution and thinking capabilities”; “feat(pluginhost): support raw request body byte-range patching”; and 26 more (refs \#3865).
sdk/pluginabi · medium confidence · unverified
37 commits (17 fixes) modifying sdk/api/handlers/claude
A change to existing behaviour in sdk/api/handlers/claude — 37 commits (17 fixs), 4 files: “feat(models): add Claude client model catalog and response builder”; “fix: flush Claude SSE chunks immediately to match OpenAI behavior”; “fix: add Claude→Claude passthrough to prevent SSE event fragmentation”; and 34 more.
sdk/api/handlers/claude · medium confidence · unverified
42 commits (15 fixes) modifying internal/auth/codex
A change to existing behaviour in internal/auth/codex — 42 commits (15 fixs), 31 files: “test(codex): make SIWC power-state checks deterministic”; “feat(auth): add hashed account ID to credential filenames for team plans”; “feat(management): add read-only SIWC credential status endpoint”; and 37 more.
internal/auth/codex · medium confidence · unverified
49 commits (6 fixes) modifying sdk/pluginapi
A change to existing behaviour in sdk/pluginapi — 49 commits (6 fixs), 2 files: “feat(pluginhost): expose token modality details in usage.handle”; “feat(pluginhost): expose outbound HTTP wire profile to plugin requests”; “feat(plugin): add host session affinity lookup callback”; and 46 more (refs \#3865).
sdk/pluginapi · medium confidence · unverified
5 commits (1 fix) modifying internal/thinking/provider/interactions
A change to existing behaviour in internal/thinking/provider/interactions — 5 commits (1 fix), 1 file: “fix(thinking): drop disabled Interactions summaries”; “feat: migrate CLIProxyAPI to version 8”; “refactor: migrate gjson, sjson, and base64 to MoeForge/moego”; and 2 more.
internal/thinking/provider/interactions · medium confidence · unverified
Authentication logic refactored to use interface-based token storage
The internal authentication implementation has been restructured to decouple token persistence from the core auth logic. The previous monolithic \auth.go\ file, which contained hardcoded Google OAuth2 credentials and a tightly coupled \TokenStorage\ struct, has been removed. It is replaced by a new \models.go\ file that defines a \TokenStorage\ interface with a \SaveTokenToFile\ method. This change allows for more flexible token management strategies and simplifies the error handling and initialization flow within the auth package.
internal/auth · high confidence
Background version caching and centralized header utilities for Antigravity
The internal/misc package now includes a background updater that periodically fetches the latest Antigravity Hub version from a remote manifest and caches it, ensuring the CLI reports a compliant version (minimum 2.9.1) to the backend while avoiding request blocking. This change also introduces centralized utilities for HTTP header management, including ScrubProxyAndFingerprintHeaders to remove proxy and fingerprint headers from outgoing requests, and EnsureHeader to standardize header population. Additionally, the package now provides OAuth helper functions for generating random states and parsing callback URLs, as well as credential logging and metadata merging helpers to support authentication flows.
internal/misc · high confidence
Centralized access provider reconciliation logic
The internal access management now uses a new \ReconcileProviders\ and \ApplyAccessProviders\ workflow to manage authentication providers. This change centralizes the logic for detecting configuration changes, allowing the system to automatically add, update, or remove providers based on the current configuration without manual intervention. Users benefit from more consistent and reliable provider management during configuration reloads, ensuring that access controls remain in sync with the defined settings.
internal/access · high confidence
Claude client model catalog with configurable ID cloaking
The internal Claude client now includes a model catalog builder that rewrites non-Anthropic model IDs (e.g., GPT, Gemini) with a 'claude-fable-5-dd-' prefix and reversed characters to hide their true identity in model listings. This cloaking behavior is controlled by a new configuration option that allows users to disable it, exposing the original model IDs instead. The implementation also includes logic to resolve these encoded IDs back to their original forms for request routing, preserving any thinking mode suffixes.
internal/client/claude · high confidence
Claude thinking signature validation and sanitization overhaul
The internal signature handling for Claude models has been significantly expanded to support new signature formats and improve compatibility across providers. New files introduce strict validation for the Antigravity CAQS (Q-form) double-base64 envelope used by Claude 5.5, rejecting malformed or ambiguous wrappers while preserving valid ones for replay. The system now validates Claude CAIS (C-form) reasoning signatures and strips invalid or empty thinking blocks from payloads, ensuring that only compatible signatures are preserved when switching between Claude, GPT, and Gemini models. Additionally, a new sanitization layer for Claude /v1/messages allows for provider-aware signature handling, including options to preserve empty thinking blocks in compatibility mode and drop tool-use signatures, while Gemini sanitization logic has been updated to correctly handle parallel function calls and bypass sentinels.
internal/signature · high confidence
Claude-to-OpenAI translator now preserves thinking content for compatibility models
The Claude-to-OpenAI request translator now supports a compatibility mode that preserves assistant thinking blocks (reasoning content) when translating to OpenAI-compatible endpoints. This allows models like deepseek-v4 to receive the reasoning content from Claude thinking blocks, while still correctly handling tool calls and other content types. The change includes new test coverage for this behavior, ensuring that thinking content is preserved in compatible translations while being dropped in standard translations for security reasons.
internal/translator/openai/claude · high confidence
Configurable error log retention in file-based request logging
The SDK's file-based request logger now allows users to control how many error log files are retained. A new constructor, NewFileRequestLoggerWithOptions, accepts an errorLogsMaxFiles parameter to set this limit, while the existing NewFileRequestLogger continues to use the default retention of 10 files. This change is implemented by re-exporting types and constructors from the upgraded CLIProxyAPI v7 dependency.
sdk/logging · high confidence
Enhanced configuration change detection with secure, human-readable diffs
The internal configuration watcher now provides detailed, redacted change summaries for both authentication and general configuration updates. The new \auth\_diff.go\ module tracks changes to API key prefixes, proxy URLs, and disabled states without exposing sensitive credentials. The expanded \config\_diff.go\ module detects and reports changes across a wide range of settings, including server ports, debug flags, pprof endpoints, logging configurations, cooling overrides, and specific provider settings for Codex, xAI, and OpenAI compatibility. It also handles complex nested structures like OAuth model aliases, excluded models, and live media relay configurations, ensuring that structural changes are visible to users while keeping secrets and internal hashes secure.
internal/watcher/diff · high confidence
Enhanced configuration management with deep cloning and robust YAML persistence
The configuration system now includes a deep-copy mechanism (\CloneForRuntime\) to provide independent in-memory snapshots, preventing shared reference issues during concurrent runtime updates. Additionally, YAML saving logic has been hardened to correctly persist explicit boolean values (such as \cache-user-id: false\) and properly clear disabled settings (like \strict-mode\), ensuring that the saved configuration file accurately reflects the current state without retaining stale or default values.
internal/config · high confidence
Gemini handler now supports Google Interactions and preserves upstream streaming errors
The Gemini API handler in sdk/api/handlers/gemini has been updated to support Google Interactions via a new POST /v1beta/interactions endpoint, allowing requests to target either a specific model or an agent. The handler also normalizes model listing output to ensure displayName and description fields are preserved from the registry, and fixes a bug where upstream streaming errors occurring before the first data payload were previously lost, ensuring clients now receive these errors correctly.
sdk/api/handlers/gemini · high confidence
Grok client-specific SSE keepalive handling and model response formatting
The Grok client now transforms Server-Sent Events (SSE) keepalive frames into comments when the request originates from a Grok client (identified by 'grok-shell' or 'grok-pager' in the User-Agent), preventing these frames from being processed as data events. Additionally, the \/v1/models\ endpoint now returns a dedicated response format for Grok Shell clients, including fields for reasoning effort levels, context window size, and API backend support, ensuring compatibility with the Grok Shell interface.
internal/client/grokbuild · high confidence
Home plugin synchronization and network scope handling
The home plugin subsystem now supports automatic synchronization of plugin manifests, including direct installation from repository artifacts and version management. This change introduces a new sync mechanism that resolves plugin directories, handles tilde expansion in paths, and ensures that plugin store clients share a common network scope (such as proxy cooldowns) to respect rate limits from external sources like GitHub. The implementation includes detailed reporting on installation status, platform normalization, and secure handling of temporary authentication tokens during sync operations.
internal/homeplugins · high confidence
Introduce core interface contracts and data models for the CLI Proxy API
This change establishes the foundational internal interfaces and shared structures for the CLI Proxy API server. It defines the APIHandler interface, which standardizes how different AI service endpoints are identified and which models they support. New data models are introduced to handle conversation content, including support for inline data (images), function calls with IDs, and function responses. The request structures now include generation configuration options such as temperature, top-p, and a new 'thinking' configuration to control whether the model outputs its reasoning process. Additionally, error handling is formalized with an ErrorMessage type that supports HTTP status codes and direct response bodies, while type aliases are provided to maintain compatibility with the v7 SDK translator package.
internal/interfaces · high confidence
Introduces v2 canonical token accounting and expanded usage record tracking
The usage tracking system now enforces a strict, non-overlapping token accounting contract (schema version 2) that normalizes input and output tokens into mutually exclusive buckets for uncached, cache read, cache write, non-reasoning, and reasoning tokens. This change ensures accurate, provider-specific token breakdowns (e.g., handling OpenAI's subset semantics versus Anthropic's independent buckets) and prevents double-counting or arithmetic overflow. Additionally, usage records now capture richer context including execution request IDs, trace IDs, upstream response models, service tiers, and streaming states, providing more granular visibility into request performance and billing metrics.
sdk/cliproxy/usage · high confidence
Major server architecture overhaul and v7 dependency upgrade
The server entry point has been significantly refactored to support a new modular architecture, introducing dedicated modes for TUI, Home control plane integration, and cloud deployment. This change upgrades the core dependency to CLIProxyAPI v7, centralizes logging via a new logging package, and adds build metadata injection. New command-line flags enable features such as LAN gateway discovery, mTLS certificate bootstrap for Home connections, and local model catalog caching, while the application now supports dynamic configuration reloading and enhanced safe-mode handling for example API keys.
cmd/server · high confidence
Migrate config-api-key provider to internal package
The \config-api-key\ access provider has been moved from its previous location into the \internal/access/config\_access\ package. This change consolidates the provider's registration and authentication logic (handling Authorization, X-Goog-Api-Key, X-Api-Key, and query parameters) within the internal access layer, ensuring it is properly registered with the SDK's access manager via the new \Register\ function.
_internal/access/config\access · high confidence
Model configuration now includes stable hashing and normalized thinking support resolution
The model configuration system now computes stable hashes for OpenAI-compatible, Vertex, Claude, Codex, and Gemini models to ensure consistent routing and caching based on model attributes like name, alias, display name, force-mapping, is-compat flag, max completion tokens, input/output modalities, and thinking support settings. Additionally, a new model info resolution mechanism normalizes thinking support levels (deduplicating and lowercasing them) and derives special flags for 'none' (ZeroAllowed) and 'auto' (DynamicAllowed) levels, while preserving upstream catalog disable types for known models like Claude unless explicitly overridden by configuration.
internal/modelconfig · high confidence
OpenAI Chat Completions translator now drops post-stream chunks and reuses payloads
The OpenAI Chat Completions translator has been updated to improve streaming reliability and performance. It now correctly drops any response chunks that arrive after the terminal \\[DONE\]\ marker, preventing stray data from reaching the client. Additionally, request translation is optimized to reuse the original JSON payload when the model name matches, avoiding unnecessary memory allocations.
internal/translator/openai/openai/chat-completions · high confidence
Plugin store SDK exposes network scope handling and direct install support
The \sdk/pluginstore\ package now exposes a \WithNetworkScope\ method on the client, allowing users to tag HTTP requests with a proxy or egress identity so that shared GitHub API rate-limit cooldowns are correctly applied across clients using the same network path. It also adds support for the \InstallTypeDirect\ install strategy, enabling plugins to be installed from direct artifact URLs rather than only via GitHub releases, and includes validation logic to ensure manifests are correctly pinned to specific release tags or direct artifacts.
sdk/pluginstore · high confidence
Refactored file watcher into modular components with hash-based change detection
The internal watcher logic has been split into focused modules (clients, config\_reload, dispatcher, events) to improve maintainability and performance. Configuration hot-reloads are now debounced (150ms) and use SHA-256 content hashing to skip unnecessary reloads when the config file is unchanged. Auth file updates are processed incrementally using hash-based change detection, avoiding full directory rescans for individual file changes. The dispatcher now batches and deduplicates auth updates, ensuring that concurrent file modifications (adds, deletes, modifications) are preserved during full auth snapshot rescans rather than being overwritten by stale scan data.
internal/watcher · high confidence
Warning page for example API keys includes management link
When the system detects that API keys still contain template values (e.g., 'your-api-key-1'), it now displays a warning page that explicitly lists the problematic keys and provides a direct 'Open Management' button. This button links to the management interface (e.g., /management.html), allowing users to easily navigate to the configuration area to replace the placeholder keys with secure, random values.
internal/safemode · high confidence
Fixes
14 commits (8 fixes) fixing internal/discovery
A fix in internal/discovery — 14 commits (8 fixs), 15 files: “fix(discovery): resolve split mDNS responses with scoped bounded caches”; “fix(discovery): tighten scan timeout, flags, and TCP-only types”; “fix(discovery): close lifecycle and routing gaps”; and 11 more.
internal/discovery · medium confidence · unverified
18 commits (16 fixes) fixing internal/clienterror
A fix in internal/clienterror — 18 commits (16 fixs), 2 files: “fix(logging): exclude HTTP 499 and client cancellations from forced error logs”; “fix(auth): rotate keys after DeepSeek insufficient balance”; “fix(cliproxy): centralize client error status mapping and apply context cancellation/deadline HTTP codes”; and 15 more.
internal/clienterror · medium confidence · unverified
349 commits (184 fixes) fixing internal/runtime/executor/helps
A fix in internal/runtime/executor/helps — 349 commits (184 fixs), 193 files: “fix(claude): keep Fable-only 429 rejections model-scoped when 5h headers are omitted”; “feat(usage): capture structured OpenAI and Codex usage across responses, chat, and images”; “fix(claude): preserve beta profiles across thread turns”; and 344 more (refs \#4275, \#5313, \#4959, \#5048, \#5044, …).
internal/runtime/executor/helps · medium confidence · unverified
50 commits (30 fixes) fixing internal/translator/common
A fix in internal/translator/common — 50 commits (30 fixs), 44 files: “fix(responses): sanitize orphan tool outputs lacking call\_id”; “fix(translator): append trailing newlines to SSEEventData frames”; “fix(translator): preserve Gemini prompt cache by demoting mid-session developer messages (\#5490)”; and 47 more (refs \#5490).
internal/translator/common · medium confidence · unverified
Codex clients now receive normalized integer types for tool parameters
When communicating with Codex clients (identified by a User-Agent containing 'codex'), the tool schema normalization logic now explicitly converts specific parameter fields from 'number' to 'integer'. This fix expands the list of normalized fields to include history and notes tools (such as \history\_\_list\items\, \notes\\_read\file\, and \web\\_run\ sub-fields) alongside existing tools like \exec\command\ and \memories\\_read\. This ensures that integer-typed arguments are correctly typed in the schema sent to Codex clients, preventing potential type-mismatch issues during tool execution.
internal/client/codex/tool-schema · high confidence
Reliable HTTP request ordering with partial-write recovery
The internal HTTP wire layer now reorders HTTP/1.1 request headers to a deterministic sequence while preserving the original casing of unlisted headers and keeping body content intact. Crucially, the connection wrapper tracks write progress so that if a partial write fails, the remaining bytes are correctly buffered and retried on the next write call, preventing data loss or corruption during network interruptions.
internal/httpwire · high confidence
Test coverage
Add comprehensive test coverage for OpenAI Responses ↔ Claude translation; Add comprehensive tests for interactions-to-OpenAI responses translation; Expanded test coverage for translation, thinking, and Codex executor behaviors.
Dependencies
CLIProxyAPI v7 release with Go 1.26 and expanded plugin ecosystem
The project has been upgraded to version 7, moving the Go module path to \github.com/router-for-me/CLIProxyAPI/v7\ and raising the minimum Go version to 1.26. This release introduces a comprehensive suite of example plugins for both Go and Rust, covering authentication, model callbacks, request lifecycle management, and scheduling. The main dependency list has been significantly expanded to include WebRTC support (pion/webrtc/v4), PostgreSQL connectivity (jackc/pgx/v5), and various utility libraries, while the \go.mod\ module name has changed from \github.com/luispater/CLIProxyAPI\.
(dependencies) · high confidence
Housekeeping
Added placeholder file to auths directory
A .gitkeep file was added to the auths directory to ensure the directory is tracked by version control even when empty.
auths · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 49 (-4.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 68 → 69 (+1.2)
- Architecture 72 → 80 (+8.3)
- Maturity 59 → 65 (+5.4)
- Readiness 44 → 42 (-2.2)
- Security 55 → 39 (-16.3)
- Performance 85 → 95 (+10.3)
Resolved (737)
- AntigravityExecutor.buildRequest (cognitive 36) (internal/runtime/executor/antigravity_executor_request.go)
- AntigravityExecutor.buildRequest (cyclomatic 26) (internal/runtime/executor/antigravity_executor_request.go)
- AntigravityExecutor.convertStreamToNonStream (cognitive 85) (internal/runtime/executor/antigravity_executor_execute.go)
- AntigravityExecutor.convertStreamToNonStream (cyclomatic 49) (internal/runtime/executor/antigravity_executor_execute.go)
- Applier.Apply (cognitive 16) (internal/thinking/provider/codex/apply.go)
- Applier.Apply (cognitive 16) (internal/thinking/provider/openai/apply.go)
- Applier.Apply (cyclomatic 16) (internal/thinking/provider/codex/apply.go)
- Applier.Apply (cyclomatic 16) (internal/thinking/provider/openai/apply.go)
- Change coupling: model_definitions.go ↔ devin_models.go (internal/registry/model_definitions.go)
- ClassTooLong: main (cmd/server/main.go)
- CodexExecutor.cacheHelper (cognitive 25) (internal/runtime/executor/codex_executor_request.go)
- CodexExecutor.cacheHelper (cyclomatic 17) (internal/runtime/executor/codex_executor_request.go)
- Duplicated block (10 lines × 2) (internal/api/handlers/management/config_auth_index.go)
- Duplicated block (10 lines × 2) (internal/registry/model_registry.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/antigravity_executor_execute.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/claude_executor_cloaking.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/codex_websockets_execute.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/gemini_vertex_executor.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/gemini_vertex_executor.go)
- Duplicated block (10 lines × 2) (internal/runtime/executor/helps/claude_diagnostics.go)
- …and 717 more
New (1975)
- AIStudioExecutor.Execute (cognitive 16) (internal/runtime/executor/aistudio_executor.go)
- AIStudioExecutor.Execute (cyclomatic 16) (internal/runtime/executor/aistudio_executor.go)
- AntigravityExecutor.buildRequestDoc (cognitive 30) (internal/runtime/executor/antigravity_executor_request.go)
- AntigravityExecutor.buildRequestDoc (cyclomatic 25) (internal/runtime/executor/antigravity_executor_request.go)
- AntigravityExecutor.convertStreamChunksToNonStream (cognitive 135) (internal/runtime/executor/antigravity_executor_execute.go)
- AntigravityExecutor.convertStreamChunksToNonStream (cyclomatic 75) (internal/runtime/executor/antigravity_executor_execute.go)
- Applier.ApplyDoc (cognitive 21) (internal/thinking/provider/claude/apply.go)
- Applier.ApplyDoc (cyclomatic 21) (internal/thinking/provider/claude/apply.go)
- Auth.hasActiveQuotaBlock (cyclomatic 20) (sdk/cliproxy/auth/types.go)
- BoltStore.KVCompareAndSwap (cognitive 24) (internal/kvstore/bolt_store.go)
- BoltStore.KVCompareAndSwap (cyclomatic 19) (internal/kvstore/bolt_store.go)
- BoltStore.KVDel (cognitive 16) (internal/kvstore/bolt_store.go)
- BoltStore.KVIncrBy (cognitive 22) (internal/kvstore/bolt_store.go)
- BoltStore.KVIncrBy (cyclomatic 16) (internal/kvstore/bolt_store.go)
- BoltStore.KVMGet (cognitive 17) (internal/kvstore/bolt_store.go)
- BoltStore.KVSet (cognitive 27) (internal/kvstore/bolt_store.go)
- BoltStore.KVSet (cyclomatic 21) (internal/kvstore/bolt_store.go)
- BoltStore.sweepExpired (cognitive 48) (internal/kvstore/bolt_store.go)
- BoltStore.sweepExpired (cyclomatic 24) (internal/kvstore/bolt_store.go)
- Boundary-crossing change coupling: rpc_schema.go ↔ types.go (internal/pluginhost/rpc_schema.go)
- …and 1955 more
Changes since last survey
- 300 commits — 112 feature/other, 188 fixes
By area
- internal/runtime — 74 commits
- (repo) — 53 commits
- sdk/cliproxy — 31 commits
- internal/translator — 30 commits
- (root) — 18 commits
- internal/api — 17 commits
- internal/pluginhost — 15 commits
- sdk/api — 14 commits
- internal/auth — 9 commits
- internal/registry — 9 commits
- internal/config — 5 commits
- internal/signature — 3 commits
- internal/thinking — 3 commits
- sdk/auth — 3 commits
- internal/home — 2 commits
- internal/wstunnel — 2 commits
- cmd/server — 1 commit
- examples/plugin — 1 commit
- internal/cache — 1 commit
- internal/client — 1 commit
Notable commits
- fix: Merge pull request #6315 from SomSamantray/fix/antigravity-aicode-scope
- fix: Merge pull request #7016 from sususu98/fix/vertex-gemini-thought-signature-7007
- fix: Merge pull request #7042 from sususu98/fix/antigravity-caqs-channel-id
- fix: Merge pull request #7092 from sususu98/fix/slow-test-disconnect
- fix: Merge pull request #7106 from router-for-me/fix/responses-ws-deferred-logging
- fix: Merge pull request #7109 from eaxeax/fix/cooldown-state-relative-auth-dir
- fix: Merge pull request #7141 from Ruanyuxi1337/fix/release-flusher-idle
- fix: Merge pull request #7142 from gabrielrinaldi/fix/grok-video-1.5-lite
- fix: Merge pull request #7143 from router-for-me/fix/codex-no-refresh-token-spin
- fix: Merge pull request #7164 from sususu98/fix/transport-cache-panic-unlock-7162
- fix: Merge pull request #7165 from sususu98/fix/credential-dedup-connection-pool-7163
- fix: Merge pull request #7166 from sususu98/fix/request-logging-finalize-on-panic-7161
- fix: Merge pull request #7167 from sususu98/fix/pluginhost-model-stream-ownership-7159
- fix: Merge pull request #7187 from sususu98/fix/gemini-omitted-content-role-7186
- fix: Merge pull request #7229 from maomaocun/fix/devin-responses-reasoning-passthrough
- fix: Merge pull request #7242 from sususu98/fix/cyber-block-request-fault-and-error-log
- fix: Merge pull request #7265 from sususu98/fix/codex-openai-image-bypass-siwc
- fix: Merge pull request #7294 from router-for-me/fix/home-terminal-request-boundaries
- fix: Merge pull request #7295 from router-for-me/fix/codex-hosted-image-request-scope
- fix: Merge pull request #7305 from router-for-me/fix/codex-refresh-uncertain-outcome
- …and 280 more
Architecture
- Unchanged — 0 containers · 2 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
router-for-me/CLIProxyAPI was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 1aaf56bc6a0fc6fce19049ba7ae8554c882304a6 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-b8b1a43ae4c3.