File size: 5,494 Bytes
9f6a4bd
e99df76
691dc7c
2415446
691dc7c
 
 
2415446
691dc7c
2415446
691dc7c
 
2415446
a9e27c0
2415446
691dc7c
 
 
 
a9e27c0
 
691dc7c
 
f7872b8
691dc7c
 
 
f7872b8
 
 
 
a9e27c0
 
 
691dc7c
2415446
691dc7c
 
 
 
 
 
f7872b8
691dc7c
 
 
 
 
 
 
f7872b8
a9e27c0
691dc7c
 
 
 
f7872b8
 
 
 
 
 
 
691dc7c
a9e27c0
a1bab2d
2415446
 
 
 
 
 
 
691dc7c
a9e27c0
f7872b8
a1bab2d
 
2415446
 
a9e27c0
 
 
691dc7c
2415446
a1bab2d
f7872b8
691dc7c
2415446
f7872b8
 
 
2415446
f7872b8
 
 
2415446
691dc7c
 
f7872b8
 
 
 
691dc7c
f7872b8
 
 
691dc7c
 
 
f7872b8
691dc7c
f7872b8
 
691dc7c
 
 
f7872b8
 
691dc7c
a9e27c0
 
 
 
 
691dc7c
f7872b8
691dc7c
2415446
 
 
691dc7c
 
 
 
 
 
 
2415446
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
from __future__ import annotations
"""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
from free_claude_code.providers.history_negotiation import HistoryModeCache

if TYPE_CHECKING:
    from .factory import ProviderFactory

type ProviderConstructor = Callable[
    [str, Settings, ProviderAdmissionRegistry, int, HistoryModeCache],
    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, HistoryModeCache | None], 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,
    history_cache: HistoryModeCache | None = None,
    *,
    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, history_cache)


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

    def __init__(
        self,
        settings: Settings,
        admission_registry: ProviderAdmissionRegistry,
        history_cache: HistoryModeCache | None = None,
        providers: MutableMapping[ProviderClientKey, BaseProvider] | None = None,
        *,
        provider_constructor: ProviderConstructor = create_provider,
    ) -> None:
        self.settings = settings
        self._history_cache = (
            history_cache if history_cache is not None else HistoryModeCache()
        )
        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._history_cache,
        )
        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)