dheraingoud's picture
sync: upstream 8dfff832 (v6.18.5) + custom addons (KeyRotator, 401/403 rotation, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
2e7b8ca
Raw History Blame Contribute Delete
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,
)