Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Retire GitHub Models and migrate selections to default (#1668)
Ali Khokharec6fda36f3e9
diff --git a/.env.example b/.env.exampleindex ac7562bf..14a08fde 100644--- a/.env.example+++ b/.env.example@@ -60,10 +60,6 @@ BEDROCK_BASE_URL="https://bedrock-mantle.us-east-1.api.aws/v1"# COHERE_API_KEY=<your-token>-# GitHub Models Config (OpenAI-compatible Chat Completions at models.github.ai/inference)-# GITHUB_MODELS_TOKEN=<your-token>--# Z.ai Config (one key for Coding Plan zai/... and pay-as-you-go zai_api/...)# The model prefix selects api.z.ai/api/coding/paas/v4 or api.z.ai/api/paas/v4.# ZAI_API_KEY=<your-token>@@ -196,7 +192,7 @@ OLLAMA_BASE_URL="http://localhost:11434"# Default model and optional Claude tier overrides# Format: provider_type/model/name-# Valid providers: "nvidia_nim" | "openai" | "azure_openai" | "open_router" | "gemini" | "vertex" | "deepseek" | "mistral" | "mistral_codestral" | "opencode_zen" | "opencode_go" | "vercel" | "bedrock" | "huggingface" | "cohere" | "github_models" | "wafer" | "kimi" | "kimi_code" | "minimax" | "cerebras" | "groq" | "cline_pass" | "xai" | "qwencloud" | "qwencloud_coding" | "together" | "deepinfra" | "siliconflow" | "nebius" | "chutes" | "featherless" | "agnes" | "zenmux" | "wandb" | "sambanova" | "kilo" | "fireworks" | "novita" | "cloudflare" | "zai" | "ollama_cloud" | "lmstudio" | "llamacpp" | "ollama" | "tokenrouter" | "nararoute" | "poolside" | "llm7"+# Valid providers: "nvidia_nim" | "openai" | "azure_openai" | "open_router" | "gemini" | "vertex" | "deepseek" | "mistral" | "mistral_codestral" | "opencode_zen" | "opencode_go" | "vercel" | "bedrock" | "huggingface" | "cohere" | "wafer" | "kimi" | "kimi_code" | "minimax" | "cerebras" | "groq" | "cline_pass" | "xai" | "qwencloud" | "qwencloud_coding" | "together" | "deepinfra" | "siliconflow" | "nebius" | "chutes" | "featherless" | "agnes" | "zenmux" | "wandb" | "sambanova" | "kilo" | "fireworks" | "novita" | "cloudflare" | "zai" | "ollama_cloud" | "lmstudio" | "llamacpp" | "ollama" | "tokenrouter" | "nararoute" | "poolside" | "llm7"# MODEL_FABLE=<provider/model-id># MODEL_OPUS=<provider/model-id># MODEL_SONNET=<provider/model-id>@@ -232,7 +228,6 @@ MODEL="nvidia_nim/nvidia/nemotron-3-super-120b-a12b"# FCC_SMOKE_MODEL_BEDROCK=<provider/model-id># FCC_SMOKE_MODEL_HUGGINGFACE=<provider/model-id># FCC_SMOKE_MODEL_COHERE=<provider/model-id>-# FCC_SMOKE_MODEL_GITHUB_MODELS=<provider/model-id># FCC_SMOKE_MODEL_ZAI=<provider/model-id># FCC_SMOKE_MODEL_ZAI_API=<provider/model-id># FCC_SMOKE_MODEL_TOKENROUTER=<your-token>@@ -309,7 +304,6 @@ REASONING_HAIKU=inherit# BEDROCK_PROXY=<http-or-socks-url># HUGGINGFACE_PROXY=<http-or-socks-url># COHERE_PROXY=<http-or-socks-url>-# GITHUB_MODELS_PROXY=<http-or-socks-url># ZAI_PROXY=<http-or-socks-url># ZAI_API_PROXY=<http-or-socks-url># TOKENROUTER_PROXY=<http-or-socks-url>diff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex 56c28f09..9ffb8b4d 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -300,6 +300,13 @@ Lifecycle behavior is covered by| [config/admin](src/free_claude_code/config/admin/) | Catalog-driven fields, presentation, validation and sparse persistence || [runtime/application.py](src/free_claude_code/runtime/application.py) | Credential checks, Apply publication/restart decisions and account operations |+Retired provider references are normalized per source before validation by+`config/model_refs.py`. Managed selections are cleared to inherit the default;+process overrides retain their ownership. Startup atomically repairs managed+config and current Chat model selections; Chat history retains its original model+facts. Stale direct request IDs route to the effective default, preserving encoded+reasoning intent. Unknown preserved config values are masked in Admin previews.+Live precedence is defaults, managed `~/.fcc/.env`, then process environment.The deliberate exception is a non-empty managed `ANTHROPIC_AUTH_TOKEN`, whichwins over an inherited token. Settings loading may perform the one-time legacydiff --git a/README.md b/README.mdindex 46de2efe..fb040a92 100644--- a/README.md+++ b/README.md@@ -25,7 +25,7 @@## What You Get-- **50 ToS-friendly providers. 1.3B+ free tokens every month.** Use free, paid, subscription, and local models from one searchable UI without putting your account at risk. FCC follows provider terms and removes integrations if they stop being allowed.+- **49 ToS-friendly providers. 1.3B+ free tokens every month.** Use free, paid, subscription, and local models from one searchable UI without putting your account at risk. FCC follows provider terms and removes integrations if they stop being allowed.- **10 coding agents. One model catalog.** Run [Claude Code](https://code.claude.com/docs/en/overview), [Codex](https://github.com/openai/codex), [Pi](https://github.com/earendil-works/pi), [OpenCode](https://github.com/anomalyco/opencode), [Cline](https://github.com/cline/cline), [Hermes](https://github.com/NousResearch/hermes-agent), [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness), [Grok Build](https://github.com/xai-org/grok-build), [Muse Code](https://research.meta.ai/blog/introducing-muse-code-and-muse-spark-1-2/), or [Aider](https://aider.chat/) with your FCC models.- **Keep coding through provider outages.** After retries are exhausted, FCC automatically tries your next configured model without making you restart the turn—across every client.- **Up to 90% fewer terminal-output tokens.** Optional [RTK](https://github.com/rtk-ai/rtk) filters common command output, while five FCC optimizations handle quota probes, command-prefix detection, titles, suggestions, and filepaths without calling a provider.@@ -185,6 +185,11 @@ from more than one provider before succeeding.<details><summary><strong>Provider catalog</strong></summary>+[GitHub Models retired on July 30, 2026](https://github.blog/changelog/2026-07-30-github-models-is-now-retired/). FCC automatically resets retired model+selections to your configured default, or the built-in default when `MODEL` itself+is retired. Configure that default provider in Admin if its credentials are missing.+GitHub Copilot is a separate service and is not a replacement provider in FCC.+| Provider | Admin UI setting | Example `MODEL` || --- | --- | --- || [NVIDIA NIM](https://build.nvidia.com/settings/api-keys) | `NVIDIA_NIM_API_KEY` | `nvidia_nim/nvidia/nemotron-3-super-120b-a12b` |@@ -216,7 +221,6 @@ from more than one provider before succeeding.| [Amazon Bedrock](https://console.aws.amazon.com/bedrock/) | `AWS_BEARER_TOKEN_BEDROCK` | `bedrock/openai.gpt-oss-120b` || [Hugging Face Inference Providers](https://huggingface.co/settings/tokens) | `HUGGINGFACE_API_KEY` | `huggingface/Qwen/Qwen3-Coder-480B-A35B-Instruct:fastest` || [Cohere](https://dashboard.cohere.com/api-keys) | `COHERE_API_KEY` | `cohere/command-a-plus-05-2026` |-| [GitHub Models](https://github.com/marketplace?type=models) | `GITHUB_MODELS_TOKEN` | `github_models/openai/gpt-4.1` || [Wafer](https://wafer.ai/) | `WAFER_API_KEY` | `wafer/DeepSeek-V4-Pro` || [Kimi API](https://platform.moonshot.ai/console/api-keys) | `KIMI_API_KEY` | `kimi/kimi-k2.5` || [Kimi Code](https://www.kimi.com/code/console) | `KIMI_CODE_API_KEY` | `kimi_code/k3` |diff --git a/e2e/test_admin_providers.py b/e2e/test_admin_providers.pyindex 16aff0a1..3b1705e4 100644--- a/e2e/test_admin_providers.py+++ b/e2e/test_admin_providers.py@@ -4,6 +4,25 @@ import pytestfrom playwright.sync_api import ConsoleMessage, Page, ViewportSize, expect+ "admin_base_url", [{"MODEL": "github_models/openai/old"}], indirect=True+)+def test_retired_provider_is_absent_and_default_setup_remains_available(+ page: Page, admin_base_url: str+):+ _open_admin(page, admin_base_url, {"width": 1280, "height": 720})+ expect(page.locator('[data-provider="github_models"]')).to_have_count(0)+ expect(page.locator("#field-GITHUB_MODELS_TOKEN")).to_have_count(0)+ card = page.locator('[data-provider="nvidia_nim"]')+ expect(card.locator(".status-pill")).to_have_text("Missing key")+ card.get_by_role("button", name="Configure", exact=True).click()+ expect(page.locator("#field-NVIDIA_NIM_API_KEY")).to_be_focused()+ page.get_by_role("button", name="Model Config", exact=True).click()+ expect(page.locator("#field-MODEL")).to_have_value(+ "nvidia_nim/nvidia/nemotron-3-super-120b-a12b"+ )++def _open_admin(page: Page,admin_base_url: str,diff --git a/e2e/test_chat_sessions.py b/e2e/test_chat_sessions.pyindex db610585..89c9db2b 100644--- a/e2e/test_chat_sessions.py+++ b/e2e/test_chat_sessions.py@@ -35,6 +35,25 @@ def _hold_next_chat_operation(page: Page, action: str) -> None:)+def test_stale_chat_selection_reloads_as_default(page: Page, admin_base_url: str):+ session = page.request.post(+ f"{admin_base_url}/admin/api/chat/sessions", data={}+ ).json()+ response = page.request.patch(+ f"{admin_base_url}/admin/api/chat/sessions/{session['id']}",+ data={+ "expected_revision": session["revision"],+ "model": "github_models/openai/old",+ },+ )+ assert response.ok+ page.goto(f"{admin_base_url}/admin/chat/{session['id']}")+ expect(page.get_by_role("combobox", name="Selected model")).to_have_value(+ "open_router/e2e-default"+ )+ expect(page.get_by_role("textbox", name="Message", exact=True)).to_be_visible()++def _select_model(page: Page, model_ref: str) -> None:model = page.get_by_role("combobox", name="Selected model")model.click()diff --git a/pyproject.toml b/pyproject.tomlindex b4caf609..5f72706d 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.20.0"+version = "5.21.0"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/smoke/lib/config.py b/smoke/lib/config.pyindex 1cf6ccf5..8d35f5dd 100644--- a/smoke/lib/config.py+++ b/smoke/lib/config.py@@ -68,7 +68,6 @@ PROVIDER_SMOKE_DEFAULT_MODELS: dict[str, str] = {"bedrock": "bedrock/openai.gpt-oss-120b","huggingface": "huggingface/openai/gpt-oss-120b:fastest","cohere": "cohere/command-a-plus-05-2026",- "github_models": "github_models/openai/gpt-4.1","zai": "zai/glm-5.2","zai_api": "zai_api/glm-4.7-flash","gemini": "gemini/models/gemini-3.1-flash-lite",diff --git a/src/free_claude_code/application/chat/ports.py b/src/free_claude_code/application/chat/ports.pyindex b5777732..fe132aaa 100644--- a/src/free_claude_code/application/chat/ports.py+++ b/src/free_claude_code/application/chat/ports.py@@ -31,6 +31,14 @@ class ChatStorePort(Protocol):async def close(self) -> None: ...+ async def repair_retired_model_selections(+ self,+ *,+ retired_provider_ids: frozenset[str],+ default_model: str,+ disable_reasoning: bool,+ ) -> int: ...+async def load_preferences(self) -> ChatPreferences: ...async def save_system_prompt(self, system_prompt: str) -> ChatPreferences: ...diff --git a/src/free_claude_code/application/chat/service.py b/src/free_claude_code/application/chat/service.pyindex 82a3b04e..fe52031a 100644--- a/src/free_claude_code/application/chat/service.py+++ b/src/free_claude_code/application/chat/service.py@@ -13,6 +13,10 @@ from loguru import loggerfrom free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.ports import RequestRuntimeLease, RequestRuntimePortfrom free_claude_code.application.routing import ProviderModelTarget+from free_claude_code.config.model_refs import (+ RETIRED_PROVIDER_IDS,+ is_retired_model_ref,+)from free_claude_code.core.anthropic import (ContentBlockText,MessagesResponse,@@ -124,12 +128,61 @@ class ChatService:async def start(self) -> None:if self._started:- return+ if self._accepting:+ return+ # A prior startup cleanup failed. Release its store before retrying.+ retry_cleanup = asyncio.create_task(self._close_startup_store())+ cancellation = await _wait_task_despite_cancellation(retry_cleanup)+ try:+ retry_cleanup.result()+ except Exception as exc:+ if cancellation is not None:+ raise cancellation from exc+ raise+ if cancellation is not None:+ raise cancellation+ cancellation: asyncio.CancelledError | None = Nonetry:await self._store.start()- except asyncio.CancelledError:- raise- except Exception as exc:+ self._started = True+ default_model = self._runtime.current_settings().model+ option = self._context.model(default_model)+ repair_task = asyncio.create_task(+ self._store.repair_retired_model_selections(+ retired_provider_ids=RETIRED_PROVIDER_IDS,+ default_model=default_model,+ disable_reasoning=option.supports_reasoning is False,+ ),+ name="fcc-chat-retirement-repair",+ )+ cancellation = await _wait_task_despite_cancellation(repair_task)+ repaired = repair_task.result()+ if cancellation is not None:+ raise cancellation+ if repaired:+ logger.info(+ "Repaired retired model selections in {} Chat sessions", repaired+ )+ except BaseException as exc:+ if self._started:+ try:+ cleanup_task = asyncio.create_task(+ self._close_startup_store(), name="fcc-chat-start-cleanup"+ )+ cleanup_cancellation = await _wait_task_despite_cancellation(+ cleanup_task+ )+ cancellation = cancellation or cleanup_cancellation+ cleanup_task.result()+ except Exception as cleanup_exc:+ logger.warning(+ "Chat startup cleanup failed: exc_type={}",+ type(cleanup_exc).__name__,+ )+ if not isinstance(exc, Exception):+ raise+ if cancellation is not None:+ raise cancellation from excself._unavailable_message = (str(exc)if isinstance(exc, ChatUnavailableError)@@ -144,6 +197,10 @@ class ChatService:self._accepting = Trueself._unavailable_message = None+ async def _close_startup_store(self) -> None:+ await self._store.close()+ self._started = False+async def close(self) -> None:self._accepting = Falseasync with self._active_lock:@@ -289,7 +346,12 @@ class ChatService:if len(title) > 200:raise ChatValidationError("Chat title cannot exceed 200 characters.")if model is not None:- self._context.model(model)+ retired = is_retired_model_ref(model)+ if retired:+ model = self._runtime.current_settings().model+ option = self._context.model(model)+ if retired and option.supports_reasoning is False:+ reasoning = ChatReasoning.OFFasync with self._active_lock:if session_id in self._deleting:raise ChatConflictError("This chat is being deleted.")diff --git a/src/free_claude_code/application/routing.py b/src/free_claude_code/application/routing.pyindex 86b57f2c..7ca3ed46 100644--- a/src/free_claude_code/application/routing.py+++ b/src/free_claude_code/application/routing.py@@ -5,7 +5,11 @@ from dataclasses import dataclassfrom loguru import loggerfrom free_claude_code.application.errors import UnknownProviderError-from free_claude_code.config.model_refs import parse_model_name, parse_provider_type+from free_claude_code.config.model_refs import (+ is_retired_model_ref,+ parse_model_name,+ parse_provider_type,+)from free_claude_code.config.provider_catalog import (PROVIDER_CATALOG,SUPPORTED_PROVIDER_IDS,@@ -147,6 +151,17 @@ class ModelRouter:self, model_name: str) -> tuple[str | None, str | None, bool]:decoded = decode_gateway_model_id(model_name)+ candidate = (+ f"{decoded.provider_id}/{decoded.provider_model}"+ if decoded is not None+ else model_name+ )+ if is_retired_model_ref(candidate):+ return (+ parse_provider_type(self._settings.model),+ parse_model_name(self._settings.model),+ decoded.force_reasoning_off if decoded is not None else False,+ )if decoded is not None:if decoded.provider_id not in SUPPORTED_PROVIDER_IDS:return None, None, Falsediff --git a/src/free_claude_code/config/admin/persistence.py b/src/free_claude_code/config/admin/persistence.pyindex 12d2d0d7..8d4d1aee 100644--- a/src/free_claude_code/config/admin/persistence.py+++ b/src/free_claude_code/config/admin/persistence.py@@ -14,6 +14,7 @@ from free_claude_code.config.env_migrations import (recognized_env_keys,render_managed_config,)+from free_claude_code.config.model_refs import normalize_retired_model_settingsfrom free_claude_code.config.paths import managed_env_pathfrom free_claude_code.config.provider_proxies import invalid_provider_proxy_keysfrom free_claude_code.config.settings import Settings@@ -103,7 +104,7 @@ def target_values_with_updates(values[key] = valuevalues[FCC_CONFIG_SCHEMA_ENV] = CONFIG_SCHEMA_VERSION- return values+ return normalize_retired_model_settings(values, preserve_empty_overrides=False)def changed_pending_fields(diff --git a/src/free_claude_code/config/admin/provider_manifest.py b/src/free_claude_code/config/admin/provider_manifest.pyindex d0f584cb..0befa6d5 100644--- a/src/free_claude_code/config/admin/provider_manifest.py+++ b/src/free_claude_code/config/admin/provider_manifest.py@@ -89,13 +89,6 @@ _PROVIDER_FIELD_OVERRIDES: dict[str, ProviderFieldOverride] = {"label": "Cohere API Key","description": "Cohere API key for the OpenAI-compatible Compatibility API.",},- "GITHUB_MODELS_TOKEN": {- "label": "GitHub Models Token",- "description": (- "GitHub token with Models access for the OpenAI-compatible inference API "- "at models.github.ai."- ),- },"ZAI_API_KEY": {"label": "Z.ai API Key","description": (diff --git a/src/free_claude_code/config/constants.py b/src/free_claude_code/config/constants.pyindex c4ea854a..d96a1617 100644--- a/src/free_claude_code/config/constants.py+++ b/src/free_claude_code/config/constants.py@@ -1,5 +1,7 @@"""Shared defaults used by config models and provider adapters."""+DEFAULT_MODEL = "nvidia_nim/nvidia/nemotron-3-super-120b-a12b"+# HTTP client connect timeout (seconds). Keep aligned with README.md and .env.example.HTTP_CONNECT_TIMEOUT_DEFAULT = 10.0diff --git a/src/free_claude_code/config/env_migrations.py b/src/free_claude_code/config/env_migrations.pyindex d9c84f63..896094cd 100644--- a/src/free_claude_code/config/env_migrations.py+++ b/src/free_claude_code/config/env_migrations.py@@ -6,6 +6,8 @@ from collections.abc import Mappingfrom dataclasses import dataclassfrom pathlib import Path+from loguru import logger+from .env_files import (ANTHROPIC_AUTH_TOKEN_ENV,FCC_CONFIG_SCHEMA_ENV,@@ -15,6 +17,7 @@ from .env_files import (legacy_explicit_env_path,verified_checkout_env_path,)+from .model_refs import normalize_retired_model_settingsfrom .paths import legacy_env_paths, managed_env_pathfrom .provider_catalog import PROVIDER_CATALOGfrom .settings import Settings@@ -190,7 +193,14 @@ def consolidate_managed_config(if base_is_managed:schema = base_values.get(FCC_CONFIG_SCHEMA_ENV)if schema == CONFIG_SCHEMA_VERSION:- return ConfigMigrationResult(changed=False)+ normalized = normalize_retired_model_settings(+ base_values, preserve_empty_overrides=False+ )+ if normalized == base_values:+ return ConfigMigrationResult(changed=False)+ atomic_write_managed_config(normalized, path=managed)+ _log_model_repairs(base_values, normalized)+ return ConfigMigrationResult(changed=True)if schema not in {None, ""}:raise ValueError(f"Managed config {managed} uses unsupported schema {schema!r}; "@@ -224,11 +234,23 @@ def consolidate_managed_config(if key in known and key != FCC_CONFIG_SCHEMA_ENV and not values[key].strip():values.pop(key)values[FCC_CONFIG_SCHEMA_ENV] = CONFIG_SCHEMA_VERSION-- atomic_write_managed_config(values, path=managed)+ normalized = normalize_retired_model_settings(+ values, preserve_empty_overrides=False+ )+ atomic_write_managed_config(normalized, path=managed)+ _log_model_repairs(values, normalized)return ConfigMigrationResult(changed=True, imported_from=tuple(imported))+def _log_model_repairs(before: Mapping[str, str], after: Mapping[str, str]) -> None:+ changed = sorted(key for key in before if before[key] != after.get(key))+ if changed:+ logger.info(+ "Repaired retired provider selections in managed config: {}",+ ", ".join(changed),+ )++def atomic_write_managed_config(values: Mapping[str, str],*,@@ -292,7 +314,8 @@ def render_managed_config(if unknown:lines.extend(("", "# Preserved unrecognized settings"))lines.extend(- f"{key}={quote_env_value(canonical[key])}" for key in sorted(unknown)+ f"{key}={quote_env_value('********' if mask_secrets else canonical[key])}"+ for key in sorted(unknown))return "\n".join(lines) + "\n"diff --git a/src/free_claude_code/config/loader.py b/src/free_claude_code/config/loader.pyindex 05d0e683..569bee6f 100644--- a/src/free_claude_code/config/loader.py+++ b/src/free_claude_code/config/loader.py@@ -15,6 +15,7 @@ from .env_migrations import (consolidate_managed_config,settings_env_keys,)+from .model_refs import normalize_retired_model_settingsfrom .paths import config_lock_path, managed_env_pathfrom .provider_proxies import invalid_provider_proxy_keysfrom .settings import Settings@@ -97,7 +98,10 @@ def compose_settings_snapshot() -> SettingsSnapshot:"""Validate prospective managed values with live process precedence."""- process = env if env is not None else os.environ+ process = normalize_retired_model_settings(+ env if env is not None else os.environ, preserve_empty_overrides=True+ )+ managed = normalize_retired_model_settings(managed, preserve_empty_overrides=False)aliases = _settings_aliases()recognized = settings_env_keys()values: dict[str, str] = {diff --git a/src/free_claude_code/config/model_refs.py b/src/free_claude_code/config/model_refs.pyindex fb4487b0..2491caa2 100644--- a/src/free_claude_code/config/model_refs.py+++ b/src/free_claude_code/config/model_refs.py@@ -1,8 +1,55 @@"""Provider-prefixed model reference helpers."""+from collections.abc import Mappingfrom dataclasses import dataclassfrom typing import Protocol+from .constants import DEFAULT_MODEL++RETIRED_PROVIDER_IDS = frozenset({"github_models"})+++def is_retired_model_ref(model_ref: str) -> bool:+ """Recognize complete references owned by a retired provider."""++ provider, separator, model = model_ref.strip().partition("/")+ return provider in RETIRED_PROVIDER_IDS and bool(separator and model.strip())+++def parse_model_fallbacks(value: object) -> object:+ if value is None:+ return None+ if isinstance(value, str):+ if not value.strip():+ return None+ return tuple(part.strip() for part in value.split(","))+ if isinstance(value, list | tuple) and not value:+ return None+ return value+++def normalize_retired_model_settings(+ values: Mapping[str, str], *, preserve_empty_overrides: bool+) -> dict[str, str]:+ """Repair one source without changing its precedence or unrelated validation."""++ normalized = dict(values)+ for key in ("MODEL", "MODEL_FABLE", "MODEL_OPUS", "MODEL_SONNET", "MODEL_HAIKU"):+ if is_retired_model_ref(normalized.get(key, "")):+ if preserve_empty_overrides:+ normalized[key] = DEFAULT_MODEL if key == "MODEL" else ""+ else:+ normalized.pop(key)+ fallbacks = parse_model_fallbacks(normalized.get("MODEL_FALLBACKS"))+ if isinstance(fallbacks, tuple) and all(fallbacks):+ retained = tuple(ref for ref in fallbacks if not is_retired_model_ref(ref))+ if retained != fallbacks:+ if retained or preserve_empty_overrides:+ normalized["MODEL_FALLBACKS"] = ",".join(retained)+ else:+ normalized.pop("MODEL_FALLBACKS")+ return normalized+@dataclass(frozen=True, slots=True)class ConfiguredChatModelRef:diff --git a/src/free_claude_code/config/provider_catalog.py b/src/free_claude_code/config/provider_catalog.pyindex 8fb63945..a63d8bf3 100644--- a/src/free_claude_code/config/provider_catalog.py+++ b/src/free_claude_code/config/provider_catalog.py@@ -37,7 +37,6 @@ VERCEL_AI_GATEWAY_DEFAULT_BASE = "https://ai-gateway.vercel.sh/v1"BEDROCK_DEFAULT_BASE = "https://bedrock-mantle.us-east-1.api.aws/v1"HUGGINGFACE_DEFAULT_BASE = "https://router.huggingface.co/v1"COHERE_DEFAULT_BASE = "https://api.cohere.ai/compatibility/v1"-GITHUB_MODELS_DEFAULT_BASE = "https://models.github.ai/inference"# Z.ai OpenAI-compatible Chat Completions APIs. The endpoint selects billing.ZAI_CODING_DEFAULT_BASE = "https://api.z.ai/api/coding/paas/v4"ZAI_API_DEFAULT_BASE = "https://api.z.ai/api/paas/v4"@@ -390,15 +389,6 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {default_base_url=COHERE_DEFAULT_BASE,proxy_attr="cohere_proxy",),- "github_models": ProviderDescriptor(- provider_id="github_models",- display_name="GitHub Models",- credential_env="GITHUB_MODELS_TOKEN",- credential_url="https://github.com/settings/tokens",- credential_attr="github_models_token",- default_base_url=GITHUB_MODELS_DEFAULT_BASE,- proxy_attr="github_models_proxy",- ),"wafer": ProviderDescriptor(provider_id="wafer",display_name="Wafer",@@ -589,7 +579,7 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {# Key order:# NVIDIA NIM, OpenRouter, and Groq lead the customer-facing ranking;# OpenCode gateways remain adjacent,-# Vercel / Hugging Face / Cohere / GitHub Models follow gateway-style remotes,+# Vercel / Hugging Face / Cohere follow gateway-style remotes,# then cloud gateways, Ollama Cloud, and local providers per project plan# (github.com/cheahjs/free-llm-api-resources Free Providers TOC as rough guide# beyond fixed slots).diff --git a/src/free_claude_code/config/settings.py b/src/free_claude_code/config/settings.pyindex ff4b7d14..18e5f5e5 100644--- a/src/free_claude_code/config/settings.py+++ b/src/free_claude_code/config/settings.py@@ -12,7 +12,8 @@ from pydantic import (model_validator,)-from .constants import HTTP_CONNECT_TIMEOUT_DEFAULT+from .constants import DEFAULT_MODEL, HTTP_CONNECT_TIMEOUT_DEFAULT+from .model_refs import parse_model_fallbacksfrom .nim import NimSettingsfrom .provider_catalog import (BEDROCK_DEFAULT_BASE,@@ -29,18 +30,6 @@ def _empty_to_none(value: object) -> object:return value-def _parse_model_fallbacks(value: object) -> object:- if value is None:- return None- if isinstance(value, str):- if not value.strip():- return None- return tuple(part.strip() for part in value.split(","))- if isinstance(value, list | tuple) and not value:- return None- return value--NonEmptyString = Annotated[str,StringConstraints(strip_whitespace=True, min_length=1),@@ -51,7 +40,7 @@ OptionalNonEmptyString = Annotated[]OptionalModelFallbacks = Annotated[tuple[NonEmptyString, ...] | None,- BeforeValidator(_parse_model_fallbacks),+ BeforeValidator(parse_model_fallbacks),]@@ -158,11 +147,6 @@ class Settings(BaseModel):default=None, validation_alias="COHERE_API_KEY")- # ==================== GitHub Models ====================- github_models_token: OptionalNonEmptyString = Field(- default=None, validation_alias="GITHUB_MODELS_TOKEN"- )-# ==================== SambaNova Cloud ====================sambanova_api_key: OptionalNonEmptyString = Field(default=None, validation_alias="SAMBANOVA_API_KEY"@@ -357,7 +341,7 @@ class Settings(BaseModel):# All Claude model requests are mapped to this single model (fallback)# Format: provider_type/model/namemodel: NonEmptyString = Field(- default="nvidia_nim/nvidia/nemotron-3-super-120b-a12b",+ default=DEFAULT_MODEL,validation_alias="MODEL",)@@ -471,9 +455,6 @@ class Settings(BaseModel):cohere_proxy: OptionalNonEmptyString = Field(default=None, validation_alias="COHERE_PROXY")- github_models_proxy: OptionalNonEmptyString = Field(- default=None, validation_alias="GITHUB_MODELS_PROXY"- )sambanova_proxy: OptionalNonEmptyString = Field(default=None, validation_alias="SAMBANOVA_PROXY")diff --git a/src/free_claude_code/providers/credential_validation.py b/src/free_claude_code/providers/credential_validation.pyindex 5dc892c0..3cf64eab 100644--- a/src/free_claude_code/providers/credential_validation.py+++ b/src/free_claude_code/providers/credential_validation.py@@ -155,7 +155,6 @@ _PROBES = (_Probe("deepinfra", "https://api.deepinfra.com/v1/me", _identity("uid")),_Probe("mistral", "/models", _MODELS),_Probe("wandb", "/models", _MODELS),- _Probe("github_models", "https://api.github.com/user", _identity("login")),_Probe("minimax", "/models", _MODELS),_Probe("novita",@@ -260,8 +259,6 @@ async def _check_one(settings: Settings, key: str, probe: _Probe) -> CredentialCheaders["x-goog-api-key"] = credentialelse:headers["Authorization"] = f"Bearer {credential}"- if probe.provider_id == "github_models":- headers["Accept"] = "application/vnd.github+json"if probe.provider_id == "novita":headers["Content-Type"] = "application/json"try:diff --git a/src/free_claude_code/providers/github_models/__init__.py b/src/free_claude_code/providers/github_models/__init__.pydeleted file mode 100644index d86c4d6f..00000000--- a/src/free_claude_code/providers/github_models/__init__.py+++ /dev/null@@ -1,5 +0,0 @@-"""GitHub Models provider."""--from .client import GitHubModelsProvider--__all__ = ["GitHubModelsProvider"]diff --git a/src/free_claude_code/providers/github_models/client.py b/src/free_claude_code/providers/github_models/client.pydeleted file mode 100644index 639d3fd9..00000000--- a/src/free_claude_code/providers/github_models/client.py+++ /dev/null@@ -1,155 +0,0 @@-"""GitHub Models provider using OpenAI-compatible chat completions."""--from collections.abc import Mapping, Sequence-from typing import Any--import httpx--from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.providers.admission import (- ProviderAdmissionController,- ProviderOperationKind,-)-from free_claude_code.providers.base import ProviderConfig-from free_claude_code.providers.http import maybe_await_aclose-from free_claude_code.providers.model_listing import (- ModelListResponseError,- model_infos_from_ids,-)-from free_claude_code.providers.openai_chat import (- NO_REASONING,- OpenAIChatProfile,- OpenAIChatProvider,- OpenAIChatRequestPolicy,-)--GITHUB_MODELS_CATALOG_URL = "https://models.github.ai/catalog/models"-GITHUB_MODELS_API_VERSION = "2026-03-10"--_REQUEST_POLICY = OpenAIChatRequestPolicy(- provider_name="GITHUB_MODELS",- reasoning_replay=ReasoningReplayMode.THINK_TAGS,-)-_PROFILE = OpenAIChatProfile(_REQUEST_POLICY, NO_REASONING)-_REQUIRED_MODEL_CAPABILITIES = frozenset({"streaming", "tool-calling"})---class GitHubModelsProvider(OpenAIChatProvider):- """GitHub Models OpenAI-compatible inference provider."""-- def __init__(- self, config: ProviderConfig, *, admission: ProviderAdmissionController- ):- self._catalog_url = GITHUB_MODELS_CATALOG_URL- self._model_list_client = httpx.AsyncClient(- proxy=config.proxy,- timeout=httpx.Timeout(- config.http_read_timeout,- connect=config.http_connect_timeout,- read=config.http_read_timeout,- write=config.http_write_timeout,- ),- )- super().__init__(- config,- profile=_PROFILE,- admission=admission,- default_headers=_github_models_default_headers(),- )-- async def cleanup(self) -> None:- """Release provider client resources."""- await super().cleanup()- await self._model_list_client.aclose()-- async def list_model_infos(self) -> frozenset[ProviderModelInfo]:- """Return stream/tool-capable GitHub Models catalog ids."""-- async def request() -> httpx.Response:- response = await self._model_list_client.get(- self._catalog_url,- headers=self._model_list_headers(),- )- try:- response.raise_for_status()- except Exception:- await maybe_await_aclose(response)- raise- return response-- execution = self._admission.start_execution()- response = await execution.run_call(- request,- operation_kind=ProviderOperationKind.MODEL_DISCOVERY,- )- try:- try:- payload = response.json()- except ValueError as exc:- raise ModelListResponseError(- "GITHUB_MODELS model-list response is malformed: invalid JSON"- ) from exc- return model_infos_from_ids(- _extract_supported_github_model_ids(payload),- )- finally:- await maybe_await_aclose(response)-- def _model_list_headers(self) -> dict[str, str]:- if self._api_key is None:- raise AssertionError("GitHub Models requires a static API key")- return _github_models_api_headers(self._api_key)---def _github_models_default_headers() -> dict[str, str]:- return {- "Accept": "application/vnd.github+json",- "X-GitHub-Api-Version": GITHUB_MODELS_API_VERSION,- }---def _github_models_api_headers(api_key: str) -> dict[str, str]:- return {- **_github_models_default_headers(),- "Authorization": f"Bearer {api_key}",- }---def _extract_supported_github_model_ids(payload: Any) -> frozenset[str]:- """Extract stream/tool-capable model ids from GitHub's catalog array."""- if not _is_sequence(payload):- raise ModelListResponseError(- "GITHUB_MODELS model-list response is malformed: expected top-level array"- )-- model_ids: set[str] = set()- for item in payload:- if not isinstance(item, Mapping):- raise ModelListResponseError(- "GITHUB_MODELS model-list response is malformed: expected every item to be an object"- )- model_id = item.get("id")- if not isinstance(model_id, str) or not model_id.strip():- raise ModelListResponseError(- "GITHUB_MODELS model-list response is malformed: expected every item to include id"- )- capabilities = item.get("capabilities")- if not _supports_streaming_tools(capabilities):- continue- model_ids.add(model_id)-- return frozenset(model_ids)---def _supports_streaming_tools(capabilities: Any) -> bool:- if not _is_sequence(capabilities):- return False- capability_names = {item for item in capabilities if isinstance(item, str)}- return capability_names >= _REQUIRED_MODEL_CAPABILITIES---def _is_sequence(value: Any) -> bool:- return isinstance(value, Sequence) and not isinstance(- value, str | bytes | bytearray- )diff --git a/src/free_claude_code/providers/runtime/factory.py b/src/free_claude_code/providers/runtime/factory.pyindex 1434ae3b..079854f1 100644--- a/src/free_claude_code/providers/runtime/factory.py+++ b/src/free_claude_code/providers/runtime/factory.py@@ -125,16 +125,6 @@ def _create_vertex()-def _create_github_models(- config: ProviderConfig,- _settings: Settings,- admission: ProviderAdmissionController,-) -> BaseProvider:- from free_claude_code.providers.github_models import GitHubModelsProvider-- return GitHubModelsProvider(config, admission=admission)--def _create_groq(config: ProviderConfig,_settings: Settings,@@ -175,7 +165,6 @@ _SPECIAL_PROVIDER_FACTORIES: dict[str, ProviderFactory] = {"cloudflare": _create_cloudflare,"gemini": _create_gemini,"vertex": _create_vertex,- "github_models": _create_github_models,"groq": _create_groq,"opencode_zen": _create_opencode_zen,"opencode_go": _create_opencode_go,diff --git a/src/free_claude_code/runtime/chat_sqlite.py b/src/free_claude_code/runtime/chat_sqlite.pyindex 630da8fd..43174e4e 100644--- a/src/free_claude_code/runtime/chat_sqlite.py+++ b/src/free_claude_code/runtime/chat_sqlite.py@@ -89,6 +89,61 @@ class SQLiteChatStore:async def load_preferences(self) -> ChatPreferences:return await self._run(self._load_preferences)+ async def repair_retired_model_selections(+ self,+ *,+ retired_provider_ids: frozenset[str],+ default_model: str,+ disable_reasoning: bool,+ ) -> int:+ """Repair current selections atomically, preserving historical model facts."""++ def operation(connection: sqlite3.Connection) -> int:+ connection.execute("BEGIN IMMEDIATE")+ repaired = 0+ now = _now_ms()+ for provider_id in sorted(retired_provider_ids):+ prefix = f"{provider_id}/"+ cursor = connection.execute(+ """+ UPDATE chat_sessions+ SET model = ?, reasoning = CASE WHEN ? THEN 'off' ELSE reasoning END,+ revision = revision + 1, updated_at = ?+ WHERE substr(model, 1, ?) = ? AND length(trim(substr(model, ?))) > 0+ """,+ (+ default_model,+ disable_reasoning,+ now,+ len(prefix),+ prefix,+ len(prefix) + 1,+ ),+ )+ repaired += cursor.rowcount+ connection.execute(+ """+ UPDATE chat_settings+ SET last_model = ?,+ last_reasoning = CASE WHEN ? THEN 'off' ELSE last_reasoning END,+ updated_at = ?+ WHERE substr(last_model, 1, ?) = ?+ AND length(trim(substr(last_model, ?))) > 0+ """,+ (+ default_model,+ disable_reasoning,+ now,+ len(prefix),+ prefix,+ len(prefix) + 1,+ ),+ )+ connection.commit()+ return repaired++ return await self._run(operation)+async def save_system_prompt(self, system_prompt: str) -> ChatPreferences:def operation(connection: sqlite3.Connection) -> ChatPreferences:now = _now_ms()diff --git a/tests/api/test_admin.py b/tests/api/test_admin.pyindex 3a2629ef..047cca6d 100644--- a/tests/api/test_admin.py+++ b/tests/api/test_admin.py@@ -31,6 +31,45 @@ def _local_client(app):)+def test_admin_retirement_preview_apply_and_runtime_agree(monkeypatch, tmp_path):+ _set_home(monkeypatch, tmp_path)+ _clear_process_config(monkeypatch)+ env_file = tmp_path / ".fcc" / ".env"+ env_file.parent.mkdir(parents=True)+ env_file.write_text(+ "FCC_CONFIG_SCHEMA=1\nMODEL=groq/default\nMODEL_OPUS=groq/managed\n"+ "GITHUB_MODELS_TOKEN=preserve-secret\nGITHUB_MODELS_PROXY=http://user:[email protected]\nPRIVATE=hidden\n",+ encoding="utf-8",+ )+ monkeypatch.setenv("MODEL_OPUS", "github_models/retired-process")+ app = create_test_app()+ client = _local_client(app)+ body = client.post(+ "/admin/api/config/apply",+ json={+ "values": {+ "MODEL_SONNET": "github_models/stale",+ "MODEL_OPUS": "deepseek/cannot-unlock",+ "MODEL_FALLBACKS": "groq/a,github_models/old,deepseek/b",+ }+ },+ ).json()+ assert body["applied"]+ text = env_file.read_text(encoding="utf-8")+ assert "MODEL=groq/default" in text+ assert "MODEL_SONNET" not in text+ assert "MODEL_OPUS=groq/managed" in text+ assert "MODEL_FALLBACKS=groq/a,deepseek/b" in text+ assert "preserve-secret" in text and "http://user:[email protected]" in text+ assert "preserve-secret" not in body["env_preview"]+ assert "http://user:[email protected]" not in body["env_preview"]+ assert "PRIVATE=********" in body["env_preview"]+ effective = provider_manager_for_app(app).current_settings()+ assert effective.model == "groq/default"+ assert effective.model_opus is None and effective.model_sonnet is None+ assert effective.model_fallbacks == ("groq/a", "deepseek/b")++@pytest.fixture(autouse=True)def _offline_credential_checks(monkeypatch):"""These tests exercise config persistence; probe HTTP has its own suite."""@@ -523,7 +562,7 @@ def test_admin_config_masks_secrets_and_exposes_manifest(monkeypatch, tmp_path):assert "FIREWORKS_API_KEY" in keysassert "CLOUDFLARE_API_TOKEN" in keysassert "CLOUDFLARE_ACCOUNT_ID" in keys- assert "GITHUB_MODELS_TOKEN" in keys+ assert "GITHUB_MODELS_TOKEN" not in keysassert "GEMINI_API_KEY" in keysassert "GROQ_API_KEY" in keysassert "SAMBANOVA_API_KEY" in keys@@ -1496,7 +1535,7 @@ def test_admin_apply_writes_cohere_key_and_masks_preview(monkeypatch, tmp_path):assert "COHERE_API_KEY=cohere-secret" in text-def test_admin_apply_writes_github_models_token_and_masks_preview(+def test_admin_apply_replaces_retired_model_and_ignores_retired_credential(monkeypatch, tmp_path):_set_home(monkeypatch, tmp_path)@@ -1516,11 +1555,11 @@ def test_admin_apply_writes_github_models_token_and_masks_preview(assert response.status_code == 200body = response.json()assert body["applied"] is True- assert "GITHUB_MODELS_TOKEN=********" in body["env_preview"]+ assert "GITHUB_MODELS_TOKEN" not in body["env_preview"]env_file = tmp_path / ".fcc" / ".env"text = env_file.read_text(encoding="utf-8")- assert "MODEL=github_models/openai/gpt-4.1" in text- assert "GITHUB_MODELS_TOKEN=github-secret" in text+ assert "MODEL=" not in text+ assert "GITHUB_MODELS_TOKEN" not in textdef test_admin_apply_preserves_hidden_diagnostics_and_smoke_values(diff --git a/tests/api/test_api.py b/tests/api/test_api.pyindex eeb295aa..8dce6fa6 100644--- a/tests/api/test_api.py+++ b/tests/api/test_api.py@@ -3,6 +3,7 @@ from unittest.mock import MagicMock, patchimport pytestfrom fastapi.testclient import TestClient+from free_claude_code.config.constants import DEFAULT_MODELfrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.reasoning import ReasoningPolicy@@ -16,6 +17,30 @@ from free_claude_code.providers.openai_chat import (from tests.api.support import create_test_appfrom tests.providers.support import immediate_admission, make_provider_config+[email protected]("stream", [False, True])[email protected]("prefix", ["", "anthropic/", "claude-3-freecc-no-thinking/"])+def test_retired_model_ingress_calls_default_provider(client, stream, prefix):+ original = f"{prefix}github_models/vendor/opus"+ _stream_messages_calls.clear()+ response = client.post(+ "/v1/messages",+ json={+ "model": original,+ "max_tokens": 32,+ "messages": [{"role": "user", "content": "hello"}],+ "stream": stream,+ },+ )+ assert response.status_code == 200+ assert len(_stream_messages_calls) == 1+ args, kwargs = _stream_messages_calls[0]+ assert args[0].model == DEFAULT_MODEL.split("/", 1)[1]+ assert kwargs["response_model"] == original+ if prefix == "claude-3-freecc-no-thinking/":+ assert kwargs["reasoning"] == ReasoningPolicy.off()++app = create_test_app()# Mock providerdiff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 717b682d..e1811824 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -6,6 +6,7 @@ import pytestfrom fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.config.constants import DEFAULT_MODELfrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.failures import ExecutionFailure, FailureKind@@ -88,6 +89,19 @@ def test_responses_probe_endpoints_return_204(assert client.options("/v1/responses").status_code == 204[email protected]("prefix", ["", "anthropic/", "claude-3-freecc-no-thinking/"])+def test_retired_response_id_uses_default_provider(responses_client, prefix):+ client, provider = responses_client+ original = f"{prefix}github_models/vendor/opus"+ response = client.post("/v1/responses", json={"model": original, "input": "hello"})+ assert response.status_code == 200+ assert "response.completed" in response.text+ assert provider.requests[0].model == DEFAULT_MODEL.split("/", 1)[1]+ assert provider.stream_kwargs[0]["response_model"] == original+ if prefix == "claude-3-freecc-no-thinking/":+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()++def test_create_response_stream_routes_native_request_through_provider(responses_client: tuple[TestClient, FakeProvider],) -> None:diff --git a/tests/api/test_routes_optimizations.py b/tests/api/test_routes_optimizations.pyindex 84ec12e3..b77127fb 100644--- a/tests/api/test_routes_optimizations.py+++ b/tests/api/test_routes_optimizations.py@@ -135,6 +135,33 @@ def test_count_tokens_endpoint(client):assert response.json()["input_tokens"] == 5[email protected]("prefix", ["", "anthropic/", "claude-3-freecc-no-thinking/"])+def test_count_tokens_retired_model_uses_configured_default(prefix):+ test_app = create_test_app(+ Settings(MODEL="groq/default", MODEL_OPUS="deepseek/opus")+ )+ with (+ patch("free_claude_code.api.routes.get_token_count", return_value=5),+ patch("free_claude_code.api.handlers.token_count.trace_event") as trace,+ ):+ response = TestClient(test_app).post(+ "/v1/messages/count_tokens",+ json={+ "model": f"{prefix}github_models/vendor/opus",+ "messages": [{"role": "user", "content": "hi"}],+ },+ )+ assert response.status_code == 200+ assert response.json()["input_tokens"] == 5+ routed = next(+ call.kwargs+ for call in trace.call_args_list+ if call.kwargs["stage"] == "routing"+ )+ assert routed["provider_model_ref"] == "groq/default"+ assert routed["gateway_model"] == f"{prefix}github_models/vendor/opus"++def test_count_tokens_error_returns_500(client):"""When get_token_count raises, count_tokens returns 500."""payload = {diff --git a/tests/application/test_chat_service.py b/tests/application/test_chat_service.pyindex 0235d2b3..b37a3ce6 100644--- a/tests/application/test_chat_service.py+++ b/tests/application/test_chat_service.py@@ -1,5 +1,6 @@import asyncioimport sqlite3+import threadingfrom collections.abc import AsyncIterator, Awaitable, Callablefrom dataclasses import dataclassfrom pathlib import Path@@ -12,6 +13,7 @@ from free_claude_code.application.chat import (ChatNotFoundError,ChatOperationAcknowledgement,ChatOperationKind,+ ChatReasoning,ChatService,ChatSession,ChatUnavailableError,@@ -23,11 +25,175 @@ from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.interprocess_lock import InterprocessFileLockfrom free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.runtime.chat_sqlite import SQLiteChatStore[email protected]("repair_fails", [False, True])+async def test_cancelled_startup_drains_retirement_worker_before_releasing_lock(+ tmp_path, monkeypatch, repair_fails+):+ store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")+ await store.start()+ original_run = store._run_sync+ entered = threading.Event()+ release = threading.Event()+ finished = threading.Event()++ def blocked_run(operation):+ entered.set()+ assert release.wait(5)+ try:+ if repair_fails:+ raise OSError("injected repair failure after cancellation")+ return original_run(operation)+ finally:+ finished.set()++ monkeypatch.setattr(store, "_run_sync", blocked_run)+ service = ChatService(FakeRuntime(FakeChatProvider()), store)+ task = asyncio.create_task(service.start())+ replacement_lock = InterprocessFileLock(tmp_path / "chat.lock")+ try:+ assert await asyncio.to_thread(entered.wait, 2)+ task.cancel()+ await asyncio.sleep(0.05)+ assert not task.done()+ assert not finished.is_set()+ assert not replacement_lock.acquire()+ release.set()+ with pytest.raises(asyncio.CancelledError):+ await task+ assert finished.is_set()+ assert replacement_lock.acquire()+ finally:+ release.set()+ await asyncio.gather(task, return_exceptions=True)+ replacement_lock.release()+ await service.close()++[email protected]("supports_thinking", [True, False, None])+async def test_retired_chat_selection_startup_and_stale_patch(+ tmp_path, monkeypatch, supports_thinking+):+ runtime = FakeRuntime(FakeChatProvider())+ monkeypatch.setattr(+ runtime,+ "cached_model_info",+ lambda provider_id, model_id: ProviderModelInfo(+ model_id, supports_thinking=supports_thinking+ ),+ )+ store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")+ await store.start()+ old = await store.create_session(+ session_id="aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaaaa",+ model="github_models/old",+ reasoning=ChatReasoning.HIGH,+ )+ await store.close()+ service = ChatService(runtime, store)+ await service.start()+ try:+ assert service.availability() == (True, None)+ repaired = await service.get_session(old.id)+ assert repaired.model == runtime.settings.model+ assert repaired.revision == old.revision + 1+ expected_reasoning = (+ ChatReasoning.OFF if supports_thinking is False else ChatReasoning.HIGH+ )+ assert repaired.reasoning is expected_reasoning+ with pytest.raises(ChatConflictError):+ await service.update_session(+ old.id,+ expected_revision=old.revision,+ title=None,+ model="github_models/old",+ reasoning=None,+ )+ assert await service.get_session(old.id) == repaired+ # Simulate a stale tab submitting an old selection while thinking is enabled.+ enabled = await store.update_session(+ old.id,+ expected_revision=repaired.revision,+ title=None,+ model=None,+ reasoning=ChatReasoning.HIGH,+ )+ patched = await service.update_session(+ old.id,+ expected_revision=enabled.revision,+ title=None,+ model="github_models/old",+ reasoning=None,+ )+ assert patched.model == runtime.settings.model+ assert patched.reasoning is expected_reasoning+ assert runtime.leases == []+ finally:+ await service.close()++[email protected]("cancel", [True, False])+async def test_chat_retirement_failure_releases_store_lock(+ tmp_path, monkeypatch, cancel+):+ store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")+ service = ChatService(FakeRuntime(FakeChatProvider()), store)++ async def fail_repair(**kwargs):+ if cancel:+ raise asyncio.CancelledError()+ raise OSError("injected repair failure")++ monkeypatch.setattr(store, "repair_retired_model_selections", fail_repair)+ if cancel:+ with pytest.raises(asyncio.CancelledError):+ await service.start()+ else:+ await service.start()+ assert not service.availability()[0]+ replacement = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")+ await replacement.start()+ await replacement.close()+ await service.close()+++async def test_chat_retirement_failed_cleanup_is_retried_before_start(+ tmp_path, monkeypatch+):+ store = SQLiteChatStore(tmp_path / "chat.db", tmp_path / "chat.lock")+ service = ChatService(FakeRuntime(FakeChatProvider()), store)+ original_repair = store.repair_retired_model_selections+ original_close = store.close++ async def fail_repair(**kwargs):+ raise OSError("injected repair failure")++ async def fail_close():+ raise OSError("injected cleanup failure")++ monkeypatch.setattr(store, "repair_retired_model_selections", fail_repair)+ monkeypatch.setattr(store, "close", fail_close)+ await service.start()+ assert not service.availability()[0]+ monkeypatch.setattr(store, "repair_retired_model_selections", original_repair)+ monkeypatch.setattr(store, "close", original_close)+ await service.start()+ try:+ assert service.availability() == (True, None)+ await service.create_session()+ finally:+ await service.close()++class FakeChatProvider:def __init__(self,diff --git a/tests/application/test_routing.py b/tests/application/test_routing.pyindex 09b0049a..a1f5dc98 100644--- a/tests/application/test_routing.py+++ b/tests/application/test_routing.py@@ -16,6 +16,51 @@ from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort+ "prefix,off",+ [("", False), ("anthropic/", False), ("claude-3-freecc-no-thinking/", True)],+)+ "suffix", ["openai/gpt-4.1", "vendor/opus", "sonnet", "haiku", "fable"]+)+def test_retired_direct_ids_route_to_default_before_family_aliases(prefix, off, suffix):+ settings = Settings(+ MODEL="groq/default",+ MODEL_OPUS="deepseek/opus",+ MODEL_SONNET="deepseek/sonnet",+ MODEL_HAIKU="deepseek/haiku",+ MODEL_FABLE="deepseek/fable",+ MODEL_FALLBACKS="groq/default,groq/backup",+ REASONING_POLICY="high",+ REASONING_OPUS="off",+ )+ original = f"{prefix}github_models/{suffix}"+ router = ModelRouter(settings)+ route = router.resolve(original)+ assert route.original_model == original+ assert route.primary.provider_model_ref == "groq/default"+ assert [target.provider_model_ref for target in route.fallbacks] == ["groq/backup"]+ assert route.reasoning_preference is (+ ReasoningPreference.OFF if off else ReasoningPreference.HIGH+ )+ messages = router.resolve_messages_request(+ MessagesRequest(+ model=original,+ max_tokens=100,+ messages=[Message(role="user", content="hi")],+ )+ )+ responses = router.resolve_responses_request(+ OpenAIResponsesRequest(model=original, input="hi")+ )+ count = router.resolve_token_count_request(+ TokenCountRequest(model=original, messages=[Message(role="user", content="hi")])+ )+ for routed in (messages, responses, count):+ assert routed.request.model == "default"+ assert routed.resolved == route++@pytest.fixturedef settings():settings = Settings()diff --git a/tests/config/test_config.py b/tests/config/test_config.pyindex d12edcc6..196e630d 100644--- a/tests/config/test_config.py+++ b/tests/config/test_config.py@@ -11,6 +11,7 @@ from free_claude_code.application.routing import ModelRouterfrom free_claude_code.config import loaderfrom free_claude_code.config.constants import (ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,+ DEFAULT_MODEL,HTTP_CONNECT_TIMEOUT_DEFAULT,)from free_claude_code.config.env_files import dotenv_values_from_file@@ -36,6 +37,82 @@ from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.config.settings import Settings[email protected]("source", [ConfigSource.MANAGED, ConfigSource.PROCESS])[email protected]("tier", ["FABLE", "OPUS", "SONNET", "HAIKU"])+def test_retirement_normalizes_sources_without_resurrecting_overrides(source, tier):+ retired = {+ "MODEL": "github_models/openai/old",+ f"MODEL_{tier}": "github_models/vendor/opus",+ "MODEL_FALLBACKS": "github_models/old",+ f"REASONING_{tier}": "off",+ }+ managed = {+ "MODEL": "groq/managed",+ f"MODEL_{tier}": "groq/tier",+ "MODEL_FALLBACKS": "groq/backup",+ }+ snapshot = compose_settings_snapshot(+ retired if source is ConfigSource.MANAGED else managed,+ retired if source is ConfigSource.PROCESS else {},+ )+ assert snapshot.settings.model == DEFAULT_MODEL+ assert getattr(snapshot.settings, f"model_{tier.lower()}") is None+ assert (+ getattr(snapshot.settings, f"reasoning_{tier.lower()}")+ is ReasoningPreference.OFF+ )+ assert snapshot.settings.model_fallbacks is None+ expected = (+ ConfigSource.PROCESS if source is ConfigSource.PROCESS else ConfigSource.DEFAULT+ )+ assert snapshot.sources["model"] is expected+ assert snapshot.sources[f"model_{tier.lower()}"] is expected+ assert snapshot.sources["model_fallbacks"] is expected+ assert retired["MODEL"] == "github_models/openai/old"+++def test_retirement_preserves_effective_default_order_and_process_environment(+ monkeypatch,+):+ monkeypatch.delenv("MODEL", raising=False)+ monkeypatch.setenv("MODEL_OPUS", "github_models/opus")+ snapshot = compose_settings_snapshot(+ {+ "MODEL": "groq/default",+ "MODEL_OPUS": "groq/managed-tier",+ "MODEL_FALLBACKS": "groq/first, github_models/old, deepseek/last",+ }+ )+ assert snapshot.settings.model == "groq/default"+ assert snapshot.settings.model_opus is None+ assert snapshot.sources["model_opus"] is ConfigSource.PROCESS+ assert snapshot.settings.model_fallbacks == ("groq/first", "deepseek/last")+ assert loader.os.environ["MODEL_OPUS"] == "github_models/opus"+++ "values",+ [+ {"MODEL": "github_models/"},+ {"MODEL": "other/unknown"},+ {"MODEL_FALLBACKS": "github_models/old,groq/a,groq/a"},+ {"MODEL_FALLBACKS": "github_models/old,,groq/a"},+ {"MODEL_FALLBACKS": "github_models/old,"},+ {"MODEL_FALLBACKS": ",github_models/old"},+ {"MODEL_FALLBACKS": "github_models/old, "},+ {"MODEL_FALLBACKS": "github_models/old,github_models/"},+ ],+)+def test_retirement_does_not_hide_invalid_configuration(values):+ with pytest.raises(ValidationError):+ compose_settings_snapshot(values, {})+++def test_direct_settings_still_reject_retired_provider():+ with pytest.raises(ValidationError):+ Settings(MODEL="github_models/openai/old")++def test_settings_defaults_are_valid_and_nonempty() -> None:settings = Settings()diff --git a/tests/config/test_env_migrations.py b/tests/config/test_env_migrations.pyindex 630f7863..98c5bfc0 100644--- a/tests/config/test_env_migrations.py+++ b/tests/config/test_env_migrations.py@@ -18,6 +18,66 @@ from free_claude_code.config.env_migrations import (from free_claude_code.config.loader import resolve_settings_snapshot[email protected]("schema", ["", "FCC_CONFIG_SCHEMA=1\n"])+def test_retired_models_repair_managed_config_once_preserving_unknowns(+ monkeypatch, tmp_path, schema+):+ managed, _ = _paths(monkeypatch, tmp_path)+ managed.parent.mkdir(parents=True)+ managed.write_text(+ schema + "MODEL=github_models/old\nMODEL_OPUS=github_models/opus\n"+ "REASONING_OPUS=off\nMODEL_FALLBACKS=groq/a,github_models/old,deepseek/b\n"+ "GITHUB_MODELS_TOKEN=retired-secret\nGITHUB_MODELS_PROXY=http://user:[email protected]\n"+ "UNKNOWN_PRIVATE=unknown-secret\nCUSTOM=\n",+ encoding="utf-8",+ )+ assert consolidate_managed_config({}).changed+ values = dotenv_values_from_file(managed)+ assert "MODEL" not in values and "MODEL_OPUS" not in values+ assert values["MODEL_FALLBACKS"] == "groq/a,deepseek/b"+ assert values["REASONING_OPUS"] == "off"+ assert values["GITHUB_MODELS_TOKEN"] == "retired-secret"+ assert values["GITHUB_MODELS_PROXY"] == "http://user:[email protected]"+ assert values["CUSTOM"] == ""+ preview = env_migrations.render_managed_config(values, mask_secrets=True)+ for secret in ("retired-secret", "password", "unknown-secret"):+ assert secret not in preview+ assert "GITHUB_MODELS_TOKEN=********" in preview+ assert "UNKNOWN_PRIVATE=********" in preview+ before = managed.read_bytes(), managed.stat().st_mtime_ns+ assert not consolidate_managed_config({}).changed+ assert (managed.read_bytes(), managed.stat().st_mtime_ns) == before+++def test_retired_legacy_import_repairs_refs_without_importing_credentials(+ monkeypatch, tmp_path+):+ managed, legacy = _paths(monkeypatch, tmp_path)+ legacy.parent.mkdir(parents=True)+ original = "MODEL=github_models/old\nGITHUB_MODELS_TOKEN=old-secret\nGITHUB_MODELS_PROXY=http://[email protected]\n"+ legacy.write_text(original, encoding="utf-8")+ consolidate_managed_config({})+ values = dotenv_values_from_file(managed)+ assert not {"MODEL", "GITHUB_MODELS_TOKEN", "GITHUB_MODELS_PROXY"} & values.keys()+ assert legacy.read_text(encoding="utf-8") == original+++def test_retirement_atomic_write_failure_preserves_managed_file(monkeypatch, tmp_path):+ managed, _ = _paths(monkeypatch, tmp_path)+ managed.parent.mkdir(parents=True)+ original = b"FCC_CONFIG_SCHEMA=1\nMODEL=github_models/old\n"+ managed.write_bytes(original)++ def fail_replace(*args):+ raise OSError("injected replace failure")++ monkeypatch.setattr(env_migrations.os, "replace", fail_replace)+ with pytest.raises(OSError, match="injected"):+ consolidate_managed_config({})+ assert managed.read_bytes() == original+ assert list(managed.parent.glob("*.tmp")) == []++def _paths(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> tuple[Path, Path]:managed = tmp_path / ".fcc" / ".env"legacy = tmp_path / "legacy" / ".env"diff --git a/tests/contracts/test_feature_manifest.py b/tests/contracts/test_feature_manifest.pyindex cb948606..892323e3 100644--- a/tests/contracts/test_feature_manifest.py+++ b/tests/contracts/test_feature_manifest.py@@ -7,7 +7,6 @@ from free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.cloudflare import CloudflareProviderfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom free_claude_code.providers.gemini import GeminiProvider-from free_claude_code.providers.github_models import GitHubModelsProviderfrom free_claude_code.providers.groq import GroqProviderfrom free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.lmstudio import LMStudioProvider@@ -75,7 +74,6 @@ def test_provider_and_platform_registries_include_builtins() -> None:"kilo": KiloProvider,"cloudflare": CloudflareProvider,"lmstudio": LMStudioProvider,- "github_models": GitHubModelsProvider,"groq": GroqProvider,"gemini": GeminiProvider,"vertex": VertexProvider,diff --git a/tests/contracts/test_provider_catalog_order.py b/tests/contracts/test_provider_catalog_order.pyindex c419f241..5c6c29f5 100644--- a/tests/contracts/test_provider_catalog_order.py+++ b/tests/contracts/test_provider_catalog_order.py@@ -35,7 +35,6 @@ _EXPECTED_PROVIDER_ORDER: tuple[str, ...] = ("bedrock","huggingface","cohere",- "github_models","wafer","kimi","kimi_code",diff --git a/tests/contracts/test_smoke_config.py b/tests/contracts/test_smoke_config.pyindex c9d0f354..f3e6b203 100644--- a/tests/contracts/test_smoke_config.py+++ b/tests/contracts/test_smoke_config.py@@ -45,7 +45,6 @@ def _settings(**overrides):"bedrock_base_url": "https://bedrock-mantle.us-east-1.api.aws/v1","huggingface_api_key": "","cohere_api_key": "",- "github_models_token": "","zai_api_key": "","kilo_api_key": "","gemini_api_key": "",@@ -795,22 +794,6 @@ def test_cohere_provider_configuration_uses_api_key(monkeypatch) -> None:assert models[0].full_model == PROVIDER_SMOKE_DEFAULT_MODELS["cohere"]-def test_github_models_provider_configuration_uses_token(monkeypatch) -> None:- monkeypatch.delenv("FCC_SMOKE_MODEL_GITHUB_MODELS", raising=False)- config = _smoke_config(- settings=_settings(- model="ollama/llama3.1",- ollama_base_url="",- github_models_token="github-token",- )- )-- assert config.has_provider_configuration("github_models")- models = config.provider_smoke_models()- assert models[0].provider == "github_models"- assert models[0].full_model == PROVIDER_SMOKE_DEFAULT_MODELS["github_models"]--def test_sambanova_provider_configuration_uses_api_key(monkeypatch) -> None:monkeypatch.delenv("FCC_SMOKE_MODEL_SAMBANOVA", raising=False)config = _smoke_config(diff --git a/tests/providers/test_credential_validation.py b/tests/providers/test_credential_validation.pyindex 50c339cc..9392cc7c 100644--- a/tests/providers/test_credential_validation.py+++ b/tests/providers/test_credential_validation.py@@ -68,7 +68,6 @@ CASES = [),("mistral", "https://api.mistral.ai/v1/models", {"data": []}, None),("wandb", "https://api.inference.wandb.ai/v1/models", {"data": []}, None),- ("github_models", "https://api.github.com/user", {"login": "user"}, None),("minimax", "https://api.minimax.io/v1/models", {"data": []}, None),("novita",diff --git a/tests/providers/test_github_models.py b/tests/providers/test_github_models.pydeleted file mode 100644index d1777e39..00000000--- a/tests/providers/test_github_models.py+++ /dev/null@@ -1,323 +0,0 @@-"""Tests for GitHub Models OpenAI-compatible provider."""--from collections.abc import AsyncIterator-from dataclasses import replace-from types import SimpleNamespace-from unittest.mock import AsyncMock, patch--import httpx-import pytest--from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.config.provider_catalog import GITHUB_MODELS_DEFAULT_BASE-from free_claude_code.core.anthropic.models import Message, MessagesRequest-from free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.providers.base import ProviderConfig-from free_claude_code.providers.github_models import GitHubModelsProvider-from free_claude_code.providers.github_models.client import GITHUB_MODELS_CATALOG_URL-from free_claude_code.providers.model_listing import ModelListResponseError-from tests.providers.support import (- REASONING_ON,- immediate_admission,- make_provider_config,-)---def github_models_config() -> ProviderConfig:- return make_provider_config(- api_key="test-github-models-token",- base_url=GITHUB_MODELS_DEFAULT_BASE,- rate_limit=10,- rate_window=60,- )---def github_models_provider(- github_models_config: ProviderConfig,-) -> GitHubModelsProvider:- return GitHubModelsProvider(github_models_config, admission=immediate_admission())---def _request(model: str = "openai/gpt-4.1") -> MessagesRequest:- return MessagesRequest(- model=model,- max_tokens=100,- messages=[Message(role="user", content="hi")],- )---def _chunk(delta: SimpleNamespace, *, finish_reason: str = "stop") -> SimpleNamespace:- return SimpleNamespace(- choices=[SimpleNamespace(delta=delta, finish_reason=finish_reason)],- usage=SimpleNamespace(completion_tokens=5, prompt_tokens=8),- )---async def _stream(*chunks: SimpleNamespace) -> AsyncIterator[SimpleNamespace]:- for chunk in chunks:- yield chunk---def _catalog_response(payload: object) -> httpx.Response:- return httpx.Response(- 200,- json=payload,- request=httpx.Request("GET", GITHUB_MODELS_CATALOG_URL),- )---def test_default_base_url_constant() -> None:- assert GITHUB_MODELS_DEFAULT_BASE == "https://models.github.ai/inference"---def test_init_uses_default_base_url_api_key_and_github_headers(- github_models_config: ProviderConfig,-) -> None:- with patch(- "free_claude_code.providers.openai_chat.provider.AsyncOpenAI"- ) as mock_openai:- provider = GitHubModelsProvider(- github_models_config, admission=immediate_admission()- )-- assert provider._api_key == "test-github-models-token"- assert provider._base_url == GITHUB_MODELS_DEFAULT_BASE- assert provider._catalog_url == GITHUB_MODELS_CATALOG_URL- assert mock_openai.call_args.kwargs["base_url"] == GITHUB_MODELS_DEFAULT_BASE- assert mock_openai.call_args.kwargs["api_key"] == "test-github-models-token"- assert mock_openai.call_args.kwargs["default_headers"] == {- "Accept": "application/vnd.github+json",- "X-GitHub-Api-Version": "2026-03-10",- }---def test_init_strips_trailing_slash(github_models_config: ProviderConfig) -> None:- config = replace(- github_models_config,- base_url=f"{GITHUB_MODELS_DEFAULT_BASE}/",- )-- with patch("free_claude_code.providers.openai_chat.provider.AsyncOpenAI"):- provider = GitHubModelsProvider(config, admission=immediate_admission())-- assert provider._base_url == GITHUB_MODELS_DEFAULT_BASE---def test_model_list_headers_use_bearer_auth(- github_models_provider: GitHubModelsProvider,-) -> None:- assert github_models_provider._model_list_headers() == {- "Accept": "application/vnd.github+json",- "Authorization": "Bearer test-github-models-token",- "X-GitHub-Api-Version": "2026-03-10",- }---def test_build_request_body_uses_shared_openai_chat_policy(- github_models_provider: GitHubModelsProvider,-) -> None:- request = _request()-- body = github_models_provider._build_request_body(request, reasoning=REASONING_ON)-- assert body["model"] == "openai/gpt-4.1"- assert body["max_tokens"] == 100- assert "extra_body" not in body---async def test_lists_stream_tool_capable_models_only(- github_models_provider: GitHubModelsProvider,-) -> None:- with patch.object(- github_models_provider._model_list_client,- "get",- new_callable=AsyncMock,- return_value=_catalog_response(- [- {- "id": "openai/gpt-4.1",- "capabilities": ["streaming", "tool-calling"],- },- {- "id": "openai/text-only",- "capabilities": ["streaming"],- },- {- "id": "openai/no-stream-tools",- "capabilities": ["tool-calling"],- },- ]- ),- ) as mock_get:- assert await github_models_provider.list_model_infos() == frozenset(- {ProviderModelInfo("openai/gpt-4.1")}- )-- mock_get.assert_awaited_once_with(- GITHUB_MODELS_CATALOG_URL,- headers={- "Accept": "application/vnd.github+json",- "Authorization": "Bearer test-github-models-token",- "X-GitHub-Api-Version": "2026-03-10",- },- )---async def test_model_list_rejects_malformed_payload(- github_models_provider: GitHubModelsProvider,-) -> None:- with (- patch.object(- github_models_provider._model_list_client,- "get",- new_callable=AsyncMock,- return_value=_catalog_response({"data": []}),- ),- pytest.raises(ModelListResponseError, match="top-level array"),- ):- await github_models_provider.list_model_infos()---async def test_model_list_returns_empty_set_when_no_models_support_streaming_tools(- github_models_provider: GitHubModelsProvider,-) -> None:- with patch.object(- github_models_provider._model_list_client,- "get",- new_callable=AsyncMock,- return_value=_catalog_response(- [- {"id": "openai/text-only", "capabilities": ["streaming"]},- {"id": "openai/non-stream-tool", "capabilities": ["tool-calling"]},- ]- ),- ):- assert await github_models_provider.list_model_infos() == frozenset()---async def test_stream_messages_text(- github_models_provider: GitHubModelsProvider,-) -> None:- delta = SimpleNamespace(- content="Hello from GitHub Models",- reasoning_content=None,- tool_calls=None,- )-- with patch.object(- github_models_provider._client.chat.completions,- "create",- new_callable=AsyncMock,- return_value=_stream(_chunk(delta)),- ) as mock_create:- events = [- event async for event in github_models_provider.stream_messages(_request())- ]-- parsed = parse_sse_text("".join(events))- assert any(- event.event == "content_block_delta"- and event.data.get("delta", {}).get("text") == "Hello from GitHub Models"- for event in parsed- )- assert mock_create.call_args.kwargs["model"] == "openai/gpt-4.1"- assert mock_create.call_args.kwargs["stream"] is True---async def test_stream_messages_tool_call(- github_models_provider: GitHubModelsProvider,-) -> None:- tool_call = SimpleNamespace(- index=0,- id="call_1",- function=SimpleNamespace(name="echo", arguments='{"value":"x"}'),- )- delta = SimpleNamespace(- content=None, reasoning_content=None, tool_calls=[tool_call]- )- request = MessagesRequest.model_validate(- {- "model": "openai/gpt-4.1",- "messages": [{"role": "user", "content": "Use the tool"}],- "tools": [- {- "name": "echo",- "description": "Echo a value",- "input_schema": {- "type": "object",- "properties": {"value": {"type": "string"}},- "required": ["value"],- },- }- ],- }- )-- with patch.object(- github_models_provider._client.chat.completions,- "create",- new_callable=AsyncMock,- return_value=_stream(_chunk(delta, finish_reason="tool_calls")),- ):- events = [- event async for event in github_models_provider.stream_messages(request)- ]-- parsed = parse_sse_text("".join(events))- assert any(- event.event == "content_block_start"- and event.data.get("content_block", {}).get("type") == "tool_use"- and event.data.get("content_block", {}).get("name") == "echo"- for event in parsed- )- assert any(- event.event == "content_block_delta"- and event.data.get("delta", {}).get("partial_json") == '{"value":"x"}'- for event in parsed- )---async def test_stream_messages_reasoning_content(- github_models_provider: GitHubModelsProvider,-) -> None:- delta = SimpleNamespace(- content=None,- reasoning_content="Thinking via GitHub Models",- tool_calls=None,- )-- with patch.object(- github_models_provider._client.chat.completions,- "create",- new_callable=AsyncMock,- return_value=_stream(_chunk(delta)),- ):- events = [- event async for event in github_models_provider.stream_messages(_request())- ]-- parsed = parse_sse_text("".join(events))- assert any(- event.event == "content_block_delta"- and event.data.get("delta", {}).get("thinking") == "Thinking via GitHub Models"- for event in parsed- )---async def test_cleanup(github_models_provider: GitHubModelsProvider) -> None:- github_models_provider._client = AsyncMock()- github_models_provider._model_list_client = AsyncMock()-- await github_models_provider.cleanup()-- github_models_provider._client.close.assert_called_once()- github_models_provider._model_list_client.aclose.assert_called_once()diff --git a/tests/providers/test_provider_runtime.py b/tests/providers/test_provider_runtime.pyindex ae8f1068..be49694b 100644--- a/tests/providers/test_provider_runtime.py+++ b/tests/providers/test_provider_runtime.py@@ -18,7 +18,6 @@ from free_claude_code.config.provider_catalog import (COHERE_DEFAULT_BASE,DEEPINFRA_DEFAULT_BASE,FEATHERLESS_DEFAULT_BASE,- GITHUB_MODELS_DEFAULT_BASE,HUGGINGFACE_DEFAULT_BASE,KIMI_CODE_DEFAULT_BASE,LLM7_DEFAULT_BASE,@@ -45,7 +44,6 @@ from free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.cloudflare import CloudflareProviderfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom free_claude_code.providers.gemini import GeminiProvider-from free_claude_code.providers.github_models import GitHubModelsProviderfrom free_claude_code.providers.groq import GroqProviderfrom free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.lmstudio import LMStudioProvider@@ -97,7 +95,6 @@ def _make_settings(**overrides):mock.bedrock_base_url = BEDROCK_DEFAULT_BASEmock.huggingface_api_key = "test_huggingface_key"mock.cohere_api_key = "test_cohere_key"- mock.github_models_token = "test_github_models_token"mock.zai_api_key = "test_zai_key"mock.tokenrouter_api_key = "test_tokenrouter_key"mock.tokenrouter_base_url = TOKENROUTER_DEFAULT_BASE@@ -130,7 +127,6 @@ def _make_settings(**overrides):mock.bedrock_proxy = Nonemock.huggingface_proxy = Nonemock.cohere_proxy = None- mock.github_models_proxy = Nonemock.zai_proxy = Nonemock.zai_api_proxy = Nonemock.tokenrouter_proxy = None@@ -780,14 +776,6 @@ def test_cohere_descriptor_uses_openai_chat_compatibility_api() -> None:assert descriptor.proxy_attr == "cohere_proxy"-def test_github_models_descriptor_uses_openai_chat_inference_api() -> None:- descriptor = PROVIDER_CATALOG["github_models"]-- assert descriptor.default_base_url == GITHUB_MODELS_DEFAULT_BASE- assert descriptor.credential_env == "GITHUB_MODELS_TOKEN"- assert descriptor.proxy_attr == "github_models_proxy"--def test_build_provider_config_vercel_uses_gateway_key_and_proxy() -> None:descriptor = PROVIDER_CATALOG["vercel"]settings = _make_settings(@@ -827,19 +815,6 @@ def test_build_provider_config_cohere_uses_api_key_and_proxy() -> None:assert config.proxy == "http://proxy.test:8080"-def test_build_provider_config_github_models_uses_token_and_proxy() -> None:- descriptor = PROVIDER_CATALOG["github_models"]- settings = _make_settings(- github_models_token="github-token",- github_models_proxy="http://proxy.test:8080",- )-- config = build_provider_config(descriptor, settings)-- assert config.api_key == "github-token"- assert config.proxy == "http://proxy.test:8080"--def test_create_provider_uses_openai_chat_openrouter_by_default():with patch("free_claude_code.providers.openai_chat.provider.AsyncOpenAI"):provider = create_provider("open_router", _make_settings())@@ -862,7 +837,6 @@ def test_create_provider_instantiates_each_builtin():bedrock_api_key="test_bedrock_key",huggingface_api_key="test_huggingface_key",cohere_api_key="test_cohere_key",- github_models_token="test_github_models_token",kimi_api_key="test_kimi_key",kimi_code_api_key="test_kimi_code_key",provider_rate_limit=7,@@ -907,7 +881,6 @@ def test_create_provider_instantiates_each_builtin():"bedrock": OpenAIChatProvider,"huggingface": OpenAIChatProvider,"cohere": OpenAIChatProvider,- "github_models": GitHubModelsProvider,"zai": OpenAIChatProvider,"zai_api": OpenAIChatProvider,"tokenrouter": OpenAIChatProvider,diff --git a/tests/runtime/test_chat_sqlite.py b/tests/runtime/test_chat_sqlite.pyindex e49c589a..67132c08 100644--- a/tests/runtime/test_chat_sqlite.py+++ b/tests/runtime/test_chat_sqlite.py@@ -19,6 +19,154 @@ from free_claude_code.application.chat import (from free_claude_code.runtime.chat_sqlite import SQLiteChatStore[email protected]("disable_reasoning", [True, False])[email protected]("healthy_preference", [True, False])+async def test_retirement_repairs_current_selections_only(+ tmp_path, disable_reasoning, healthy_preference+):+ store = _store(tmp_path)+ await store.start()+ try:+ retired = await store.create_session(+ session_id=_id(),+ model="github_models/vendor/old",+ reasoning=ChatReasoning.HIGH,+ )+ generation_id = _id()+ await store.begin_send(+ retired.id,+ expected_revision=retired.revision,+ turn_id=_id(),+ generation_id=generation_id,+ operation_id=_id(),+ user_text="Keep history",+ requested_model=retired.model,+ reasoning=retired.reasoning,+ effective_output_limit=100,+ )+ await store.set_generation_actual_model(generation_id, retired.model)+ await store.finish_generation(+ generation_id,+ status=GenerationStatus.COMPLETED,+ stop_reason="end_turn",+ error_code=None,+ error_message=None,+ )+ await store.upsert_compaction(+ retired.id,+ covered_through_sequence=1,+ summary="Keep summary",+ estimated_tokens=5,+ requested_model=retired.model,+ actual_model=retired.model,+ )+ before = await store.get_transcript(retired.id)+ untouched = [+ await store.create_session(+ session_id=_id(), model=model, reasoning=ChatReasoning.MEDIUM+ )+ for model in ("githubXmodels/old", "github_models/", "groq/healthy")+ ]+ if not healthy_preference:+ temporary = await store.create_session(+ session_id=_id(), model=retired.model, reasoning=ChatReasoning.HIGH+ )+ await store.delete_session(+ temporary.id, expected_revision=temporary.revision+ )+ preferences = await store.load_preferences()+ assert (+ await store.repair_retired_model_selections(+ retired_provider_ids=frozenset({"github_models"}),+ default_model="groq/default",+ disable_reasoning=disable_reasoning,+ )+ == 1+ )+ after = await store.get_transcript(retired.id)+ assert after.session.model == "groq/default"+ assert after.session.revision == before.session.revision + 1+ assert after.session.reasoning is (+ ChatReasoning.OFF if disable_reasoning else ChatReasoning.HIGH+ )+ assert after.session.title == before.session.title+ assert after.turns == before.turns+ assert after.compaction == before.compaction+ for session in untouched:+ assert await store.get_session(session.id) == session+ updated_preferences = await store.load_preferences()+ if healthy_preference:+ assert updated_preferences == preferences+ else:+ assert updated_preferences.last_model == "groq/default"+ assert updated_preferences.last_reasoning is (+ ChatReasoning.OFF if disable_reasoning else ChatReasoning.HIGH+ )+ assert (+ await store.repair_retired_model_selections(+ retired_provider_ids=frozenset({"github_models"}),+ default_model="groq/default",+ disable_reasoning=disable_reasoning,+ )+ == 0+ )+ assert await store.get_transcript(retired.id) == after+ assert await store.load_preferences() == updated_preferences+ finally:+ await store.close()+++async def test_retirement_repairs_global_preference_without_sessions(tmp_path):+ store = _store(tmp_path)+ await store.start()+ try:+ session = await store.create_session(+ session_id=_id(), model="github_models/old", reasoning=ChatReasoning.HIGH+ )+ await store.delete_session(session.id, expected_revision=session.revision)+ assert (+ await store.repair_retired_model_selections(+ retired_provider_ids=frozenset({"github_models"}),+ default_model="groq/default",+ disable_reasoning=True,+ )+ == 0+ )+ preferences = await store.load_preferences()+ assert preferences.last_model == "groq/default"+ assert preferences.last_reasoning is ChatReasoning.OFF+ finally:+ await store.close()+++async def test_retirement_rolls_back_sessions_when_preference_update_fails(tmp_path):+ store = _store(tmp_path)+ await store.start()+ try:+ session = await store.create_session(+ session_id=_id(), model="github_models/old", reasoning=ChatReasoning.HIGH+ )+ before = await store.load_preferences()+ with closing(sqlite3.connect(tmp_path / "chat.db")) as connection:+ connection.execute(+ "CREATE TRIGGER fail_preference BEFORE UPDATE ON chat_settings BEGIN SELECT RAISE(ABORT, 'injected'); END"+ )+ connection.commit()+ with pytest.raises(ChatUnavailableError):+ await store.repair_retired_model_selections(+ retired_provider_ids=frozenset({"github_models"}),+ default_model="groq/default",+ disable_reasoning=True,+ )+ assert await store.get_session(session.id) == session+ assert await store.load_preferences() == before+ finally:+ await store.close()++def _id() -> str:return str(uuid.uuid4())diff --git a/uv.lock b/uv.lockindex 73ad1cb7..3758cfa3 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.20.0"+version = "5.21.0"source = { editable = "." }dependencies = [{ name = "aiohttp" },