free-claude-code 6.4.2__tar.gz → 6.4.4__tar.gz

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: free-claude-code
-Version: 6.4.2
+Version: 6.4.4
 Summary: Local proxy connecting coding agents to OpenAI-compatible AI providers
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/e2e/conftest.py

@@ -56,9 +56,6 @@ class _ModelListingProvider(BaseProvider):
             ProviderConfig(
                 api_key="browser-test",
                 base_url="https://provider.invalid/v1",
-                rate_limit=1_000,
-                rate_window=1,
-                max_concurrency=100,
                 http_read_timeout=1.0,
                 http_write_timeout=1.0,
                 http_connect_timeout=1.0,
@@ -252,15 +249,20 @@ def admin_base_url(
         ),
     }
 
-    async def fixture_provider(provider_id: str, _settings: Settings) -> BaseProvider:
+    async def fixture_provider(
+        provider_id: str, _settings: Settings, _admission_registry
+    ) -> BaseProvider:
         if provider_id not in providers:
             raise AssertionError(f"Missing browser fixture provider: {provider_id}")
         return providers[provider_id]
 
     manager = ProviderRuntimeManager(
         get_settings(),
-        runtime_factory=lambda snapshot: ProviderRuntime(
-            snapshot, dict(providers), provider_constructor=fixture_provider
+        runtime_factory=lambda snapshot, admission_registry: ProviderRuntime(
+            snapshot,
+            admission_registry,
+            dict(providers),
+            provider_constructor=fixture_provider,
         ),
     )
     runtime = ApplicationRuntime(

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/scripts/install.ps1

@@ -1006,7 +1006,7 @@ function Install-Hermes {
     Invoke-DownloadedPowerShellInstaller `
         -Url $HermesInstallUrl `
         -Name "Hermes Agent" `
-        -ScriptArguments @("-NonInteractive", "-SkipSetup")
+        -ScriptArguments @("-NonInteractive")
     Add-KnownBinDirectories
 }
 

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/smoke/installers/test_installers.py

@@ -2327,15 +2327,15 @@ Add-Content -LiteralPath $env:CALL_LOG -Value "pi-install"
         encoding="utf-8",
     )
     (fixtures / "hermes-installer.ps1").write_text(
-        r"""param(
-    [switch] $NonInteractive,
-    [switch] $SkipSetup
+        r"""[CmdletBinding(PositionalBinding=$false)]
+param(
+    [switch] $NonInteractive
 )
 if ($env:FAIL_STEP -eq "hermes-install") { exit 65 }
 $bin = Join-Path $env:LOCALAPPDATA "hermes\hermes-agent\bin"
 New-Item -ItemType Directory -Force -Path $bin | Out-Null
 Copy-Item (Join-Path $env:FAKE_FIXTURES "hermes-command.cmd") (Join-Path $bin "hermes.cmd") -Force
-Add-Content -LiteralPath $env:CALL_LOG -Value "hermes-install:${NonInteractive}:${SkipSetup}"
+Add-Content -LiteralPath $env:CALL_LOG -Value "hermes-install:${NonInteractive}"
 """,
         encoding="utf-8",
     )
@@ -3173,7 +3173,7 @@ def test_install_ps1_fresh_install_is_verified(
     )
     assert calls.index("npm:install -g cline") < calls.index("cline:--version")
     assert any("hermes-agent.nousresearch.com/install.ps1" in call for call in calls)
-    assert "hermes-install:True:True" in calls
+    assert "hermes-install:True" in calls
     assert calls.index("npm:install -g @deepseek-ai/dsh@0.1.0-rc.8") < calls.index(
         "dsh:--version"
     )
@@ -3251,7 +3251,7 @@ def test_install_ps1_discovers_grok_in_custom_bin_directory(
     ("client", "install_call"),
     [
         ("cline", "npm:install -g cline"),
-        ("hermes", "hermes-install:True:True"),
+        ("hermes", "hermes-install:True"),
         ("grok", "grok-install"),
         (
             "aider",
@@ -3538,6 +3538,16 @@ def test_install_ps1_stops_when_selected_dsh_install_fails(
     _assert_uv_ready_without_fcc_install(powershell_harness.calls())
 
 
+def test_install_ps1_installs_hermes_noninteractively(
+    powershell_harness: PowerShellHarness,
+) -> None:
+    result = powershell_harness.run_functions("Ensure-Hermes")
+
+    assert result.returncode == 0, result.stderr
+    calls = powershell_harness.calls()
+    assert calls.index("hermes-install:True") < calls.index("hermes:--version")
+
+
 def test_install_ps1_rejects_unsupported_hermes_architecture_before_download(
     powershell_harness: PowerShellHarness,
 ) -> None:

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/config/settings.py

@@ -584,12 +584,14 @@ class Settings(BaseModel):
         default=None, validation_alias="OLLAMA_CLOUD_PROXY"
     )
     # ==================== Provider Rate Limiting ====================
-    provider_rate_limit: int = Field(default=1, validation_alias="PROVIDER_RATE_LIMIT")
+    provider_rate_limit: int = Field(
+        default=1, gt=0, validation_alias="PROVIDER_RATE_LIMIT"
+    )
     provider_rate_window: int = Field(
-        default=2, validation_alias="PROVIDER_RATE_WINDOW"
+        default=2, gt=0, validation_alias="PROVIDER_RATE_WINDOW"
     )
     provider_max_concurrency: int = Field(
-        default=2, validation_alias="PROVIDER_MAX_CONCURRENCY"
+        default=2, gt=0, validation_alias="PROVIDER_MAX_CONCURRENCY"
     )
     provider_progress_timeout: float = Field(
         default=600.0,

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/providers/admission.py

@@ -5,6 +5,7 @@ import math
 import random
 import time
 import uuid
+from collections import deque
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
@@ -14,8 +15,8 @@ from typing import TypeVar
 
 from loguru import logger
 
-from free_claude_code.core.rate_limit import StrictSlidingWindowLimiter
 from free_claude_code.core.trace import trace_event
+from free_claude_code.providers.admission_policy import ProviderAdmissionLimits
 from free_claude_code.providers.failure_policy import (
     ProviderFailureOverride,
     ProviderRecoveryExhausted,
@@ -416,12 +417,7 @@ class ProviderAdmissionController:
         max_delay: float = DEFAULT_UPSTREAM_MAX_DELAY,
         jitter: float = DEFAULT_UPSTREAM_JITTER,
     ) -> None:
-        if rate_limit <= 0:
-            raise ValueError("rate_limit must be > 0")
-        if rate_window <= 0:
-            raise ValueError("rate_window must be > 0")
-        if max_concurrency <= 0:
-            raise ValueError("max_concurrency must be > 0")
+        limits = ProviderAdmissionLimits(rate_limit, rate_window, max_concurrency)
         if max_attempts <= 0:
             raise ValueError("max_attempts must be > 0")
         if base_delay < 0:
@@ -436,10 +432,11 @@ class ProviderAdmissionController:
         self._base_delay = base_delay
         self._max_delay = max_delay
         self._jitter = jitter
-        self._proactive_limiter = StrictSlidingWindowLimiter(
-            rate_limit, float(rate_window)
-        )
-        self._concurrency_sem = asyncio.Semaphore(max_concurrency)
+        self._limits = limits
+        self._admission_times: deque[float] = deque()
+        self._last_discarded_at: float | None = None
+        self._active_attempts = 0
+        self._capacity_changed = asyncio.Event()
         self._condition = asyncio.Condition()
         self._episode: _RecoveryEpisode | None = None
         self._next_generation = 1
@@ -485,19 +482,11 @@ class ProviderAdmissionController:
             slot_acquired = False
             claim: _AttemptClaim | None = None
             try:
-                admitted = await self._proactive_limiter.acquire_if(
-                    lambda permit=permit: self._permit_is_current(execution, permit)
-                )
+                admitted = await self._acquire_capacity(execution, permit)
                 if not admitted:
                     await self._abandon_probe_permit(execution, permit)
                     continue
-                await self._concurrency_sem.acquire()
                 slot_acquired = True
-                if not self._permit_is_current(execution, permit):
-                    self._concurrency_sem.release()
-                    slot_acquired = False
-                    await self._abandon_probe_permit(execution, permit)
-                    continue
                 claim = execution._claim_attempt(operation_kind)
                 attempt = ProviderAttempt(self, execution, permit, claim)
                 trace_event(
@@ -518,7 +507,7 @@ class ProviderAdmissionController:
                 if claim is not None:
                     execution._close_attempt(claim)
                 if slot_acquired:
-                    self._concurrency_sem.release()
+                    self._release_concurrency()
                 await self._abandon_probe_permit(execution, permit)
                 raise
 
@@ -639,7 +628,7 @@ class ProviderAdmissionController:
             if episode is None:
                 return
             self._episode = None
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
         trace_event(
             stage="provider",
             event="provider.recovery.closed",
@@ -664,7 +653,7 @@ class ProviderAdmissionController:
                 return
             episode.probe_active = False
             episode.ready_at = time.monotonic()
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
 
     async def _attempt_rejected(
         self,
@@ -679,7 +668,7 @@ class ProviderAdmissionController:
             if episode is None:
                 return
             self._episode = None
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
         trace_event(
             stage="provider",
             event="provider.recovery.closed",
@@ -705,7 +694,7 @@ class ProviderAdmissionController:
             episode.leader = None
             episode.probe_active = False
             episode.ready_at = time.monotonic()
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
 
     async def _attempt_failed(
         self,
@@ -740,7 +729,7 @@ class ProviderAdmissionController:
                     execution._fail_recovery(episode.last_error)
                 else:
                     episode.waiters.add(execution)
-                self._condition.notify_all()
+                self._notify_recovery_waiters()
             elif episode is None or matching_probe is not None:
                 terminal_delay = self._retry_delay(
                     error,
@@ -761,7 +750,7 @@ class ProviderAdmissionController:
                     waiter._fail_recovery(error)
                 episode.waiters.clear()
                 exhausted_episode = True
-                self._condition.notify_all()
+                self._notify_recovery_waiters()
 
         label = self._failure_label(status, error)
         if became_leader:
@@ -871,7 +860,7 @@ class ProviderAdmissionController:
             episode.leader = None
             episode.probe_active = False
             episode.ready_at = time.monotonic()
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
 
     async def _abandon_waiting_leader(
         self,
@@ -888,10 +877,64 @@ class ProviderAdmissionController:
             ):
                 return
             episode.leader = None
-            self._condition.notify_all()
+            self._notify_recovery_waiters()
+
+    def reconfigure(self, limits: ProviderAdmissionLimits) -> None:
+        """Update capacity without resetting occupancy, history, or recovery."""
+        if limits != self._limits:
+            self._limits = limits
+            self._wake_capacity()
+
+    def _wake_capacity(self) -> None:
+        changed = self._capacity_changed
+        self._capacity_changed = asyncio.Event()
+        changed.set()
+
+    def _notify_recovery_waiters(self) -> None:
+        self._condition.notify_all()
+        self._wake_capacity()
+
+    async def _acquire_capacity(
+        self, execution: ProviderExecution, permit: _GatePermit
+    ) -> bool:
+        while self._permit_is_current(execution, permit):
+            changed = self._capacity_changed
+            now = time.monotonic()
+            limits = self._limits
+            cutoff = now - limits.rate_window
+            while self._admission_times and self._admission_times[0] <= cutoff:
+                self._last_discarded_at = self._admission_times.popleft()
+
+            ready_at = now
+            if self._last_discarded_at is not None:
+                ready_at = max(ready_at, self._last_discarded_at + limits.rate_window)
+            if len(self._admission_times) >= limits.rate_limit:
+                ready_at = max(
+                    ready_at,
+                    self._admission_times[-limits.rate_limit] + limits.rate_window,
+                )
+            if self._active_attempts < limits.max_concurrency and ready_at <= now:
+                self._admission_times.append(now)
+                self._active_attempts += 1
+                return True
+
+            # Occupancy changes explicitly wake us. Avoid an expired rate timer
+            # spinning while all concurrency slots remain occupied.
+            delay = (
+                max(0.0, ready_at - now)
+                if self._active_attempts < limits.max_concurrency
+                else None
+            )
+            try:
+                async with asyncio.timeout(delay):
+                    await changed.wait()
+            except TimeoutError:
+                pass
+        return False
 
     def _release_concurrency(self) -> None:
-        self._concurrency_sem.release()
+        self._active_attempts -= 1
+        self._wake_capacity()
 
     def _retry_delay(self, error: Exception, attempt: int) -> float:
         exponent = max(0, attempt - 1)

free_claude_code-6.4.4/src/free_claude_code/providers/admission_policy.py

@@ -0,0 +1,31 @@
+"""Validated capacity policy, independent of clients and controller lifetime."""
+
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from free_claude_code.config.settings import Settings
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderAdmissionLimits:
+    rate_limit: int
+    rate_window: float
+    max_concurrency: int
+
+    def __post_init__(self) -> None:
+        for name in ("rate_limit", "max_concurrency"):
+            value = getattr(self, name)
+            if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+                raise ValueError(f"{name} must be a positive integer")
+        if not math.isfinite(self.rate_window) or self.rate_window <= 0:
+            raise ValueError("rate_window must be finite and > 0")
+
+    @classmethod
+    def from_settings(cls, settings: Settings) -> ProviderAdmissionLimits:
+        return cls(
+            settings.provider_rate_limit,
+            settings.provider_rate_window,
+            settings.provider_max_concurrency,
+        )

free_claude_code-6.4.4/src/free_claude_code/providers/admission_registry.py

@@ -0,0 +1,50 @@
+"""Loop-owned admission policy and controller lifetimes, independent of clients."""
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from free_claude_code.providers.admission_policy import ProviderAdmissionLimits
+
+if TYPE_CHECKING:
+    from free_claude_code.providers.admission import ProviderAdmissionController
+
+
+class ProviderAdmissionRegistry:
+    """One protection budget per configured provider for one runtime manager."""
+
+    def __init__(self, limits: ProviderAdmissionLimits) -> None:
+        self._limits = limits
+        self._controllers: dict[str, ProviderAdmissionController] = {}
+        self._closed = False
+
+    def get(self, provider_id: str) -> ProviderAdmissionController:
+        if self._closed:
+            raise RuntimeError("Provider admission registry is closed")
+        if provider_id not in self._controllers:
+            # Provider preparation loads SDKs in a worker before reaching here.
+            from free_claude_code.providers.admission import ProviderAdmissionController
+
+            self._controllers[provider_id] = ProviderAdmissionController(
+                provider_name=provider_id,
+                rate_limit=self._limits.rate_limit,
+                rate_window=self._limits.rate_window,
+                max_concurrency=self._limits.max_concurrency,
+            )
+        return self._controllers[provider_id]
+
+    def reconfigure(self, limits: ProviderAdmissionLimits) -> None:
+        """Publish validated limits without yielding to waiting requests."""
+        self._limits = limits
+        for controller in self._controllers.values():
+            controller.reconfigure(limits)
+
+    def retain_custom(self, provider_ids: Iterable[str]) -> None:
+        retained = set(provider_ids)
+        for provider_id in tuple(self._controllers):
+            if provider_id.startswith("custom_") and provider_id not in retained:
+                del self._controllers[provider_id]
+
+    def close(self) -> None:
+        """Forget state only after client generations have drained and closed."""
+        self._closed = True
+        self._controllers.clear()

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/providers/base.py

@@ -20,9 +20,6 @@ class ProviderConfig:
 
     api_key: str | None
     base_url: str
-    rate_limit: int
-    rate_window: int
-    max_concurrency: int
     http_read_timeout: float
     http_write_timeout: float
     http_connect_timeout: float

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/providers/runtime/config.py

@@ -80,9 +80,6 @@ def build_provider_config(
     return ProviderConfig(
         api_key=credential,
         base_url=resolved_base_url,
-        rate_limit=settings.provider_rate_limit,
-        rate_window=settings.provider_rate_window,
-        max_concurrency=settings.provider_max_concurrency,
         http_read_timeout=settings.http_read_timeout,
         http_write_timeout=settings.http_write_timeout,
         http_connect_timeout=settings.http_connect_timeout,
@@ -99,9 +96,6 @@ def build_custom_provider_config(
         api_key=definition.api_key.get_secret_value() if definition.api_key else None,
         base_url=definition.base_url,
         proxy=None,
-        rate_limit=settings.provider_rate_limit,
-        rate_window=settings.provider_rate_window,
-        max_concurrency=settings.provider_max_concurrency,
         http_read_timeout=settings.http_read_timeout,
         http_write_timeout=settings.http_write_timeout,
         http_connect_timeout=settings.http_connect_timeout,

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/providers/runtime/factory.py

@@ -11,6 +11,7 @@ from free_claude_code.config.custom_providers import CustomProviderDefinition
 from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
 from free_claude_code.config.settings import Settings
 from free_claude_code.providers.admission import ProviderAdmissionController
+from free_claude_code.providers.admission_registry import ProviderAdmissionRegistry
 from free_claude_code.providers.base import BaseProvider, ProviderConfig
 from free_claude_code.providers.openai_chat import (
     OPENAI_CHAT_PROFILES,
@@ -251,7 +252,7 @@ def prepare_provider(
     provider_id: str,
     provider_loaders: Mapping[str, Callable[[], ProviderFactory]],
     custom_definition: CustomProviderDefinition | None = None,
-) -> Callable[[Settings], BaseProvider]:
+) -> Callable[[Settings, ProviderAdmissionRegistry], BaseProvider]:
     """Load implementation modules in a worker; return a loop-owned constructor."""
 
     # The SDK lazily imports these on first client resource access. Keep that
@@ -262,14 +263,11 @@ def prepare_provider(
 
         from .config import build_custom_provider_config
 
-        def construct_custom(settings: Settings) -> BaseProvider:
+        def construct_custom(
+            settings: Settings, admission_registry: ProviderAdmissionRegistry
+        ) -> BaseProvider:
             config = build_custom_provider_config(custom_definition, settings)
-            admission = ProviderAdmissionController(
-                provider_name=provider_id,
-                rate_limit=config.rate_limit,
-                rate_window=config.rate_window,
-                max_concurrency=config.max_concurrency,
-            )
+            admission = admission_registry.get(provider_id)
             return CustomProvider(
                 config, definition=custom_definition, admission=admission
             )
@@ -287,14 +285,11 @@ def prepare_provider(
         )
     factory = loader() if loader is not None else None
 
-    def construct(settings: Settings) -> BaseProvider:
+    def construct(
+        settings: Settings, admission_registry: ProviderAdmissionRegistry
+    ) -> BaseProvider:
         config = build_provider_config(descriptor, settings)
-        admission = ProviderAdmissionController(
-            provider_name=provider_id,
-            rate_limit=config.rate_limit,
-            rate_window=config.rate_window,
-            max_concurrency=config.max_concurrency,
-        )
+        admission = admission_registry.get(provider_id)
         if factory is not None:
             return factory(config, settings, admission)
         return create_openai_chat_provider(provider_id, config, admission)

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/providers/runtime/runtime.py

@@ -8,18 +8,21 @@ from typing import TYPE_CHECKING
 from free_claude_code.application.errors import ApplicationUnavailableError
 from free_claude_code.config.settings import Settings
 from free_claude_code.core.async_tasks import run_sync_owned
+from free_claude_code.providers.admission_registry import ProviderAdmissionRegistry
 from free_claude_code.providers.base import BaseProvider
 
 if TYPE_CHECKING:
     from .factory import ProviderFactory
 
-type ProviderConstructor = Callable[[str, Settings], Awaitable[BaseProvider]]
+type ProviderConstructor = Callable[
+    [str, Settings, ProviderAdmissionRegistry], Awaitable[BaseProvider]
+]
 type ProviderLoader = Callable[[], ProviderFactory]
 
 
 def _load_constructor(
     provider_id: str, provider_loaders: Mapping[str, ProviderLoader], settings: Settings
-) -> Callable[[Settings], BaseProvider]:
+) -> Callable[[Settings, ProviderAdmissionRegistry], BaseProvider]:
     from .factory import prepare_provider
 
     return prepare_provider(
@@ -34,13 +37,14 @@ def _load_constructor(
 async def create_provider(
     provider_id: str,
     settings: Settings,
+    admission_registry: ProviderAdmissionRegistry,
     *,
     provider_loaders: Mapping[str, ProviderLoader] | None = None,
 ) -> BaseProvider:
     constructor = await run_sync_owned(
         partial(_load_constructor, provider_id, provider_loaders or {}, settings)
     )
-    return constructor(settings)
+    return constructor(settings, admission_registry)
 
 
 class ProviderRuntime:
@@ -49,11 +53,13 @@ class ProviderRuntime:
     def __init__(
         self,
         settings: Settings,
+        admission_registry: ProviderAdmissionRegistry,
         providers: MutableMapping[str, BaseProvider] | None = None,
         *,
         provider_constructor: ProviderConstructor = create_provider,
     ) -> None:
         self.settings = settings
+        self._admission_registry = admission_registry
         self._providers = providers if providers is not None else {}
         self._provider_constructor = provider_constructor
         self._creations: dict[str, asyncio.Task[BaseProvider]] = {}
@@ -85,7 +91,9 @@ class ProviderRuntime:
             task.exception()  # Observe failures even when every caller stopped waiting.
 
     async def _construct(self, provider_id: str) -> BaseProvider:
-        provider = await self._provider_constructor(provider_id, self.settings)
+        provider = await self._provider_constructor(
+            provider_id, self.settings, self._admission_registry
+        )
         self._providers[provider_id] = provider
         return provider
 

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/src/free_claude_code/runtime/provider_manager.py

@@ -20,6 +20,8 @@ from free_claude_code.core.async_tasks import run_sync_owned
 from free_claude_code.core.json_types import JsonObject
 from free_claude_code.core.token_estimation import initialize_token_estimation
 from free_claude_code.core.trace import trace_event
+from free_claude_code.providers.admission_policy import ProviderAdmissionLimits
+from free_claude_code.providers.admission_registry import ProviderAdmissionRegistry
 from free_claude_code.providers.base import BaseProvider
 from free_claude_code.providers.model_listing import model_infos_from_ids
 from free_claude_code.providers.runtime.discovery import (
@@ -31,7 +33,9 @@ from free_claude_code.providers.runtime.discovery import (
 from free_claude_code.providers.runtime.model_cache import ProviderModelCache
 from free_claude_code.providers.runtime.runtime import ProviderRuntime
 
-ProviderRuntimeFactory = Callable[[Settings], ProviderRuntime]
+ProviderRuntimeFactory = Callable[
+    [Settings, ProviderAdmissionRegistry], ProviderRuntime
+]
 ConnectedProviderIds = Callable[[], tuple[str, ...]]
 CommitConfig = Callable[[], Awaitable[None]]
 
@@ -157,6 +161,9 @@ class ProviderRuntimeManager:
         model_catalog_publisher: ModelCatalogPublisher | None = None,
     ) -> None:
         self._runtime_factory = runtime_factory
+        self._admission_registry = ProviderAdmissionRegistry(
+            ProviderAdmissionLimits.from_settings(settings)
+        )
         self._connected_provider_ids = connected_provider_ids
         self._model_catalog_publisher = model_catalog_publisher
         self._catalog_changed: Callable[[], None] | None = None
@@ -174,7 +181,7 @@ class ProviderRuntimeManager:
         self._current = _ProviderGeneration(
             generation_id=1,
             settings=settings,
-            runtime=runtime_factory(settings),
+            runtime=runtime_factory(settings, self._admission_registry),
             cache=ProviderModelCache(
                 model_cache_provider_ids_for_settings(
                     settings, connected_provider_ids()
@@ -527,10 +534,13 @@ class ProviderRuntimeManager:
         async with self._replace_lock:
             self._ensure_open()
             await self._retry_unpublished_cleanup()
+            limits = ProviderAdmissionLimits.from_settings(settings)
             candidate_id = self._next_generation_id
             candidate_runtime: ProviderRuntime | None = None
             try:
-                candidate_runtime = self._runtime_factory(settings)
+                candidate_runtime = self._runtime_factory(
+                    settings, self._admission_registry
+                )
                 await commit()
             except BaseException as exc:
                 trace_event(
@@ -565,6 +575,7 @@ class ProviderRuntimeManager:
                     runtime=candidate_runtime,
                     cache=cache,
                 )
+                self._admission_registry.reconfigure(limits)
                 self._current = candidate
                 self._catalog_revision += 1
                 previous.retired = True
@@ -621,8 +632,21 @@ class ProviderRuntimeManager:
             if not all(generation_results) or not unpublished_closed:
                 raise RuntimeError("One or more provider runtimes failed to close.")
             self._current.cache.clear()
+            self._admission_registry.close()
             self._closed = True
 
+    def _prune_admission(self) -> None:
+        runtimes = (
+            self._current.runtime,
+            *(generation.runtime for generation in self._retired.values()),
+            *self._unpublished,
+        )
+        self._admission_registry.retain_custom(
+            definition.provider_id
+            for runtime in runtimes
+            for definition in runtime.settings.custom_providers
+        )
+
     async def _release(self, generation: _ProviderGeneration) -> None:
         if generation.active_leases <= 0:
             return
@@ -645,6 +669,7 @@ class ProviderRuntimeManager:
             )
             return False
         self._unpublished.discard(runtime)
+        self._prune_admission()
         return True
 
     async def _retry_unpublished_cleanup(self) -> bool:
@@ -696,6 +721,7 @@ class ProviderRuntimeManager:
 
             generation.closed = True
             self._retired.pop(generation.generation_id, None)
+            self._prune_admission()
             trace_event(
                 stage="runtime",
                 event="provider_generation.closed",

{free_claude_code-6.4.2 → free_claude_code-6.4.4}/tests/api/support.py

@@ -67,8 +67,9 @@ def create_test_app(
     else:
         manager = ApiTestRuntime(
             settings,
-            runtime_factory=lambda snapshot: ProviderRuntime(
+            runtime_factory=lambda snapshot, admission_registry: ProviderRuntime(
                 snapshot,
+                admission_registry,
                 dict(providers),
             ),
             connected_provider_ids=connected_provider_ids,