Spaces:
Running
Running
Download src/free_claude_code/providers/github_copilot/provider.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 19.7 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/github_copilot/provider.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/providers/github_copilot/provider.py
-
curl -L -o provider.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/github_copilot/provider.py
19.7 kB
| from __future__ import annotations | |
| """Copilot subscription models dispatched through FCC's three HTTP egresses.""" | |
| import asyncio | |
| import sys | |
| from collections.abc import AsyncIterator, Mapping | |
| from contextlib import suppress | |
| from dataclasses import replace | |
| import httpx | |
| import httpx2 | |
| from openai import AsyncOpenAI | |
| from free_claude_code.application.errors import InvalidRequestError | |
| from free_claude_code.application.model_metadata import ProviderModelInfo | |
| from free_claude_code.core.anthropic.models import MessagesRequest | |
| from free_claude_code.core.chat_completions.request import ChatRequest | |
| from free_claude_code.core.failures import ExecutionFailure, FailureKind | |
| from free_claude_code.core.gemini import GeminiRequest | |
| from free_claude_code.core.openai_responses import OpenAIResponsesRequest | |
| from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy | |
| from free_claude_code.core.stream_output import StreamOutput | |
| from free_claude_code.core.stream_recovery import ContinuationSeed | |
| from free_claude_code.providers.admission import ProviderAdmissionController | |
| from free_claude_code.providers.anthropic_messages.transport import ( | |
| AnthropicMessagesTransport, | |
| ) | |
| from free_claude_code.providers.base import BaseProvider, ProviderConfig | |
| from free_claude_code.providers.endpoint_types import EndpointContext, HttpEndpoint | |
| from free_claude_code.providers.history_negotiation import HistoryModeCache | |
| from free_claude_code.providers.http import close_provider_stream | |
| from free_claude_code.providers.openai_chat import ( | |
| OpenAIChatBehavior, | |
| OpenAIChatTransport, | |
| ) | |
| from free_claude_code.providers.openai_responses import OpenAIResponsesTransport | |
| from .auth import CopilotAuthManager | |
| from .lifecycle import drain_owned | |
| from .request_policy import ( | |
| PROVIDER_NAME, | |
| REPLAY_SCOPE, | |
| chat_profile, | |
| non_messages_reasoning, | |
| ) | |
| from .responses_events import CopilotResponsesEvents | |
| from .types import CopilotEgress, CopilotModel | |
| class _BorrowedMessagesPool(httpx.AsyncBaseTransport): | |
| def __init__(self, pool: httpx.AsyncBaseTransport) -> None: | |
| self._pool = pool | |
| async def handle_async_request(self, request: httpx.Request) -> httpx.Response: | |
| return await self._pool.handle_async_request(request) | |
| class _MessagesEndpoint: | |
| """A fresh snapshot replaces all cookie state for this request's next attempt.""" | |
| def __init__(self, context: EndpointContext, client: httpx.AsyncClient) -> None: | |
| self._context = context | |
| self._client = client | |
| async def endpoint(self, *, force_refresh: bool = False) -> HttpEndpoint: | |
| snapshot = await self._context.endpoint(force_refresh=force_refresh) | |
| self._client.cookies.clear() | |
| base_url = snapshot.base_url.rstrip("/") | |
| return replace( | |
| snapshot, | |
| base_url=base_url if base_url.endswith("/v1") else base_url + "/v1", | |
| ) | |
| class GitHubCopilotProvider(BaseProvider): | |
| """Own generation HTTP resources; borrow the process account for each stream.""" | |
| def __init__( | |
| self, | |
| config: ProviderConfig, | |
| *, | |
| auth: CopilotAuthManager, | |
| admission: ProviderAdmissionController, | |
| history_cache: HistoryModeCache | None = None, | |
| messages_transport: httpx.AsyncBaseTransport | None = None, | |
| openai_transport: httpx2.AsyncBaseTransport | None = None, | |
| ) -> None: | |
| super().__init__(config, history_cache=history_cache) | |
| self._auth = auth | |
| self._admission = admission | |
| self._messages_pool = messages_transport or httpx.AsyncHTTPTransport( | |
| proxy=config.proxy | |
| ) | |
| self._openai_pool = openai_transport or httpx2.AsyncHTTPTransport( | |
| proxy=config.proxy | |
| ) | |
| self._client = AsyncOpenAI( | |
| api_key=_endpoint_required, | |
| base_url=config.base_url, | |
| max_retries=0, | |
| timeout=httpx2.Timeout( | |
| config.http_read_timeout, | |
| connect=config.http_connect_timeout, | |
| write=config.http_write_timeout, | |
| ), | |
| ) | |
| self._responses = OpenAIResponsesTransport( | |
| client=self._client, | |
| admission=admission, | |
| history_cache=self._history_cache, | |
| provider_name=PROVIDER_NAME, | |
| read_timeout_s=config.http_read_timeout, | |
| log_raw_sse_events=config.log_raw_sse_events, | |
| endpoint_transport=self._openai_pool, | |
| event_adapter_factory=CopilotResponsesEvents, | |
| ) | |
| self._chats: dict[str, tuple[CopilotModel, OpenAIChatTransport]] = {} | |
| self._condition = asyncio.Condition() | |
| self._active = 0 | |
| self._closing = False | |
| self._closed = False | |
| self._cleanup_task: asyncio.Task[None] | None = None | |
| def _check_model(self, model: str) -> None: | |
| if self._closing: | |
| raise ExecutionFailure( | |
| FailureKind.UNAVAILABLE, 503, "Copilot provider is closing.", False | |
| ) | |
| if not model.strip() or model.strip().casefold() == "auto": | |
| raise InvalidRequestError( | |
| "Choose a concrete model from the connected Copilot account." | |
| ) | |
| async def list_model_infos(self) -> frozenset[ProviderModelInfo]: | |
| if self._closing: | |
| raise ExecutionFailure( | |
| FailureKind.UNAVAILABLE, 503, "Copilot provider is closing.", False | |
| ) | |
| return frozenset( | |
| model.info for model in (await self._auth.models(refresh=True)).values() | |
| ) | |
| def stream_messages( | |
| self, | |
| request: MessagesRequest, | |
| input_tokens: int = 0, | |
| *, | |
| request_id: str | None = None, | |
| response_model: str | None = None, | |
| reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, | |
| request_headers: Mapping[str, str] | None = None, | |
| model_info: ProviderModelInfo | None = None, | |
| continuation: ContinuationSeed | None = None, | |
| ) -> AsyncIterator[StreamOutput]: | |
| self._check_model(request.model) | |
| return self._dispatch( | |
| request, | |
| input_tokens, | |
| request_id, | |
| response_model or request.model, | |
| reasoning, | |
| continuation=continuation, | |
| ) | |
| def stream_chat( | |
| self, | |
| request: ChatRequest, | |
| input_tokens: int = 0, | |
| *, | |
| request_id: str | None = None, | |
| response_model: str | None = None, | |
| reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, | |
| request_headers: Mapping[str, str] | None = None, | |
| model_info: ProviderModelInfo | None = None, | |
| continuation: ContinuationSeed | None = None, | |
| ) -> AsyncIterator[StreamOutput]: | |
| self._check_model(request.model) | |
| return self._dispatch( | |
| request, | |
| input_tokens, | |
| request_id, | |
| response_model or request.model, | |
| reasoning, | |
| continuation=continuation, | |
| ) | |
| def stream_gemini( | |
| self, | |
| request: GeminiRequest, | |
| input_tokens: int = 0, | |
| *, | |
| request_id: str | None = None, | |
| response_model: str | None = None, | |
| reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, | |
| request_headers: Mapping[str, str] | None = None, | |
| model_info: ProviderModelInfo | None = None, | |
| continuation: ContinuationSeed | None = None, | |
| ) -> AsyncIterator[StreamOutput]: | |
| self._check_model(request.model) | |
| return self._dispatch( | |
| request, | |
| input_tokens, | |
| request_id, | |
| response_model or request.model, | |
| reasoning, | |
| continuation=continuation, | |
| ) | |
| def stream_responses( | |
| self, | |
| request: OpenAIResponsesRequest, | |
| input_tokens: int = 0, | |
| *, | |
| request_id: str | None = None, | |
| response_model: str | None = None, | |
| reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY, | |
| request_headers: Mapping[str, str] | None = None, | |
| model_info: ProviderModelInfo | None = None, | |
| continuation: ContinuationSeed | None = None, | |
| ) -> AsyncIterator[StreamOutput]: | |
| self._check_model(request.model) | |
| return self._dispatch( | |
| request, | |
| input_tokens, | |
| request_id, | |
| response_model or request.model, | |
| reasoning, | |
| continuation=continuation, | |
| ) | |
| def _chat(self, model: CopilotModel) -> OpenAIChatTransport: | |
| cached = self._chats.get(model.info.model_id) | |
| if cached is None or cached[0] != model: | |
| transport = OpenAIChatTransport( | |
| behavior=OpenAIChatBehavior(chat_profile(model)), | |
| read_timeout_s=self._config.http_read_timeout, | |
| log_raw_sse_events=self._config.log_raw_sse_events, | |
| log_api_error_tracebacks=self._config.log_api_error_tracebacks, | |
| admission=self._admission, | |
| history_cache=self._history_cache, | |
| client=self._client, | |
| endpoint_transport=self._openai_pool, | |
| ) | |
| self._chats[model.info.model_id] = (model, transport) | |
| return transport | |
| return cached[1] | |
| async def _dispatch( | |
| self, | |
| request: MessagesRequest | OpenAIResponsesRequest | GeminiRequest | ChatRequest, | |
| input_tokens: int, | |
| request_id: str | None, | |
| response_model: str, | |
| reasoning: ReasoningPolicy, | |
| continuation: ContinuationSeed | None = None, | |
| ) -> AsyncIterator[StreamOutput]: | |
| async with self._condition: | |
| self._check_model(request.model) | |
| self._active += 1 | |
| try: | |
| async with self._auth.lease(request.model) as lease: | |
| selected: AsyncIterator[StreamOutput] | None = None | |
| http: httpx.AsyncClient | None = None | |
| try: | |
| if lease.egress is CopilotEgress.MESSAGES: | |
| http = httpx.AsyncClient( | |
| transport=_BorrowedMessagesPool(self._messages_pool), | |
| follow_redirects=False, | |
| timeout=httpx.Timeout( | |
| self._config.http_read_timeout, | |
| connect=self._config.http_connect_timeout, | |
| write=self._config.http_write_timeout, | |
| ), | |
| ) | |
| native = AnthropicMessagesTransport( | |
| client=http, | |
| admission=self._admission, | |
| history_cache=self._history_cache, | |
| provider_name=PROVIDER_NAME, | |
| replay_scope=REPLAY_SCOPE, | |
| read_timeout_s=self._config.http_read_timeout, | |
| capabilities=lease.model.messages, | |
| ) | |
| endpoint = _MessagesEndpoint(lease, http) | |
| if isinstance(request, ChatRequest): | |
| selected = native.stream_chat( | |
| request, | |
| endpoint_context=endpoint, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=reasoning, | |
| model_info=lease.model.info, | |
| continuation=continuation, | |
| ) | |
| elif isinstance(request, GeminiRequest): | |
| selected = native.stream_gemini( | |
| request, | |
| endpoint_context=endpoint, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=reasoning, | |
| model_info=lease.model.info, | |
| continuation=continuation, | |
| ) | |
| elif isinstance(request, MessagesRequest): | |
| selected = native.stream_messages( | |
| request, | |
| endpoint_context=endpoint, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=reasoning, | |
| model_info=lease.model.info, | |
| continuation=continuation, | |
| ) | |
| else: | |
| selected = native.stream_responses( | |
| request, | |
| endpoint_context=endpoint, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=reasoning, | |
| continuation=continuation, | |
| ) | |
| else: | |
| resolved = non_messages_reasoning( | |
| request, reasoning, lease.model | |
| ) | |
| transport = ( | |
| self._responses | |
| if lease.egress is CopilotEgress.RESPONSES | |
| else self._chat(lease.model) | |
| ) | |
| if isinstance(request, ChatRequest): | |
| selected = transport.stream_chat( | |
| request, | |
| input_tokens=input_tokens, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=resolved, | |
| endpoint_context=lease, | |
| continuation=continuation, | |
| ) | |
| elif isinstance(request, GeminiRequest): | |
| selected = transport.stream_gemini( | |
| request, | |
| input_tokens=input_tokens, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=resolved, | |
| endpoint_context=lease, | |
| continuation=continuation, | |
| ) | |
| elif isinstance(request, MessagesRequest): | |
| if lease.egress is CopilotEgress.RESPONSES: | |
| selected = self._responses.stream_messages( | |
| request, | |
| input_tokens=input_tokens, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=resolved, | |
| endpoint_context=lease, | |
| model_info=lease.model.info, | |
| can_disable_reasoning="none" | |
| in (lease.model.supported_efforts or ()), | |
| continuation=continuation, | |
| ) | |
| else: | |
| selected = self._chat(lease.model).stream_messages( | |
| request, | |
| input_tokens=input_tokens, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=resolved, | |
| endpoint_context=lease, | |
| model_info=lease.model.info, | |
| continuation=continuation, | |
| ) | |
| else: | |
| selected = transport.stream_responses( | |
| request, | |
| input_tokens=input_tokens, | |
| request_id=request_id, | |
| response_model=response_model, | |
| reasoning=resolved, | |
| endpoint_context=lease, | |
| continuation=continuation, | |
| ) | |
| while True: | |
| try: | |
| event = await _next_event(selected) | |
| except StopAsyncIteration: | |
| break | |
| yield event | |
| finally: | |
| await drain_owned( | |
| asyncio.create_task( | |
| _close_request( | |
| selected, | |
| http, | |
| active_error=sys.exception(), | |
| request_id=request_id, | |
| ) | |
| ) | |
| ) | |
| finally: | |
| async with self._condition: | |
| self._active -= 1 | |
| self._condition.notify_all() | |
| async def cleanup(self) -> None: | |
| if self._closed: | |
| return | |
| self._closing = True | |
| if self._cleanup_task is None or self._cleanup_task.done(): | |
| self._cleanup_task = asyncio.create_task(self._cleanup()) | |
| await drain_owned(self._cleanup_task) | |
| async def _cleanup(self) -> None: | |
| async with self._condition: | |
| await self._condition.wait_for(lambda: self._active == 0) | |
| results = await asyncio.gather( | |
| self._client.close(), | |
| self._messages_pool.aclose(), | |
| self._openai_pool.aclose(), | |
| return_exceptions=True, | |
| ) | |
| failures = [result for result in results if isinstance(result, Exception)] | |
| if failures: | |
| raise ExceptionGroup("Copilot HTTP cleanup failed", failures) | |
| self._chats.clear() | |
| self._closed = True | |
| async def _close_request( | |
| stream: AsyncIterator[StreamOutput] | None, | |
| client: httpx.AsyncClient | None, | |
| *, | |
| active_error: BaseException | None, | |
| request_id: str | None, | |
| ) -> None: | |
| try: | |
| if stream is not None: | |
| await close_provider_stream( | |
| stream, | |
| active_error=active_error, | |
| provider_name=PROVIDER_NAME, | |
| request_id=request_id, | |
| ) | |
| finally: | |
| if client is not None: | |
| await client.aclose() | |
| async def _endpoint_required() -> str: | |
| raise ExecutionFailure( | |
| FailureKind.UNAVAILABLE, | |
| 503, | |
| "Copilot inference requires a current account endpoint.", | |
| False, | |
| ) | |
| async def _advance(stream: AsyncIterator[StreamOutput]) -> StreamOutput: | |
| return await anext(stream) | |
| async def _next_event(stream: AsyncIterator[StreamOutput]) -> StreamOutput: | |
| # Cancel transport work once, then protect its response-close finally blocks | |
| # from repeated caller cancellation before releasing the account lease. | |
| task = asyncio.create_task(_advance(stream)) | |
| try: | |
| return await asyncio.shield(task) | |
| except asyncio.CancelledError: | |
| task.cancel() | |
| with suppress(Exception, asyncio.CancelledError): | |
| await drain_owned(task) | |
| raise | |