Spaces:
Running
Running
sync: upstream 8dfff832 (v6.18.5) + custom addons (KeyRotator, 401/403 rotation, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
2e7b8ca Download src/free_claude_code/providers/github_copilot/sdk.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 19.5 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/github_copilot/sdk.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/providers/github_copilot/sdk.py
-
curl -L -o sdk.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/providers/github_copilot/sdk.py
19.5 kB
| from __future__ import annotations | |
| """Official Copilot SDK boundary; never run SDK agent turns.""" | |
| import asyncio | |
| import re | |
| import tempfile | |
| import uuid | |
| from pathlib import Path | |
| from types import MappingProxyType | |
| from typing import Literal | |
| from urllib.parse import urlsplit | |
| import httpx | |
| from copilot import ( | |
| CapiSessionOptions, | |
| CopilotClient, | |
| CopilotSession, | |
| PermissionRequest, | |
| RuntimeConnection, | |
| ) | |
| from copilot.rpc import ( | |
| AdaptiveThinkingSupport, | |
| Model, | |
| ModelPolicyState, | |
| ModelsListRequest, | |
| PermissionDecisionReject, | |
| ProviderEndpoint, | |
| ProviderTransport, | |
| ProviderType, | |
| ProviderWireAPI, | |
| SessionProviderGetEndpointRequest, | |
| ) | |
| from copilot.session import PermissionInvocation | |
| from free_claude_code.application.model_metadata import ProviderModelInfo | |
| from free_claude_code.core.model_capabilities import ModelInputModality | |
| from free_claude_code.providers.anthropic_messages.request_policy import ( | |
| MessagesModelCapabilities, | |
| ) | |
| from free_claude_code.providers.endpoint_types import HttpEndpoint | |
| from free_claude_code.providers.model_listing import reasoning_capability_from_options | |
| from .lifecycle import drain_owned | |
| from .native_cli import COPILOT_CLI_VERSION, profile_environment, verified_cli_path | |
| from .types import ( | |
| CopilotEgress, | |
| CopilotEndpoint, | |
| CopilotIdentity, | |
| CopilotModel, | |
| CopilotUnavailable, | |
| ) | |
| SDK_RPC_TIMEOUT = 30.0 | |
| _HEADER_NAME = re.compile(r"[!#$%&'*+.^_`|~0-9A-Za-z-]+") | |
| def _deny_permission( | |
| _request: PermissionRequest, _invocation: PermissionInvocation | |
| ) -> PermissionDecisionReject: | |
| return PermissionDecisionReject(feedback="FCC owns tool execution.") | |
| async def _delete_session_record( | |
| client: CopilotClient, session_id: str, *, allow_absent: bool = True | |
| ) -> None: | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await client.delete_session(session_id) | |
| except Exception: | |
| # Endpoint-only sessions need not have a persisted record. Check this | |
| # exact owned UUID; neither error prose nor a failed lookup proves absence. | |
| if not allow_absent: | |
| raise | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| metadata = await client.get_session_metadata(session_id) | |
| if metadata is not None: | |
| raise | |
| class SdkRuntime: | |
| """Own a hidden official runtime with native authentication and inert sessions.""" | |
| def __init__(self) -> None: | |
| self._client: CopilotClient | None = None | |
| self._directory: tempfile.TemporaryDirectory[str] | None = None | |
| self._sessions: list[SdkSession] = [] | |
| self._pending_session_ids: set[str] = set() | |
| self._lock = asyncio.Lock() | |
| self._close_task: asyncio.Task[None] | None = None | |
| self._closing = False | |
| self._stopped = False | |
| async def start(self) -> None: | |
| async with self._lock: | |
| if self._closing: | |
| raise CopilotUnavailable("Copilot runtime has closed.") | |
| if self._client is not None: | |
| return | |
| env = profile_environment() | |
| path = await verified_cli_path(env) | |
| env["COPILOT_ALLOW_GET_PROVIDER_ENDPOINT"] = "true" | |
| directory = tempfile.TemporaryDirectory(prefix="fcc-copilot-") | |
| self._directory = directory | |
| try: | |
| client = CopilotClient( | |
| connection=RuntimeConnection.for_stdio( | |
| path=path, args=("--no-auto-update", "--disable-builtin-mcps") | |
| ), | |
| env=env, | |
| working_directory=directory.name, | |
| use_logged_in_user=True, | |
| mode="copilot-cli", | |
| log_level="error", | |
| ) | |
| self._client = client | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await client.start() | |
| status = await client.get_status() | |
| if status.version != COPILOT_CLI_VERSION: | |
| raise CopilotUnavailable( | |
| "Copilot runtime version changed. Reconnect with the supported CLI version." | |
| ) | |
| except BaseException: | |
| self._closing = True | |
| await drain_owned(asyncio.create_task(self._close_client())) | |
| raise | |
| def _running(self) -> CopilotClient: | |
| if self._client is None: | |
| raise CopilotUnavailable("Copilot runtime is not connected.") | |
| return self._client | |
| async def identity(self) -> CopilotIdentity | None: | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| status = await self._running().get_auth_status() | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not read Copilot profile status. Reconnect Copilot." | |
| ) from None | |
| if not status.isAuthenticated: | |
| return None | |
| if status.authType not in {"user", "gh-cli"}: | |
| raise CopilotUnavailable( | |
| "Copilot must use an existing GitHub profile. Sign in with copilot login --device-code." | |
| ) | |
| if not status.login or not status.host: | |
| raise CopilotUnavailable( | |
| "Copilot did not report the selected GitHub profile." | |
| ) | |
| host = urlsplit( | |
| status.host if "://" in status.host else f"https://{status.host}" | |
| ).hostname | |
| if not host: | |
| raise CopilotUnavailable("Copilot reported an invalid GitHub profile host.") | |
| return CopilotIdentity(host.lower(), status.login) | |
| async def models(self) -> tuple[CopilotModel, ...]: | |
| try: | |
| result = await self._running().rpc.models.list( | |
| ModelsListRequest(), timeout=SDK_RPC_TIMEOUT | |
| ) | |
| return tuple( | |
| _model(model) | |
| for model in result.models | |
| if model.id.strip() | |
| and model.id.strip().casefold() != "auto" | |
| and ( | |
| model.policy is None | |
| or model.policy.state is ModelPolicyState.ENABLED | |
| ) | |
| ) | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not discover Copilot subscription models. Check the selected account and its model policies." | |
| ) from None | |
| async def session(self, model_id: str) -> SdkSession: | |
| client = self._running() | |
| directory = self._directory | |
| if directory is None: | |
| raise CopilotUnavailable("Copilot working directory is unavailable.") | |
| session_id = str(uuid.uuid4()) | |
| config = Path(directory.name) / session_id | |
| config.mkdir() | |
| self._pending_session_ids.add(session_id) | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| session = await client.create_session( | |
| session_id=session_id, | |
| model=model_id, | |
| working_directory=directory.name, | |
| config_directory=str(config), | |
| available_tools=[], | |
| on_permission_request=_deny_permission, | |
| enable_config_discovery=False, | |
| skip_custom_instructions=True, | |
| custom_agents_local_only=True, | |
| enable_file_hooks=False, | |
| enable_on_demand_instruction_discovery=False, | |
| enable_host_git_operations=False, | |
| enable_skills=False, | |
| included_builtin_skills=[], | |
| request_extensions=False, | |
| enable_session_store=False, | |
| infinite_sessions={"enabled": False}, | |
| memory={"enabled": False}, | |
| skip_embedding_retrieval=True, | |
| embedding_cache_storage="in-memory", | |
| mcp_oauth_token_storage="in-memory", | |
| enable_session_telemetry=False, | |
| capi=CapiSessionOptions(enable_web_socket_responses=False), | |
| ) | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not open a Copilot endpoint session. Reconnect Copilot." | |
| ) from None | |
| owned = SdkSession(client, session, model_id, session_id) | |
| self._sessions.append(owned) | |
| self._pending_session_ids.discard(session_id) | |
| return owned | |
| async def close(self) -> None: | |
| self._closing = True | |
| if self._close_task is None or self._close_task.done(): | |
| self._close_task = asyncio.create_task(self._close()) | |
| await drain_owned(self._close_task) | |
| async def _close(self) -> None: | |
| async with self._lock: | |
| await self._close_client() | |
| async def _close_client(self) -> None: | |
| client = self._client | |
| if client is None: | |
| if self._directory is not None: | |
| self._directory.cleanup() | |
| self._directory = None | |
| return | |
| records_only = self._stopped | |
| try: | |
| # A prior shutdown can stop the process while record deletion fails. | |
| # Retain that ownership and reconnect only to retry our own deletions. | |
| if self._stopped: | |
| self._stopped = False | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await client.start() | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not reconnect Copilot to remove an FCC session record. Retry disconnect to finish cleanup." | |
| ) from None | |
| failed_sessions: list[SdkSession] = [] | |
| for session in self._sessions: | |
| try: | |
| await session.close(runtime_stopped=records_only) | |
| except Exception: | |
| failed_sessions.append(session) | |
| self._sessions = failed_sessions | |
| # A cancelled create RPC can still finish remotely. Do not accept | |
| # absence until the process that could create its record has stopped. | |
| for session_id in tuple(self._pending_session_ids) if records_only else (): | |
| try: | |
| await _delete_session_record(client, session_id) | |
| self._pending_session_ids.discard(session_id) | |
| except Exception: | |
| pass | |
| finally: | |
| # start() may fail after spawning a process. Stop that partial runtime | |
| # too, without discarding record IDs still owned by this adapter. | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await client.stop() | |
| except Exception: | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await client.force_stop() | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not stop the Copilot runtime. Retry disconnect to finish cleanup." | |
| ) from None | |
| self._stopped = True | |
| if self._pending_session_ids and not records_only: | |
| # Reconnect solely to clean known UUIDs after their writer is gone. | |
| await self._close_client() | |
| return | |
| if self._sessions or self._pending_session_ids: | |
| raise CopilotUnavailable( | |
| "Copilot stopped, but an FCC session record could not be removed. Retry disconnect to finish cleanup." | |
| ) | |
| self._client = None | |
| if self._directory is not None: | |
| self._directory.cleanup() | |
| self._directory = None | |
| class SdkSession: | |
| def __init__( | |
| self, | |
| client: CopilotClient, | |
| session: CopilotSession, | |
| model_id: str, | |
| session_id: str, | |
| ) -> None: | |
| self._client = client | |
| self._session = session | |
| self._model_id = model_id | |
| self._session_id = session_id | |
| self._closed = False | |
| self._disconnected = False | |
| self._close_task: asyncio.Task[None] | None = None | |
| async def endpoint(self) -> CopilotEndpoint: | |
| if self._closed: | |
| raise CopilotUnavailable("Copilot endpoint session is closed.") | |
| try: | |
| endpoint = await self._session.rpc.provider.get_endpoint( | |
| SessionProviderGetEndpointRequest(model_id=self._model_id), | |
| timeout=SDK_RPC_TIMEOUT, | |
| ) | |
| return _endpoint(endpoint, self._model_id) | |
| except CopilotUnavailable: | |
| raise | |
| except Exception: | |
| raise CopilotUnavailable( | |
| "Could not resolve this model's Copilot endpoint. Refresh models or reconnect Copilot." | |
| ) from None | |
| async def close(self, *, runtime_stopped: bool = False) -> None: | |
| if runtime_stopped: | |
| # Only SdkRuntime, after stopping the owning process, supplies this. | |
| self._disconnected = True | |
| if self._closed: | |
| return | |
| if self._close_task is None or self._close_task.done(): | |
| self._close_task = asyncio.create_task(self._close()) | |
| await drain_owned(self._close_task) | |
| async def _close(self) -> None: | |
| if not self._disconnected: | |
| try: | |
| async with asyncio.timeout(SDK_RPC_TIMEOUT): | |
| await self._session.disconnect() | |
| self._disconnected = True | |
| except Exception: | |
| # Deletion and runtime stop also release server-side ownership. | |
| pass | |
| await _delete_session_record( | |
| self._client, self._session_id, allow_absent=self._disconnected | |
| ) | |
| self._closed = True | |
| def _model(model: Model) -> CopilotModel: | |
| limits = model.capabilities.limits | |
| supports = model.capabilities.supports | |
| adaptive: Literal["unsupported", "optional", "required"] | None = None | |
| if supports is not None and supports.adaptive_thinking is not None: | |
| modes: dict[ | |
| AdaptiveThinkingSupport, Literal["unsupported", "optional", "required"] | |
| ] = { | |
| AdaptiveThinkingSupport.UNSUPPORTED: "unsupported", | |
| AdaptiveThinkingSupport.OPTIONAL: "optional", | |
| AdaptiveThinkingSupport.REQUIRED: "required", | |
| } | |
| adaptive = modes[supports.adaptive_thinking] | |
| vision = supports.vision if supports is not None else None | |
| effort_support = supports.reasoning_effort if supports is not None else None | |
| efforts = ( | |
| tuple(model.supported_reasoning_efforts) | |
| if model.supported_reasoning_efforts is not None | |
| else None | |
| ) | |
| output = limits.max_output_tokens if limits is not None else None | |
| context = limits.max_context_window_tokens if limits is not None else None | |
| info = ProviderModelInfo( | |
| model_id=model.id, | |
| reasoning_capability=reasoning_capability_from_options( | |
| {"supported_efforts": efforts} | |
| ), | |
| supports_thinking=True | |
| if effort_support is True or adaptive in {"optional", "required"} | |
| else None, | |
| input_modalities=frozenset({ModelInputModality.TEXT, ModelInputModality.IMAGE}) | |
| if vision is True | |
| else frozenset({ModelInputModality.TEXT}) | |
| if vision is False | |
| else None, | |
| context_window_tokens=context if context is not None and context > 0 else None, | |
| max_output_tokens=output if output is not None and output > 0 else None, | |
| ) | |
| return CopilotModel( | |
| info, | |
| MessagesModelCapabilities( | |
| max_output_tokens=info.max_output_tokens, | |
| adaptive_thinking=adaptive, | |
| supports_output_effort=effort_support, | |
| supported_efforts=efforts, | |
| supports_vision=vision, | |
| ), | |
| efforts, | |
| model.default_reasoning_effort, | |
| ) | |
| def _endpoint(endpoint: ProviderEndpoint, model_id: str) -> CopilotEndpoint: | |
| if endpoint.transport not in {None, ProviderTransport.HTTP}: | |
| raise CopilotUnavailable( | |
| "This Copilot model requires an unsupported upstream transport." | |
| ) | |
| if endpoint.type is ProviderType.ANTHROPIC and endpoint.wire_api is None: | |
| egress = CopilotEgress.MESSAGES | |
| elif endpoint.type is ProviderType.OPENAI: | |
| egress = ( | |
| CopilotEgress.RESPONSES | |
| if endpoint.wire_api is ProviderWireAPI.RESPONSES | |
| else CopilotEgress.CHAT | |
| ) | |
| else: | |
| raise CopilotUnavailable( | |
| "This Copilot model requires an unsupported provider endpoint." | |
| ) | |
| try: | |
| url = urlsplit(endpoint.base_url) | |
| valid_url = ( | |
| url.scheme == "https" | |
| and bool(url.hostname) | |
| and url.username is None | |
| and url.password is None | |
| and not url.query | |
| and not url.fragment | |
| and not any( | |
| character.isspace() or ord(character) < 32 | |
| for character in endpoint.base_url | |
| ) | |
| and (url.port is None or url.port > 0) | |
| ) | |
| except ValueError: | |
| valid_url = False | |
| if not valid_url: | |
| raise CopilotUnavailable("Copilot returned an invalid HTTPS endpoint.") | |
| headers = httpx.Headers(encoding="ascii") | |
| for key, value in endpoint.headers.items(): | |
| if _HEADER_NAME.fullmatch(key) is None or any( | |
| character in value for character in "\r\n\0" | |
| ): | |
| raise CopilotUnavailable("Copilot returned invalid endpoint headers.") | |
| try: | |
| headers[key] = value | |
| except (UnicodeError, ValueError): | |
| raise CopilotUnavailable( | |
| "Copilot returned invalid endpoint headers." | |
| ) from None | |
| expires = None | |
| token = endpoint.session_token | |
| if token is not None: | |
| if ( | |
| token.model not in {None, model_id} | |
| or not token.token | |
| or _HEADER_NAME.fullmatch(token.header) is None | |
| or any(character in token.token for character in "\r\n\0") | |
| ): | |
| raise CopilotUnavailable( | |
| "Copilot returned an invalid or differently bound session token." | |
| ) | |
| try: | |
| headers[token.header] = token.token | |
| except (UnicodeError, ValueError): | |
| raise CopilotUnavailable( | |
| "Copilot returned an invalid session token." | |
| ) from None | |
| if token.expires_at is not None: | |
| if token.expires_at.tzinfo is None: | |
| raise CopilotUnavailable( | |
| "Copilot returned a session expiry without a time zone." | |
| ) | |
| expires = token.expires_at.timestamp() | |
| if endpoint.api_key is not None: | |
| if not endpoint.api_key or any( | |
| character in endpoint.api_key for character in "\r\n\0" | |
| ): | |
| raise CopilotUnavailable("Copilot returned an invalid endpoint credential.") | |
| try: | |
| endpoint.api_key.encode("ascii") | |
| except UnicodeError: | |
| raise CopilotUnavailable( | |
| "Copilot returned an invalid endpoint credential." | |
| ) from None | |
| return CopilotEndpoint( | |
| egress, | |
| HttpEndpoint( | |
| endpoint.base_url.rstrip("/"), | |
| MappingProxyType(dict(headers.items())), | |
| endpoint.api_key, | |
| ), | |
| expires, | |
| ) | |