Skip to content

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
4.9 KB
Raw Blame
"""One closable generation of lazily constructed provider clients."""

import asyncio
from collections.abc import Awaitable, Callable, Mapping, MutableMapping
from functools import partial
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, ProviderAdmissionRegistry, int], Awaitable[BaseProvider]
]
type ProviderLoader = Callable[[], ProviderFactory]
type ProviderClientKey = tuple[str, int]


def _load_constructor(
    provider_id: str,
    provider_loaders: Mapping[str, ProviderLoader],
    settings: Settings,
    api_key_number: int,
) -> Callable[[Settings, ProviderAdmissionRegistry], BaseProvider]:
    from .factory import prepare_provider

    return prepare_provider(
        provider_id,
        provider_loaders,
        settings.custom_provider(provider_id)
        if provider_id.startswith("custom_")
        else None,
        api_key_number=api_key_number,
    )


async def create_provider(
    provider_id: str,
    settings: Settings,
    admission_registry: ProviderAdmissionRegistry,
    api_key_number: int = 1,
    *,
    provider_loaders: Mapping[str, ProviderLoader] | None = None,
) -> BaseProvider:
    constructor = await run_sync_owned(
        partial(
            _load_constructor,
            provider_id,
            provider_loaders or {},
            settings,
            api_key_number,
        )
    )
    return constructor(settings, admission_registry)


class ProviderRuntime:
    """Own provider instances for one immutable settings snapshot."""

    def __init__(
        self,
        settings: Settings,
        admission_registry: ProviderAdmissionRegistry,
        providers: MutableMapping[ProviderClientKey, 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[ProviderClientKey, asyncio.Task[BaseProvider]] = {}
        self._closing = False

    def is_cached(self, provider_id: str, api_key_number: int = 1) -> bool:
        """Return whether this provider/key client is already cached."""
        return (provider_id, api_key_number) in self._providers

    async def resolve_provider(
        self, provider_id: str, api_key_number: int = 1
    ) -> BaseProvider:
        """Return an existing provider or create it lazily."""
        if self._closing:
            raise ApplicationUnavailableError("Provider runtime is shutting down.")
        key = (provider_id, api_key_number)
        if key in self._providers:
            return self._providers[key]
        task = self._creations.get(key)
        if task is None or task.done():
            task = asyncio.create_task(self._construct(key))
            self._creations[key] = task
            task.add_done_callback(partial(self._creation_done, key))
        return await asyncio.shield(task)

    def _creation_done(
        self, key: ProviderClientKey, task: asyncio.Task[BaseProvider]
    ) -> None:
        if self._creations.get(key) is task:
            del self._creations[key]
        if not task.cancelled():
            task.exception()  # Observe failures even when every caller stopped waiting.

    async def _construct(self, key: ProviderClientKey) -> BaseProvider:
        provider_id, api_key_number = key
        provider = await self._provider_constructor(
            provider_id, self.settings, self._admission_registry, api_key_number
        )
        self._providers[key] = provider
        return provider

    async def cleanup(self) -> None:
        """Release every provider client constructed by this generation."""
        self._closing = True
        creations = tuple(self._creations.values())
        for task in creations:
            if not task.done():
                task.cancel()
        await asyncio.gather(*creations, return_exceptions=True)
        self._creations.clear()
        errors: list[Exception] = []
        for provider_id, provider in list(self._providers.items()):
            try:
                await provider.cleanup()
            except asyncio.CancelledError:
                raise
            except Exception as exc:
                errors.append(exc)
            else:
                self._providers.pop(provider_id, None)
        if len(errors) == 1:
            raise errors[0]
        if len(errors) > 1:
            raise ExceptionGroup("One or more provider cleanups failed", errors)