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
10.5 KB
Raw Blame
"""Provider construction from declarative profiles and exceptional adapters."""

import importlib
from collections.abc import Callable, Mapping

from free_claude_code.application.errors import (
    ApplicationUnavailableError,
    UnknownProviderError,
)
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,
    create_openai_chat_provider,
)

from .config import build_provider_config

ProviderFactory = Callable[
    [ProviderConfig, Settings, ProviderAdmissionController], BaseProvider
]


def _load_anthropic() -> ProviderFactory:
    from free_claude_code.providers.anthropic import AnthropicProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return AnthropicProvider(
            config, workspace_id=settings.anthropic_workspace_id, admission=admission
        )

    return construct


def _load_nvidia_nim() -> ProviderFactory:
    from free_claude_code.providers.nvidia_nim import NvidiaNimProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return NvidiaNimProvider(
            config,
            nim_settings=settings.nim,
            admission=admission,
        )

    return construct


def _load_open_router() -> ProviderFactory:
    from free_claude_code.providers.open_router import OpenRouterProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return OpenRouterProvider(config, admission=admission)

    return construct


def _load_openai_api() -> ProviderFactory:
    from free_claude_code.providers.openai_api import OpenAIAPIProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return OpenAIAPIProvider(config, admission=admission)

    return construct


def _load_mistral() -> ProviderFactory:
    from free_claude_code.providers.mistral import MistralProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return MistralProvider(config, admission=admission)

    return construct


def _load_kilo() -> ProviderFactory:
    from free_claude_code.providers.kilo import KiloProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return KiloProvider(config, admission=admission)

    return construct


def _load_deepseek() -> ProviderFactory:
    from free_claude_code.providers.deepseek import DeepSeekProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return DeepSeekProvider(config, admission=admission)

    return construct


def _load_alibaba_cloud() -> ProviderFactory:
    from free_claude_code.providers.alibaba_cloud import AlibabaCloudProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return AlibabaCloudProvider(config, admission=admission)

    return construct


def _load_lmstudio() -> ProviderFactory:
    from free_claude_code.providers.lmstudio import LMStudioProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return LMStudioProvider(config, admission=admission)

    return construct


def _load_cloudflare() -> ProviderFactory:
    from free_claude_code.providers.cloudflare import CloudflareProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return CloudflareProvider(
            config,
            account_id=_required_setting(settings, "cloudflare_account_id"),
            admission=admission,
        )

    return construct


def _load_gemini() -> ProviderFactory:
    from free_claude_code.providers.gemini import GeminiProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return GeminiProvider(config, admission=admission)

    return construct


def _load_vertex() -> ProviderFactory:
    from free_claude_code.providers.vertex import VertexProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return VertexProvider(
            config,
            project_id=_required_setting(settings, "vertex_project_id"),
            location=settings.vertex_location,
            admission=admission,
        )

    return construct


def _load_groq() -> ProviderFactory:
    from free_claude_code.providers.groq import GroqProvider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return GroqProvider(config, admission=admission)

    return construct


def _load_opencode_zen() -> ProviderFactory:
    from free_claude_code.providers.opencode import create_opencode_provider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return create_opencode_provider("opencode_zen", config, admission)

    return construct


def _load_opencode_go() -> ProviderFactory:
    from free_claude_code.providers.opencode import create_opencode_provider

    def construct(
        config: ProviderConfig,
        settings: Settings,
        admission: ProviderAdmissionController,
    ) -> BaseProvider:
        return create_opencode_provider("opencode_go", config, admission)

    return construct


_SPECIAL_PROVIDER_FACTORIES: dict[str, Callable[[], ProviderFactory]] = {
    "anthropic": _load_anthropic,
    "alibaba_cloud": _load_alibaba_cloud,
    "nvidia_nim": _load_nvidia_nim,
    "open_router": _load_open_router,
    "openai_api": _load_openai_api,
    "mistral": _load_mistral,
    "kilo": _load_kilo,
    "deepseek": _load_deepseek,
    "lmstudio": _load_lmstudio,
    "cloudflare": _load_cloudflare,
    "gemini": _load_gemini,
    "vertex": _load_vertex,
    "groq": _load_groq,
    "opencode_zen": _load_opencode_zen,
    "opencode_go": _load_opencode_go,
}
_INJECTED_PROVIDER_IDS = {"openai", "github_copilot"}


def _required_setting(settings: Settings, attr_name: str) -> str:
    value = getattr(settings, attr_name, None)
    if not isinstance(value, str) or not value:
        raise AssertionError(f"Provider config did not validate {attr_name!r}")
    return value


_profiled_ids = set(OPENAI_CHAT_PROFILES)
_special_ids = set(_SPECIAL_PROVIDER_FACTORIES)
_construction_ids = _profiled_ids | _special_ids | _INJECTED_PROVIDER_IDS
if (
    _profiled_ids & _special_ids
    or _profiled_ids & _INJECTED_PROVIDER_IDS
    or _special_ids & _INJECTED_PROVIDER_IDS
    or _construction_ids != set(PROVIDER_CATALOG)
):
    raise AssertionError(
        "Every provider must have exactly one construction owner: "
        f"profiles={_profiled_ids!r} special={_special_ids!r} "
        f"injected={_INJECTED_PROVIDER_IDS!r} catalog={set(PROVIDER_CATALOG)!r}"
    )


def prepare_provider(
    provider_id: str,
    provider_loaders: Mapping[str, Callable[[], ProviderFactory]],
    custom_definition: CustomProviderDefinition | None = None,
    *,
    api_key_number: int = 1,
) -> 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
    # work in this loader, before constructing clients on their owner loop.
    importlib.import_module("openai.resources")
    if custom_definition is not None:
        from free_claude_code.providers.custom import CustomProvider

        from .config import build_custom_provider_config

        def construct_custom(
            settings: Settings, admission_registry: ProviderAdmissionRegistry
        ) -> BaseProvider:
            config = build_custom_provider_config(
                custom_definition, settings, api_key_number=api_key_number
            )
            admission = admission_registry.get(provider_id, api_key=config.api_key)
            return CustomProvider(
                config, definition=custom_definition, admission=admission
            )

        return construct_custom
    descriptor = PROVIDER_CATALOG.get(provider_id)
    if descriptor is None:
        raise UnknownProviderError.for_provider(provider_id, PROVIDER_CATALOG)
    loader = provider_loaders.get(provider_id) or _SPECIAL_PROVIDER_FACTORIES.get(
        provider_id
    )
    if provider_id in _INJECTED_PROVIDER_IDS and loader is None:
        raise ApplicationUnavailableError(
            f"Provider {provider_id!r} is unavailable in this runtime."
        )
    factory = loader() if loader is not None else None

    def construct(
        settings: Settings, admission_registry: ProviderAdmissionRegistry
    ) -> BaseProvider:
        config = build_provider_config(
            descriptor, settings, api_key_number=api_key_number
        )
        admission = admission_registry.get(provider_id, api_key=config.api_key)
        if factory is not None:
            provider = factory(config, settings, admission)
            if (
                descriptor.native_messages_passthrough
                and type(provider).stream_native_messages
                is BaseProvider.stream_native_messages
            ):
                raise AssertionError(
                    f"Provider {provider_id!r} lacks native Messages execution"
                )
            return provider
        return create_openai_chat_provider(provider_id, config, admission)

    return construct