Spaces:
Running
Running
Download src/free_claude_code/api/routes.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 17.9 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/routes.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/api/routes.py
-
curl -L -o routes.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/routes.py
17.9 kB
| from __future__ import annotations | |
| """FastAPI route handlers.""" | |
| import json | |
| from collections.abc import Mapping | |
| from typing import Annotated, Any, cast | |
| from fastapi import APIRouter, Body, Depends, Header, HTTPException, Request, Response | |
| from fastapi.exceptions import RequestValidationError | |
| from loguru import logger | |
| from pydantic import ValidationError | |
| from free_claude_code.application.errors import ApplicationError, InvalidRequestError | |
| from free_claude_code.application.ports import ProviderResolver, RequestRuntimeLease | |
| from free_claude_code.application.routing import ModelRouter, supports_native_messages | |
| from free_claude_code.config.model_refs import parse_provider_type | |
| from free_claude_code.config.settings import Settings | |
| from free_claude_code.core.anthropic import ( | |
| MessagesRequest, | |
| NativeTokenCountRequest, | |
| TokenCountRequest, | |
| get_token_count, | |
| ) | |
| from free_claude_code.core.anthropic.native import ( | |
| NativeMessagesError, | |
| validate_messages_json, | |
| ) | |
| from free_claude_code.core.anthropic.passthrough import NativeMessagesRequest | |
| from free_claude_code.core.chat_completions.request import ChatRequest | |
| from free_claude_code.core.gemini import GeminiRequest | |
| from free_claude_code.core.json_types import JsonObject | |
| from free_claude_code.core.openai_responses import OpenAIResponsesRequest | |
| from free_claude_code.core.trace import trace_event | |
| from .dependencies import ( | |
| get_services, | |
| get_settings, | |
| require_anthropic_proxy_auth, | |
| require_gemini_proxy_auth, | |
| require_proxy_auth, | |
| resolve_provider, | |
| ) | |
| from .handlers import MessagesHandler, ResponsesHandler, TokenCountHandler | |
| from .handlers.chat import ChatHandler | |
| from .handlers.gemini import GeminiHandler | |
| from .inline_system_turns import ( | |
| normalize_supported_inline_system_turns, | |
| reject_inline_system_turns, | |
| ) | |
| from .model_catalog import ( | |
| ModelCatalogView, | |
| ModelsListResponse, | |
| build_models_list_response, | |
| build_muse_models_list_response, | |
| ) | |
| from .ports import ApiServices | |
| from .request_errors import ( | |
| ordinary_application_error_response, | |
| require_non_empty_messages, | |
| ) | |
| from .request_ids import get_request_id | |
| from .response_streams import bind_response_lifetime | |
| router = APIRouter() | |
| def _unique_json_fields(pairs: list[tuple[str, Any]]) -> dict[str, Any]: | |
| result: dict[str, Any] = {} | |
| for key, value in pairs: | |
| if key in result: | |
| raise ValueError(f"Duplicate JSON field: {key}") | |
| result[key] = value | |
| return result | |
| async def create_gemini_response( | |
| resource: str, | |
| request: Request, | |
| request_data: Annotated[dict[str, Any], Body()], | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_gemini_proxy_auth), | |
| ): | |
| try: | |
| json.loads(await request.body(), object_pairs_hook=_unique_json_fields) | |
| except ValueError as error: | |
| raise HTTPException(status_code=400, detail=str(error)) from error | |
| model, separator, action = resource.rpartition(":") | |
| if not separator or action not in {"generateContent", "streamGenerateContent"}: | |
| raise HTTPException(status_code=404, detail="Unknown Gemini generation method") | |
| if not model.strip() or any( | |
| not segment or segment in {".", ".."} or any(char.isspace() for char in segment) | |
| for segment in model.split("/") | |
| ): | |
| raise HTTPException(status_code=400, detail="Invalid model resource") | |
| streaming = action == "streamGenerateContent" | |
| alt = request.query_params.getlist("alt") | |
| if ( | |
| len(alt) > 1 | |
| or (streaming and alt != ["sse"]) | |
| or (not streaming and alt not in ([], ["json"])) | |
| ): | |
| raise HTTPException( | |
| status_code=400, | |
| detail="Streaming requires alt=sse; JSON generation accepts alt=json", | |
| ) | |
| if "model" in request_data: | |
| raise HTTPException(status_code=400, detail="Specify the model in the URL only") | |
| try: | |
| data = GeminiRequest.model_validate({**request_data, "model": model}) | |
| except ValidationError as error: | |
| raise RequestValidationError( | |
| [{**item, "loc": ("body", *item["loc"])} for item in error.errors()], | |
| body=request_data, | |
| ) from error | |
| lease = await services.requests.acquire() | |
| try: | |
| await lease.wait_for_token_estimation() | |
| handler = GeminiHandler( | |
| lease.settings, | |
| _provider_resolver(lease), | |
| generation_id=lease.generation_id, | |
| request_headers={ | |
| key: value | |
| for key, value in request.headers.items() | |
| if key.lower() not in {"authorization", "x-api-key", "x-goog-api-key"} | |
| }, | |
| model_info_lookup=lease.model_info, | |
| ) | |
| response = await handler.create( | |
| data, streaming=streaming, request_id=get_request_id(request) | |
| ) | |
| except BaseException: | |
| await lease.release() | |
| raise | |
| return await bind_response_lifetime(response, lease.release) | |
| def _provider_resolver(lease: RequestRuntimeLease) -> ProviderResolver: | |
| return lambda provider_type, api_key_number: resolve_provider( | |
| provider_type, api_key_number, lease=lease | |
| ) | |
| async def create_chat_completion( | |
| request: Request, | |
| request_data: ChatRequest, | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| lease = await services.requests.acquire() | |
| try: | |
| await lease.wait_for_token_estimation() | |
| handler = ChatHandler( | |
| lease.settings, | |
| _provider_resolver(lease), | |
| generation_id=lease.generation_id, | |
| request_headers=request.headers, | |
| model_info_lookup=lease.model_info, | |
| ) | |
| response = await handler.create( | |
| request_data, request_id=get_request_id(request) | |
| ) | |
| except BaseException: | |
| await lease.release() | |
| raise | |
| return await bind_response_lifetime(response, lease.release) | |
| async def probe_chat(_auth=Depends(require_proxy_auth)): | |
| return _probe_response("POST, HEAD, OPTIONS") | |
| async def _create_messages_response( | |
| services: ApiServices, | |
| request_data: MessagesRequest | JsonObject, | |
| *, | |
| request_id: str, | |
| request_headers: Mapping[str, str] | None = None, | |
| ) -> object: | |
| lease: RequestRuntimeLease | None = None | |
| try: | |
| lease = await services.requests.acquire() | |
| router = ModelRouter(lease.settings) | |
| raw = ( | |
| request_data.model_dump(mode="json", exclude_unset=True) | |
| if isinstance(request_data, MessagesRequest) | |
| else request_data | |
| ) | |
| messages = raw.get("messages") | |
| if not isinstance(messages, list): | |
| raise InvalidRequestError("messages must be an array") | |
| require_non_empty_messages(messages) | |
| model = raw.get("model") | |
| resolved = ( | |
| router.resolve(model) if isinstance(model, str) and model.strip() else None | |
| ) | |
| native = resolved is not None and supports_native_messages( | |
| resolved.primary.provider_id | |
| ) | |
| if native: | |
| try: | |
| native_request = NativeMessagesRequest(raw) | |
| except NativeMessagesError as error: | |
| raise InvalidRequestError(str(error)) from error | |
| else: | |
| if not isinstance(request_data, MessagesRequest): | |
| normalized = normalize_supported_inline_system_turns( | |
| raw, request_headers | |
| ) | |
| if normalized is not None: | |
| raw = normalized | |
| request_data = raw | |
| reject_inline_system_turns(raw, request_headers) | |
| try: | |
| request_data = MessagesRequest.model_validate(raw) | |
| except ValidationError as error: | |
| raise RequestValidationError( | |
| [ | |
| {**item, "loc": ("body", *item["loc"])} | |
| for item in error.errors() | |
| ], | |
| body=raw, | |
| ) from error | |
| await lease.wait_for_token_estimation() | |
| handler = MessagesHandler( | |
| lease.settings, | |
| web_tools=services.web_tools, | |
| provider_resolver=_provider_resolver(lease), | |
| token_counter=get_token_count, | |
| generation_id=lease.generation_id, | |
| request_headers=request_headers, | |
| model_info_lookup=lease.model_info, | |
| ) | |
| if native: | |
| assert resolved is not None | |
| response = await handler.create_native( | |
| router.route_native_messages(native_request, resolved), | |
| request_id=request_id, | |
| ) | |
| else: | |
| assert isinstance(request_data, MessagesRequest) | |
| response = await handler.create(request_data, request_id=request_id) | |
| except ApplicationError as exc: | |
| if lease is not None: | |
| await lease.release() | |
| return ordinary_application_error_response( | |
| exc, | |
| wire_api="messages", | |
| request_id=request_id, | |
| ) | |
| except BaseException: | |
| if lease is not None: | |
| await lease.release() | |
| raise | |
| assert lease is not None | |
| return await bind_response_lifetime(response, lease.release) | |
| async def _create_responses_response( | |
| services: ApiServices, | |
| request_data: OpenAIResponsesRequest, | |
| *, | |
| request_id: str, | |
| request_headers: Mapping[str, str] | None = None, | |
| ) -> object: | |
| lease: RequestRuntimeLease | None = None | |
| try: | |
| lease = await services.requests.acquire() | |
| await lease.wait_for_token_estimation() | |
| handler = ResponsesHandler( | |
| lease.settings, | |
| provider_resolver=_provider_resolver(lease), | |
| generation_id=lease.generation_id, | |
| request_headers=request_headers, | |
| model_info_lookup=lease.model_info, | |
| ) | |
| response = await handler.create(request_data, request_id=request_id) | |
| except ApplicationError as exc: | |
| if lease is not None: | |
| await lease.release() | |
| return ordinary_application_error_response( | |
| exc, | |
| wire_api="responses", | |
| request_id=request_id, | |
| ) | |
| except BaseException: | |
| if lease is not None: | |
| await lease.release() | |
| raise | |
| assert lease is not None | |
| return await bind_response_lifetime(response, lease.release) | |
| def _probe_response(allow: str) -> Response: | |
| return Response(status_code=204, headers={"Allow": allow}) | |
| async def create_message( | |
| request: Request, | |
| request_data: Annotated[dict[str, Any], Body()], | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_anthropic_proxy_auth), | |
| ): | |
| """Create a message (JSON by default; stream=true returns Anthropic SSE).""" | |
| return await _create_messages_response( | |
| services, | |
| cast(JsonObject, request_data), | |
| request_id=get_request_id(request), | |
| request_headers=request.headers, | |
| ) | |
| async def probe_messages(_auth=Depends(require_anthropic_proxy_auth)): | |
| return _probe_response("POST, HEAD, OPTIONS") | |
| async def create_response( | |
| request: Request, | |
| request_data: OpenAIResponsesRequest, | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| """Create an OpenAI Responses-compatible response through this proxy.""" | |
| return await _create_responses_response( | |
| services, | |
| request_data, | |
| request_id=get_request_id(request), | |
| request_headers=request.headers, | |
| ) | |
| async def probe_responses(_auth=Depends(require_proxy_auth)): | |
| return _probe_response("POST, HEAD, OPTIONS") | |
| async def count_tokens( | |
| request: Request, | |
| request_data: Annotated[dict[str, Any], Body()], | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_anthropic_proxy_auth), | |
| ): | |
| """Count tokens for a request.""" | |
| lease = await services.requests.acquire() | |
| try: | |
| model_router = ModelRouter(lease.settings) | |
| model = request_data.get("model") | |
| if isinstance(model, str) and not model.strip(): | |
| raise InvalidRequestError("Messages model must not be empty.") | |
| resolved = ( | |
| model_router.resolve(model) | |
| if isinstance(model, str) and model.strip() | |
| else None | |
| ) | |
| try: | |
| if resolved is not None and supports_native_messages( | |
| resolved.primary.provider_id | |
| ): | |
| validate_messages_json(request_data) | |
| counted = NativeTokenCountRequest.model_validate(request_data) | |
| else: | |
| normalized = normalize_supported_inline_system_turns( | |
| request_data, request.headers | |
| ) | |
| if normalized is None: | |
| reject_inline_system_turns(request_data, request.headers) | |
| counted = TokenCountRequest.model_validate( | |
| normalized if normalized is not None else request_data | |
| ) | |
| except NativeMessagesError as error: | |
| raise InvalidRequestError(str(error)) from error | |
| except ValidationError as error: | |
| raise RequestValidationError( | |
| [{**item, "loc": ("body", *item["loc"])} for item in error.errors()], | |
| body=request_data, | |
| ) from error | |
| await lease.wait_for_token_estimation() | |
| handler = TokenCountHandler( | |
| lease.settings, model_router=model_router, token_counter=get_token_count | |
| ) | |
| return handler.count( | |
| counted, request_id=get_request_id(request), resolved=resolved | |
| ) | |
| finally: | |
| await lease.release() | |
| async def probe_count_tokens(_auth=Depends(require_anthropic_proxy_auth)): | |
| return _probe_response("POST, HEAD, OPTIONS") | |
| async def root( | |
| settings: Settings = Depends(get_settings), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| return { | |
| "status": "ok", | |
| "provider": parse_provider_type(settings.model), | |
| "model": settings.model, | |
| } | |
| async def probe_root(): | |
| return _probe_response("GET, HEAD, OPTIONS") | |
| async def health(settings: Settings = Depends(get_settings)): | |
| """Health check endpoint — returns model configuration and key counts.""" | |
| import os | |
| def count_indexed_keys(prefix: str, max_idx: int = 20) -> int: | |
| return sum( | |
| 1 for i in range(1, max_idx) if os.environ.get(f"{prefix}_{i}", "").strip() | |
| ) | |
| return { | |
| "status": "healthy", | |
| "model_opus": settings.model_opus, | |
| "model_sonnet": settings.model_sonnet, | |
| "model_haiku": settings.model_haiku, | |
| "nvidia_indexed_keys": count_indexed_keys("NVIDIA_NIM_API_KEY"), | |
| "nvidia_legacy_keys": 1 if os.environ.get("NVIDIA_NIM_API_KEY", "").strip() else 0, | |
| "groq_indexed_keys": count_indexed_keys("GROQ_API_KEY"), | |
| "groq_legacy_keys": 0, | |
| } | |
| async def probe_health(): | |
| return _probe_response("GET, HEAD, OPTIONS") | |
| async def list_models( | |
| view: ModelCatalogView | None = None, | |
| x_fcc_model_view: ModelCatalogView | None = Header(default=None), | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| """List the model ids this proxy advertises to compatible clients.""" | |
| trace_event(stage="ingress", event="free_claude_code.api.models.list", source="api") | |
| snapshot = services.requests.catalog_snapshot() | |
| return build_models_list_response( | |
| snapshot.settings, | |
| snapshot, | |
| view=view or x_fcc_model_view or ModelCatalogView.CLAUDE, | |
| ) | |
| async def list_muse_models( | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| """List the direct Responses models expected by Muse Code.""" | |
| trace_event(stage="ingress", event="free_claude_code.api.models.list", source="api") | |
| snapshot = services.requests.catalog_snapshot() | |
| return build_muse_models_list_response(snapshot.settings, snapshot) | |
| async def stop_cli( | |
| services: ApiServices = Depends(get_services), | |
| _auth=Depends(require_proxy_auth), | |
| ): | |
| """Stop all CLI sessions and pending tasks.""" | |
| result = await services.tasks.stop_all() | |
| if result is None: | |
| raise HTTPException(status_code=503, detail="Messaging system not initialized") | |
| if result.source is not None: | |
| logger.info("STOP_CLI: source={} cancelled_count=N/A", result.source) | |
| return {"status": "stopped", "source": result.source} | |
| count = result.cancelled_count or 0 | |
| trace_event( | |
| stage="ingress", | |
| event="free_claude_code.api.cli.stop_via_messaging_workflow", | |
| source="api", | |
| cancelled_nodes=count, | |
| ) | |
| logger.info("STOP_CLI: source=messaging_workflow cancelled_count={}", count) | |
| return {"status": "stopped", "cancelled_count": count} | |