Alishahryar1/free-claude-code
45.1
Weak · 14 November 2026
77.5k
lines of production code
Python
with JavaScript
7
measurements over time
What this system is
Features
Add Alibaba Cloud Model Studio provider
Users can now connect to Alibaba Cloud Model Studio via a new provider implementation. This adds support for discovering and using models hosted on Alibaba Cloud, leveraging the OpenAI-compatible chat interface while handling Alibaba's specific paginated model catalog and feature capabilities.
_src/free\_claude\_code/providers/alibaba\cloud · high confidence
Add ChatGPT OAuth as an OpenAI Codex provider
Users can now connect their ChatGPT account to use the OpenAI Codex backend for coding assistance. This new provider handles authentication via ChatGPT OAuth, automatically discovers available models for the connected account, and manages request streaming and recovery using the shared OpenAI SDK transport.
_src/free\_claude\_code/providers/openai\codex · high confidence
Add Cloudflare Workers AI provider support
Users can now use Cloudflare Workers AI as a chat provider. This change introduces the Cloudflare provider implementation, which connects to the Cloudflare Workers AI API using an OpenAI-compatible interface. It requires configuration of the Cloudflare account ID and API key, and supports model discovery via the Cloudflare model search endpoint. The provider handles reasoning content mapping and integrates with the existing admission control and retry mechanisms.
_src/free\_claude\code/providers/cloudflare · high confidence
Add DeepSeek provider support via OpenAI-compatible adapter
Users can now use DeepSeek models through the application. This change introduces a new provider implementation that translates Anthropic-format requests into DeepSeek's OpenAI-compatible Chat Completions API. The adapter handles specific DeepSeek requirements, such as stripping unsupported document blocks, managing reasoning content, and correctly accounting for prompt cache hits and misses in usage statistics.
_src/free\_claude\code/providers/deepseek · high confidence
Add GitHub Copilot provider and Messages egress
Users can now connect their GitHub Copilot account to use Copilot subscription models within Free Claude Code. This change introduces the \github\_copilot\ provider, which requires the GitHub Copilot CLI (version 1.0.83) and authenticates via a device-code login flow. Once connected, the provider exposes available Copilot models and supports streaming via the Anthropic Messages API egress, allowing users to generate text using their Copilot entitlements. Also in this area: 1 commit (0 fixes) modifying e2e, free-claude-code, src/free\_claude\_code.
_src/free\_claude\_code/providers/github\copilot · medium confidence · unverified
Add Google Vertex AI provider with renewable ADC and Gemini support
Users can now connect Google Vertex AI as a provider, enabling access to Gemini models via the OpenAI-compatible Chat Completions API. This change introduces a new \google\_openai\ provider family that handles Google-specific behaviors, including thought-signature replay for conversation continuity and reasoning content encoding. It also adds a dedicated \VertexProvider\ that manages renewable Application Default Credentials (ADC) for authentication and performs native model discovery from Google's publisher-model endpoints, ensuring accurate model metadata and context-window limits are available in the catalog.
_src/free\_claude\_code/providers/openai\chat · high confidence
Add LM Studio provider support via OpenAI-compatible endpoint
Users can now connect to LM Studio as a custom provider. This new implementation routes requests through LM Studio's OpenAI-compatible \/v1/chat/completions\ endpoint rather than its native Anthropic Messages path, avoiding issues with control token leakage and silent stream truncation. It includes proactive context-window validation to refuse over-budget prompts early and supports reasoning effort mapping and stream recovery.
_src/free\_claude\code/providers/lmstudio · high confidence
Add Mistral provider with prompt-cache affinity and reasoning support
Introduces a new Mistral provider implementation that enables prompt caching by forwarding the session ID via the \x-affinity\ header, ensuring consistent cache hits across requests. It also adds native support for Mistral's reasoning fields, automatically handling request shaping, stream normalization, and retry logic when the upstream model rejects reasoning parameters.
_src/free\_claude\code/providers/mistral · high confidence
Add fcc-update script to manage Free Claude Code updates
New shell (fcc-update) and Windows batch (fcc-update.cmd) scripts have been added to the scripts/update directory to handle Free Claude Code updates. These scripts check the current release version, validate it, and then execute the appropriate installation script (install.sh or install.ps1) fetched from the GitHub repository for that specific version, ensuring updates are bound to the selected FCC release.
scripts/update · high confidence
Add native Free Claude Code app icon
A new native application icon (app-icon.svg) has been added to the Free Claude Code assets, providing a distinct visual identity for the application.
_src/free\_claude\code/assets · high confidence
Added Free Claude Code branding assets and architecture diagram
The assets folder now includes dark and light SVG wordmarks for "Free Claude Code" to support consistent branding in documentation and UI, alongside a new Mermaid source file and its rendered SVG diagram that visually explains the system architecture, including the proxy, model routing, and provider adapters.
assets · high confidence
Admin UI configuration schema and validation
The Admin UI now exposes a structured configuration interface with sections for providers, model routing, reasoning policies, runtime settings, messaging, voice, web tools, and diagnostics. Users can manage provider credentials, set default and tier-specific model overrides (Fable, Opus, Sonnet, Haiku), configure reasoning policies, and adjust runtime parameters like proxy authentication and timeouts. The system includes validation to ensure settings are valid before application, and displays provider configuration status to help users verify their setup.
_src/free\_claude\code/config/admin · high confidence
Introduce Alibaba Cloud Model Studio provider and centralized runtime configuration
Users can now connect to Alibaba Cloud Model Studio via a new provider that adapts the OpenAI chat transport to the DashScope API, including automatic model discovery and reasoning capability detection. This addition is supported by a new provider runtime layer in src/free\_claude\_code/providers/runtime that centralizes configuration building, model-list discovery, and lazy provider construction, ensuring consistent credential handling and metadata caching across all supported providers.
_src/free\_claude\code/providers/runtime · high confidence
Introduce Anthropic protocol helper library
Added a new \src/free\_claude\_code/core/anthropic\ package providing shared protocol helpers for Anthropic-compatible interactions. This includes content block utilities, error mapping and serialization, portable image source normalization, request serialization and snapshotting, SSE stream aggregation for non-streaming responses, token estimation (including specific handling for tool-result images), and JSON schema helpers for tool arguments.
_src/free\_claude\code/core/anthropic · high confidence
Introduce FCC Desktop shell with system tray and diagnostic tools
Free Claude Code now includes a native desktop shell for Windows and macOS that runs in the system tray, manages the background server lifecycle (including graceful restarts and shutdown), and provides a menu to open the Admin dashboard, check status, restart the server, or quit. The shell uses a singleton lock to prevent multiple instances and keeps local traffic off outbound proxies. Additionally, a new \fcc-doctor\ command is available to generate and copy a JSON diagnostic report to the clipboard for bug reporting.
_src/free\_claude\code/cli · high confidence
Introduce Free Claude Code application layer with model routing and execution
The application layer for Free Claude Code is now available, providing the core logic for model routing, provider execution, and session management. Users can now select from a configurable model catalog that supports reasoning preferences and input modalities, with automatic fallbacks to alternative providers if the primary target fails. The system enforces a configurable progress timeout to cancel stalled inference requests and manages connected account states for provider authentication. Additionally, a new event subscription system allows observers to track session state changes without blocking the main execution flow.
_src/free\_claude\code/application · high confidence
Introduce NVIDIA NIM provider with voice transcription and robust error handling
This change adds a new \NvidiaNimProvider\ to the application, enabling users to interact with NVIDIA NIM models via the OpenAI-compatible API. The provider includes built-in support for NVIDIA NIM voice transcription (using Parakeet and Whisper models via gRPC) for processing audio notes. It also implements specific behavioral improvements for reliability: it correctly maps NIM 500 context overflow errors to \context\_window\_exceeded\, retries requests that fail due to unsupported fields like \chat\_template\ or \reasoning\_content\, and sanitizes tool schemas to handle NIM-specific argument aliasing and parameter restrictions.
_src/free\_claude\_code/providers/nvidia\nim · high confidence
Introduce OpenAI Responses protocol support
The system now supports the OpenAI Responses protocol alongside the existing Anthropic Messages protocol. This change adds a new module that handles the translation of Anthropic Messages requests into OpenAI Responses format, manages the streaming of Responses events back to the client, and maps internal execution failures to OpenAI-compatible error envelopes. Users can now interact with providers that expose the OpenAI Responses interface, with the system handling the necessary request conversion, token usage tracking, and reasoning content preservation.
_src/free\_claude\_code/core/openai\responses · high confidence
Introduce OpenAI Responses streaming primitives
Added a new streaming module under \src/free\_claude\_code/core/openai\_responses/streaming\ that implements the infrastructure for emitting OpenAI-style Responses events. This includes a \ResponseEventBuilder\ to format SSE events (such as \response.created\, \output\_item.added\, and text/function-call deltas), a \ResponsesOutputLedger\ to track active blocks and calculate token usage, and a \ResponseBlockCompleter\ to finalize text, reasoning, and tool blocks into the appropriate output items.
_src/free\_claude\_code/core/openai\responses/streaming · high confidence
Introduce OpenRouter provider with image-input and reasoning error handling
Users can now use the OpenRouter provider, which exposes tool-capable models with reasoning metadata. The implementation includes specific error handling: it translates OpenRouter 404 errors related to image input into clear user messages advising to remove images or select an image-capable model, and it correctly handles reasoning-control rejection errors (HTTP 400) to ensure smooth interaction with providers that require thinking.
_src/free\_claude\_code/providers/open\router · high confidence
Introduce dedicated Anthropic streaming engine components
This change introduces the core implementation files for the Anthropic streaming engine within the \src/free\_claude\_code/core/anthropic/streaming\ directory. It adds an SSE decoder (\decoder.py\) capable of handling arbitrarily split text chunks while preserving frame order, an emitter module (\emitter.py\) for serializing Anthropic-style Server-Sent Events and mapping stop reasons, and a ledger module (\ledger.py\) for tracking stream state. These components provide the foundational infrastructure for processing and emitting streaming responses in the Anthropic protocol format.
_src/free\_claude\code/core/anthropic/streaming · high confidence
Introduce local smoke test infrastructure and DSH desktop acceptance driver
Adds a new \smoke/lib\ package that establishes the foundation for local-only smoke testing. This includes a deterministic DSH (Desktop Shell) protocol provider fixture (\dsh\_provider.py\) and an Electron-based acceptance driver (\dsh\_desktop.cjs\) to validate desktop session lifecycle, connection, and disconnection states. The suite also introduces robust child-process execution helpers (\child\_process.py\) to prevent flaky Windows console-locking issues, HTTP request builders with session tracking (\http.py\), and outcome classification logic (\outcomes.py\, \skips.py\) to reliably distinguish between upstream unavailability and product failures.
smoke/lib · high confidence
Introduce local-only Admin UI with secure, cache-free access
The API layer now serves a local Admin interface (accessible at /admin) that is strictly restricted to loopback connections, enforcing security by validating the client host, Host header, and Origin header. To protect sensitive configuration data, an AdminNoStoreMiddleware ensures all Admin responses include a Cache-Control: no-store header, preventing browser caching. The Admin UI is versioned against the package release to ensure asset consistency, and the application factory wires up request correlation, lifetime tracking, and outcome logging middleware alongside dedicated exception handlers for code sessions and application errors.
_src/free\_claude\code/api · high confidence
Introduce native Anthropic Messages provider support
Added a new provider implementation in src/free\_claude\_code/providers/anthropic\_messages that enables direct communication with the Anthropic Messages API. This includes model discovery to list available models, a transport layer to handle request preparation and streaming, and wire utilities to parse server-sent events and manage upstream errors. Users can now interact with Anthropic models using the native Messages protocol, which supports features like streaming responses, automatic retry on transient failures, and recovery of interrupted streams.
_src/free\_claude\_code/providers/anthropic\messages · high confidence
Introduce native client harnesses for Claude, Codex, and DeepSeek
This change adds a new \harnesses\ module that manages the configuration and integration of native AI coding clients. It provides logic to connect and disconnect Claude Code in VS Code and JetBrains, configure the Codex CLI via TOML, and integrate with DeepSeek Harness Desktop via YAML. The module also handles independent Claude onboarding, model catalog serialization for these clients, and secure atomic writes to local configuration files.
_src/free\_claude\code/harnesses · high confidence
Introduce native folder picker and secure web tools for Code sessions
The runtime now provides a native OS folder picker dialog for Code sessions, replacing previous methods with platform-specific implementations (tkinter on Windows, osascript on macOS, zenity/kdialog on Linux) that run as isolated subprocesses. Additionally, the runtime includes a secure HTTP client for web search and fetch tools, featuring strict egress policies that validate DNS resolution to prevent server-side request forgery (SSRF) by pinning connections to pre-validated IP addresses and blocking private or localhost targets. Also in this area: Free Claude Code provider recovery and timeout adjustments; Introduce structured smoke testing framework and local admin UI.
_src/free\_claude\code/runtime · high confidence
Introduce persistent native code sessions
Free Claude Code now supports persistent, server-owned coding conversations that survive HTTP and browser lifetimes. This change introduces a new application module (\src/free\_claude\_code/application/code\_sessions\) containing the core service, models, and ports required to manage these sessions, including state management, storage integration, and event publishing.
_src/free\_claude\_code/application/code\sessions · high confidence
Introduce platform-agnostic messaging layer with Discord support
A new messaging subsystem has been added to provide a unified, platform-agnostic interface for interacting with Claude Code. This change introduces a structured event pipeline that parses raw CLI output into a transcript-friendly format, enabling real-time status updates and streaming responses in chat interfaces. The initial release includes a fully integrated Discord runtime, featuring inbound message handling, voice note transcription, and outbound delivery with rate limiting and message deduplication. Users can now manage conversations via slash commands like /stop, /clear, and /stats, which are handled through a dedicated dispatcher that supports both global and reply-scoped actions.
_src/free\_claude\code/messaging · high confidence
Introduce shared OpenAI Responses transport and presenter layer
The \src/free\_claude\_code/providers/openai\_responses\ module now provides a unified transport layer for executing requests against the OpenAI Responses API. This change introduces \OpenAIResponsesTransport\ to handle the core streaming lifecycle, including request preparation, retry semantics, and context-window recovery, while \presentation.py\ adds specific presenters (\MessagesResponsesPresenter\ and \NativeResponsesPresenter\) to translate upstream OpenAI events into the expected client protocols (Anthropic Messages SSE or native Responses SSE). This consolidates the execution logic for OpenAI-based providers into a shared, reusable component.
_src/free\_claude\_code/providers/openai\responses · high confidence
Introduces a unified provider execution and admission framework
The \src/free\_claude\_code/providers\ module has been restructured to introduce a centralized provider execution lifecycle. This change adds a \BaseProvider\ interface and a \ProviderConfig\ dataclass to standardize how providers are configured and initialized. It introduces a new admission control system (\ProviderAdmissionController\, \ProviderAdmissionRegistry\) to manage rate limits, concurrency, and retry budgets for provider calls. The diff also adds specific implementations for the Anthropic provider, including native message streaming and model discovery, as well as a \CustomProvider\ class to support user-defined API endpoints. Additionally, it includes credential validation probes for various upstream providers and a history replay mechanism to handle context window and reasoning history corrections.
_src/free\_claude\code/providers · high confidence
Introduces managed session pool for parallel Claude Code messaging
Adds a new managed session layer in the CLI that pools and reuses persistent Claude Code subprocesses for messaging. This allows multiple conversations to be processed in parallel, with each new conversation getting its own session while replies to existing conversations reuse the same instance. The implementation includes a session manager for lifecycle control and a session class that handles subprocess execution, bounded stderr capture to prevent memory exhaustion, and proper cleanup on cancellation.
_src/free\_claude\code/cli/managed · high confidence
Introduces structured smoke testing framework and typed runtime ports
This change establishes a new, structured smoke testing infrastructure for the product, introducing a public feature inventory and capability contracts to ensure deterministic coverage of user-facing behaviors like Code session modes, API compatibility, and provider routing. It also defines typed runtime ports (Protocols) for the API, application, and web tools layers, creating explicit boundaries for capabilities such as provider execution, code session persistence, and admin operations.
free-claude-code · high confidence
Native CLI launchers for external coding agents
Free Claude Code now supports launching external coding agents (Aider, Cline CLI, Codex CLI, DeepSeek Harness, Grok Build, Hermes Agent, Muse Code, OpenCode, and Pi) directly from the terminal. These new launchers automatically configure the agents to route requests through the local FCC proxy, handling authentication, model catalog discovery, and environment isolation so users can use their preferred coding tools with FCC models without manual setup.
_src/free\_claude\code/cli/launchers · high confidence
New Admin UI with integrated Code Sessions and third-party app connections
The Admin interface has been replaced with a modern, dark-themed design that introduces a dedicated Code Sessions view for managing and monitoring active coding sessions, including context usage tracking and session controls. The Integrations tab now provides a streamlined way to connect Free Claude Code to external applications like VS Code, JetBrains ACP, and Claude Desktop, handling configuration and status updates directly from the UI. The interface also features a new searchable model combobox for easier model selection and improved form controls that disable browser auto-fill for sensitive fields.
_src/free\_claude\_code/api/admin\static · high confidence
New Markdown rendering utilities for Discord and Telegram
Added new modules in the messaging rendering layer to convert standard Markdown into platform-specific formats for Discord and Telegram. The \discord\_markdown\ module handles Discord's markdown syntax, including escaping special characters and formatting bold, italic, code, links, and images. The \telegram\_markdown\ module implements Telegram's MarkdownV2 format, correctly escaping special characters and handling the lack of native image support by degrading images to plain text. A shared \markdown\_tables\ module normalizes GFM tables to ensure consistent rendering across both platforms.
_src/free\_claude\code/messaging/rendering · high confidence
New public API handlers for Messages, Responses, and Token Counting
The API layer now exposes dedicated handlers for three distinct product flows: Anthropic-compatible Messages (including native routing and reasoning suppression), OpenAI-compatible Responses (streaming-only for Codex clients), and Anthropic-compatible Token Counting. These handlers centralize request validation, model routing, provider execution, and error translation, ensuring that clients using either the Anthropic or OpenAI protocol formats receive correctly structured responses and standardized error codes.
_src/free\_claude\code/api/handlers · high confidence
New release automation and local CI tooling
The scripts directory now includes a comprehensive set of new tools to manage releases and local development workflows. A new version policy script (check\_version\_policy.py) enforces that release changes are tagged with patch, minor, or major prefixes and validates packaging requirements. A new publish\_release.py script automates the creation of GitHub releases and publishing to PyPI. Additionally, platform-specific CI scripts (ci.sh and ci.ps1) allow developers to run the same check sequence locally as GitHub Actions, including linting, type checking, and browser tests. The installation and uninstallation scripts have been expanded to support a wider range of coding agents (such as Muse, Hermes, and DeepSeek) and include native uninstallers for specific tools like Muse Code.
scripts · high confidence
New shared core module for Free Claude Code
A new \src/free\_claude\_code/core\ package has been introduced to centralize shared application logic. This includes a \reasoning\ module for controlling reasoning effort, \async\_iterators\ and \async\_rwlock\ for managing asynchronous resource lifecycles and concurrency, and \continuation\_stream\ to handle response recovery and continuation events. The core also bundles a local \cl100k\_base\ tokenizer for resilient token estimation, \rate\_limit\ for sliding-window rate limiting, and \trace\ for structured, credential-redacted logging. Platform-specific helpers for Windows DPI awareness and interprocess file locking are also included.
_src/free\_claude\code/core · high confidence
New transcript rendering and subagent tracking for messaging UI
The messaging module now includes a new transcript rendering system that processes CLI events into visual segments (text, thinking, tool calls, errors) and supports truncation for long outputs. It also introduces subagent state tracking, which suppresses nested thinking and text events when a Task tool is active, ensuring cleaner display of hierarchical agent interactions in the UI.
_src/free\_claude\_code, src/free\_claude\code/messaging/transcript · high confidence
Standalone update preflight check for Free Claude Code
A new standalone updater module has been introduced to handle version preflight checks independently of the server and harness runtime. This component verifies the currently installed Free Claude Code version against the latest GitHub release and PyPI metadata, ensuring consistency between sources. It determines whether an update is available, if the system is already up to date, or if the installed version is newer than the published release, returning specific exit codes to authorize or skip installation.
_src/free\_claude\code/updater · high confidence
Support for local Anthropic web search and fetch tools
The application now supports executing Anthropic's \web\_search\ and \web\_fetch\ server tools locally. This change introduces a new \web\_tools\ module that recognizes specific Anthropic tool definitions, validates domain filters (allowed/blocked), and translates automatic search requests into a hidden internal tool format for execution. Users can now leverage web search capabilities directly through the local provider without requiring external API calls for these specific tool types, provided the \ENABLE\_WEB\_SERVER\_TOOLS\ setting is enabled.
_src/free\_claude\_code/application/web\tools · high confidence
Removals
Removal of legacy provider base classes and NVIDIA NIM implementation
The \providers\ package has removed the \BaseProvider\ abstract class, the \ProviderConfig\ data model, and the \NvidiaNimProvider\ implementation. This deletion eliminates the previous extensibility pattern for custom providers and removes the specific integration for NVIDIA NIM, indicating a shift in how provider interfaces and specific vendor integrations are managed in the codebase.
providers · high confidence
Removed legacy provider utility modules
Deleted the \providers/utils\ package, including \\_\init\\_.py\, \heuristic\_tool\_parser.py\, \message\_converter.py\, \rate\_limiter.py\, and \sse\_builder.py\. This removes the local implementations for the sliding window rate limiter, the heuristic tool parser, the Anthropic-to-OpenAI message converter, and the SSE event builder, indicating these capabilities have been moved or replaced elsewhere in the codebase.
providers/utils · high confidence
Behavioural changes
3 commits (1 fix) modifying src/free\_claude\_code
A change to existing behaviour in src/free\_claude\_code — 3 commits (1 fix), 12 files: “patch: fix web\_fetch RuntimeError when Content-Type has no charset (\#2344)”; “patch: Fall back during long upstream cooldowns (\#2359)”; “patch: Resolve empty streamed tool arguments to the start input (\#2360)” (refs \#2344, \#2359, \#2360). Also in this area: Introduce native folder picker and secure web tools for Code sessions.
_src/free\_claude\_code/runtime/web\tools · medium confidence · unverified
7 commits (0 fixes) modifying src/free\_claude\_code/core/gemini
A change to existing behaviour in src/free\_claude\_code/core/gemini — 7 commits, 9 files: “patch: Align Gemini thinking with shared FCC effort budgets (\#2299)”; “patch: Buffer complete tool calls before protocol translation (\#2362)”; “patch: Use client-native history for readable thinking (\#2274)”; and 4 more (refs \#2299, \#2362, \#2274, \#2270, \#2177, …).
_src/free\_claude\code/core/gemini · medium confidence · unverified
9 commits (0 fixes) modifying src/free\_claude\_code/providers/openai\_api
A change to existing behaviour in src/free\_claude\_code/providers/openai\_api — 9 commits, 2 files: “patch: isolate provider recovery by model (\#2176)”; “minor: continue interrupted responses across fallback models (\#1994)”; “patch: Buffer complete tool calls before protocol translation (\#2362)”; and 6 more (refs \#2176, \#1994, \#2362, \#1883, \#2270, …).
_src/free\_claude\_code/providers/openai\api · medium confidence · unverified
Introduce managed configuration schema with automatic legacy migration
The application now uses a centralized, validated settings model (Pydantic) loaded from a single managed configuration file at \~/.fcc/.env, replacing the previous scattered environment variable approach. On startup, the system automatically detects legacy .env files (from the repository root or XDG config paths) and migrates their values into the new managed schema, handling key renames (such as HF\_TOKEN to HUGGINGFACE\_API\_KEY) and format changes (such as boolean reasoning flags to structured policies). This ensures that existing user configurations are preserved and upgraded seamlessly without manual intervention, while also introducing support for custom provider definitions and stricter validation of model references and proxy settings.
_src/free\_claude\code/config · high confidence
Introduces a unified provider execution and admission framework
The provider subsystem has been restructured to use a centralized admission controller and execution lifecycle. This change introduces a new \ProviderExecution\ model that owns the attempt budget, retry logic, and state transitions for all provider calls, replacing previous ad-hoc handling. It also adds a new \CredentialValidation\ module that performs non-generating API key checks for a wide range of providers (including OpenRouter, Groq, DeepSeek, and others) during configuration application, ensuring keys are valid before inference begins. Additionally, new provider adapters for Cloudflare Workers AI and DeepSeek are added, along with a dedicated transport for native Anthropic Messages, establishing a more consistent and robust foundation for adding and managing external AI providers. Also in this area: 1 commit (0 fixes) modifying e2e, free-claude-code, src/free\_claude\_code; 3 commits (1 fix) modifying src/free\_claude\_code.
_src/free\_claude\code/providers/gemini · medium confidence · unverified
New atomic messaging tree architecture with transactional persistence
The messaging subsystem has been refactored to use a new tree-based model where conversations are managed as atomic aggregates. This change introduces a \TreeQueueManager\ that coordinates message processing using durable transactions, ensuring that message admission, cancellation, and removal are committed or rolled back as a single unit. The new architecture includes a \MessageTreeGraph\ for in-memory parent-child link management, a \TreeRepository\ for indexing trees by scope and reference, and a \TreeTransaction\ layer that handles storage commits and rollbacks. This provides stronger consistency guarantees for messaging operations, particularly during shutdown or failure scenarios, by preventing partial state updates.
_src/free\_claude\code/messaging/trees · high confidence
Project license changed to AGPL-3.0-only and initial repository structure established
The project license has been switched to the GNU Affero General Public License v3.0 (AGPL-3.0-only), requiring that source code be made available to users of networked deployments. This change accompanies the initial commit that established the repository's foundational structure, including the addition of a \CONTRIBUTING.md\ guide for developers, a \LICENSE\ file, and \.gitattributes\ for line-ending and linguist configuration. As part of this initial setup, legacy configuration files such as \.env.example\ and \nvidia\_nim\_models.json\ were removed, and the project now targets Python 3.14 with a \conftest.py\ registering shared pytest plugins.
(repo-wide) · high confidence
Fixes
Fix macOS app menu-bar launch identity
The macOS desktop application now correctly identifies itself as the Free Claude Code bundle when launched from Finder, ensuring the process executable and bundle ID match the installed app rather than a legacy shell wrapper. This change introduces a native Objective-C launcher that initializes the Python runtime directly, replacing the previous shell-based launch method to provide a consistent and verifiable application identity.
scripts/macos, smoke/desktop · high confidence
Test coverage
46 commits adding/updating tests in tests/core; Add contract tests for provider catalog, admin manifest, and smoke infrastructure; Added API test suite for model fallback, admin configuration, and authentication; Added CLI launcher and session management tests; Added application-layer tests for code sessions, execution, and routing; Added comprehensive test coverage for messaging subsystem; Added runtime tests for Codex integration, code sessions, and configuration management; Added test coverage for Anthropic protocol core components; Added test coverage for integration harnesses; Added test infrastructure and harness support for Code Sessions and provider integrations; Added tests for CI sharding, release validation, and workflow configuration; Added tests for OpenAI Responses protocol translation and streaming; Added tests for managed configuration, provider catalog, and logging behavior; Expanded provider test coverage with new test infrastructure and provider-specific suites; Installer smoke test suite for release pinning, isolation, and lifecycle validation; Introduce local-only live smoke test suite; New end-to-end browser tests for the Admin UI and Code Sessions; New live smoke test suite for API, authentication, and provider prerequisites; New product-level end-to-end smoke test suite.
Dependencies
Major dependency upgrade and project restructuring
The project has been renamed to 'free-claude-code' and upgraded to require Python 3.14.7. Key dependency updates include FastAPI to \>=0.141.1, the OpenAI SDK to \>=3.18.0, httpx to \>=0.28.1, and pydantic to \>=2.13.5. New dependencies added include tiktoken for token counting, discord.py for Discord support, and various libraries for voice and desktop integration. The build system now uses hatchling with VCS-based versioning, and development tooling has been updated to include ruff, ty, and pytest-xdist.
(dependencies) · 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 44 → 45 (+1.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 31 → 30 (-1.0)
- Architecture 81 → 90 (+9.3)
- Maturity 65 → 69 (+3.6)
- Readiness 40 → 40 (-0.0)
- Security 79 → 77 (-2.1)
- Accessibility 61 → 70 (+9.1)
- Performance 100 → 100 (+0.0)
Resolved (43)
- Duplicated block (11–15 lines × 2) (smoke/lib/config.py)
- Duplicated block (13 lines × 2) (smoke/lib/config.py)
- Duplicated block (15–16 lines × 2) (src/free_claude_code/providers/anthropic_messages/transport.py)
- Duplicated block (17 lines × 2) (smoke/lib/claude_cli_matrix.py)
- Duplicated block (17 lines × 2) (src/free_claude_code/providers/openai_chat/transport.py)
- Duplicated block (18–20 lines × 2) (src/free_claude_code/application/execution.py)
- Duplicated block (21 lines × 2) (src/free_claude_code/messaging/platforms/discord_inbound.py)
- Duplicated block (9 lines × 2) (src/free_claude_code/harnesses/claude_desktop_integration.py)
- Hotspot: src/free_claude_code/api/tool_call_buffer.py (src/free_claude_code/api/tool_call_buffer.py)
- Hotspot: src/free_claude_code/application/routing.py (src/free_claude_code/application/routing.py)
- Hotspot: src/free_claude_code/config/settings.py (src/free_claude_code/config/settings.py)
- Hotspot: src/free_claude_code/providers/openai_chat/tool_calls.py (src/free_claude_code/providers/openai_chat/tool_calls.py)
- Inconsistent naming for health/check endpoints. While probe_health is standard, the others use probe_<domain> (messages, responses, count_tokens). This mixes a generic health check pattern with specific domain checks. It is unclear if these are all equivalent 'ping' endpoints or if they serve different diagnostic purposes. Given the symmetry, they likely all serve the same 'is this specific subsystem alive' purpose, but the naming convention is inconsistent with standard REST/HTTP practices (usually just /health or /ready).
- Leaked secret: hardcoded-credential (smoke/lib/config.py)
- No ADRs found
- OpenAIToolCallAssembler._process_resolved_tool_call (cognitive 37) (src/free_claude_code/providers/openai_chat/tool_calls.py)
- OpenAIToolCallAssembler._process_resolved_tool_call (cyclomatic 29) (src/free_claude_code/providers/openai_chat/tool_calls.py)
- OpenAIToolCallCollector.completed_calls (cognitive 17) (src/free_claude_code/providers/openai_chat/tool_calls.py)
- Projects may be oversized for their cohesion
- Publisher.publish (cognitive 34) (scripts/publish_release.py)
- …and 23 more
New (195)
- ChatMessagesStream.feed (cognitive 36) (src/free_claude_code/core/chat_completions/messages_stream.py)
- ChatMessagesStream.feed (cyclomatic 24) (src/free_claude_code/core/chat_completions/messages_stream.py)
- ChatRequest.validate_messages (cognitive 79) (src/free_claude_code/core/chat_completions/request.py)
- ChatRequest.validate_messages (cyclomatic 52) (src/free_claude_code/core/chat_completions/request.py)
- ChatResponseAccumulator.feed (cognitive 119) (src/free_claude_code/core/chat_completions/response.py)
- ChatResponseAccumulator.feed (cyclomatic 43) (src/free_claude_code/core/chat_completions/response.py)
- ChatResponsesStream._item (cognitive 23) (src/free_claude_code/core/chat_completions/responses_stream.py)
- ChatResponsesStream._item (cyclomatic 19) (src/free_claude_code/core/chat_completions/responses_stream.py)
- ChatResponsesStream.feed (cognitive 45) (src/free_claude_code/core/chat_completions/responses_stream.py)
- ChatResponsesStream.feed (cyclomatic 26) (src/free_claude_code/core/chat_completions/responses_stream.py)
- ChatToolCallBuffer._complete_native_group (cognitive 49) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ChatToolCallBuffer._complete_native_group (cyclomatic 21) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ChatToolCallBuffer._feed_native (cognitive 34) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ChatToolCallBuffer._feed_native (cyclomatic 18) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ChatToolCallBuffer.feed (cognitive 32) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ChatToolCallBuffer.feed (cyclomatic 23) (src/free_claude_code/core/chat_completions/tool_calls.py)
- ContinuationOverlap._check_terminal_order (cognitive 24) (src/free_claude_code/core/continuation_overlap.py)
- ContinuationOverlap._check_terminal_order (cyclomatic 16) (src/free_claude_code/core/continuation_overlap.py)
- ContinuationOverlap._render (cognitive 37) (src/free_claude_code/core/continuation_overlap.py)
- ContinuationOverlap._render (cyclomatic 18) (src/free_claude_code/core/continuation_overlap.py)
- …and 175 more
Changes since last survey
- 30 commits — 28 feature/other, 2 fixes
By area
- src/free_claude_code — 14 commits
- (root) — 9 commits
- tests/providers — 2 commits
- scripts/install.ps1 — 1 commit
- smoke/lib — 1 commit
- tests/api — 1 commit
- tests/cli — 1 commit
- tests/scripts — 1 commit
Notable commits
- fix: patch: Fix Muse model visibility and native client smoke failures (#2261)
- fix: patch: fix web_fetch RuntimeError when Content-Type has no charset (#2344)
- change: Clarify free provider token availability (#2241)
- change: Document installer as update fallback (#2244)
- change: Group README features (#2243)
- change: Simplify README features (#2242)
- change: Simplify the README (#2239)
- change: minor: Add Chat Completions ingress and native Gemini egress (#2285)
- change: minor: Add Gemini generation ingress across existing transports (#2177)
- change: minor: Add native Antigravity CLI integration (#2179)
- change: patch: Advertise Claude Fable 5.2 shortcut (#2314)
- change: patch: Align Gemini thinking with shared FCC effort budgets (#2299)
- change: patch: Buffer complete tool calls before protocol translation (#2362)
- change: patch: Bump uv to 0.13.7 and consolidate macOS runners (#2259)
- change: patch: Disable Copilot CLI auto-update during connection (#2226)
- change: patch: Enforce upstream read timeout across keepalive traffic (#2295)
- change: patch: Fall back during long upstream cooldowns (#2359)
- change: patch: Manage Antigravity CLI connections in Admin (#2181)
- change: patch: Preserve invalid-request errors from provider streams (#2258)
- change: patch: Preserve signed Gemini replay across recovered responses (#2297)
- …and 10 more
Architecture
- Unchanged — 0 containers · 1 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
Alishahryar1/free-claude-code 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 14 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 56621010ada15b633d76ab19178764bb3e81bcc5 — the exact code this score is about.
- Scored under rubric-2026.11.4 — 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.65+preprod-36d4cd83012f.