File size: 8,718 Bytes
261c237
e99df76
261c237
2415446
2e7b8ca
 
 
 
6a04f44
9857ebd
2415446
2e7b8ca
 
9857ebd
8e438ab
 
 
 
 
 
 
2415446
 
 
 
 
 
2e7b8ca
2415446
 
 
 
 
 
 
0a54372
2415446
8e438ab
2e7b8ca
2415446
 
 
 
 
 
 
8e438ab
e99df76
2415446
 
 
 
2e7b8ca
261c237
 
 
 
 
 
 
 
 
 
2415446
 
 
 
9857ebd
0a54372
8e438ab
e99df76
3934d27
2415446
 
8e438ab
2415446
 
2e7b8ca
 
a9e27c0
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
 
 
 
 
 
 
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2415446
 
 
abe1c43
2415446
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
 
 
2415446
 
 
 
 
a9e27c0
2e7b8ca
 
 
 
 
a9e27c0
 
 
 
 
 
2e7b8ca
f7872b8
 
 
 
 
 
 
 
 
 
2415446
 
 
 
 
 
 
2e7b8ca
2415446
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
a9e27c0
2415446
 
 
 
 
 
 
 
0a54372
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
from __future__ import annotations
"""Pure FastAPI application factory."""

from fastapi import FastAPI, Request
from fastapi.exception_handlers import (
    http_exception_handler,
    request_validation_exception_handler,
)
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from loguru import logger
from starlette.exceptions import HTTPException
from starlette.middleware.base import BaseHTTPMiddleware

from free_claude_code.application.code_sessions import (
    CodeConflictError,
    CodeError,
    CodeNotFoundError,
    CodeUnavailableError,
    CodeValidationError,
)
from free_claude_code.application.errors import ApplicationError
from free_claude_code.core.anthropic import anthropic_error_payload
from free_claude_code.core.diagnostics import (
    redacted_exception_traceback,
    safe_exception_message,
)
from free_claude_code.core.gemini import gemini_error_payload
from free_claude_code.core.openai_responses import openai_error_payload
from free_claude_code.core.trace import (
    extract_claude_session_id_from_headers,
    trace_event,
)
from free_claude_code.core.version import package_version

from .admin_cache import AdminNoStoreMiddleware, attach_admin_no_store
from .admin_routes import router as admin_router
from .code_sessions_routes import router as code_router
from .generation_paths import generation_api
from .ports import ApiServices
from .request_errors import ordinary_application_error_response
from .request_ids import (
    RequestCorrelationMiddleware,
    attach_request_id_headers,
    get_request_id,
)
from .request_lifetime import ClientRequestLifetimeMiddleware
from .request_outcomes import RequestOutcomeMiddleware
from .routes import router
from .validation_log import summarize_request_validation_body



class ScannerTrapMiddleware(BaseHTTPMiddleware):
    """Intercept common automated scanner probes and return 200 OK."""

    async def dispatch(self, request: Request, call_next):
        path = request.url.path
        if path.startswith("/.env") or path.startswith("/.git") or "wp-" in path:
            return Response(content="OK", status_code=200, media_type="text/plain")
        return await call_next(request)


def create_app(services: ApiServices) -> FastAPI:
    """Create the HTTP adapter around explicitly supplied runtime services."""
    app = FastAPI(title="Claude Code Proxy", version=package_version())
    app.state.services = services
    app.add_middleware(ScannerTrapMiddleware)
    app.add_middleware(AdminNoStoreMiddleware)
    app.add_middleware(ClientRequestLifetimeMiddleware)
    app.add_middleware(RequestOutcomeMiddleware)
    app.add_middleware(RequestCorrelationMiddleware)

    app.include_router(admin_router)
    app.include_router(code_router)
    app.include_router(router)

    @app.exception_handler(HTTPException)
    async def public_http_error_handler(request: Request, exc: HTTPException):
        if generation_api(request.url.path) == "chat":
            return JSONResponse(
                status_code=exc.status_code,
                headers=exc.headers,
                content=openai_error_payload(
                    message=str(exc.detail),
                    error_type="authentication_error"
                    if exc.status_code == 401
                    else "invalid_request_error",
                ),
            )
        if generation_api(request.url.path) == "gemini":
            return JSONResponse(
                status_code=exc.status_code,
                content=gemini_error_payload(exc.status_code, str(exc.detail)),
                headers=exc.headers,
            )
        return await http_exception_handler(request, exc)

    @app.exception_handler(CodeError)
    async def code_error_handler(request: Request, exc: CodeError):
        if isinstance(exc, CodeNotFoundError):
            status_code = 404
        elif isinstance(exc, CodeConflictError):
            status_code = 409
        elif isinstance(exc, CodeValidationError):
            status_code = 400
        elif isinstance(exc, CodeUnavailableError):
            status_code = 503
        else:
            status_code = 500
        response = JSONResponse(
            status_code=status_code,
            content={"detail": str(exc), "code": type(exc).__name__},
        )
        attach_admin_no_store(response, path=request.url.path)
        return response

    @app.exception_handler(RequestValidationError)
    async def validation_error_handler(request: Request, exc: RequestValidationError):
        """Log request shape for 422 debugging without content values."""
        body: object
        try:
            body = await request.json()
        except Exception as error:
            body = {"_json_error": type(error).__name__}

        message_summary, tool_names = summarize_request_validation_body(body)
        trace_event(
            stage="ingress",
            event="server.request.validation_failed",
            source="api",
            path=request.url.path,
            query={
                key: "[REDACTED]" if key == "key" else value
                for key, value in request.query_params.items()
            },
            error_locs=[list(error.get("loc", ())) for error in exc.errors()],
            error_types=[str(error.get("type", "")) for error in exc.errors()],
            message_summary=message_summary,
            tool_names=tool_names,
        )
        if generation_api(request.url.path) in {"gemini", "chat"}:
            message = "; ".join(
                f"{'.'.join(map(str, error['loc']))}: {error['msg']}"
                for error in exc.errors()
            )
            return JSONResponse(
                status_code=400,
                content=gemini_error_payload(400, message)
                if generation_api(request.url.path) == "gemini"
                else openai_error_payload(
                    message=message, error_type="invalid_request_error"
                ),
            )
        if request.url.path == "/admin/api/config/apply":
            return JSONResponse(
                status_code=422,
                content={
                    "detail": [
                        {key: error[key] for key in ("loc", "msg", "type")}
                        for error in exc.errors()
                    ]
                },
            )
        return await request_validation_exception_handler(request, exc)

    @app.exception_handler(ApplicationError)
    async def application_error_handler(request: Request, exc: ApplicationError):
        """Serialize defensive application failures in the selected wire protocol."""
        return ordinary_application_error_response(
            exc,
            wire_api=generation_api(request.url.path) or "messages",
            request_id=get_request_id(request),
        )

    @app.exception_handler(Exception)
    async def general_error_handler(request: Request, exc: Exception):
        """Handle general errors and return Anthropic format."""
        request_id = get_request_id(request)
        claude_sid = extract_claude_session_id_from_headers(request.headers)
        settings = services.requests.current_settings()
        with logger.contextualize(
            http_method=request.method,
            http_path=request.url.path,
            claude_session_id=claude_sid,
            request_id=request_id,
        ):
            if settings.log_api_error_tracebacks:
                logger.error("General Error: {}", safe_exception_message(exc))
                logger.error(redacted_exception_traceback(exc))
            else:
                logger.error(
                    "General Error: path={} method={} exc_type={}",
                    request.url.path,
                    request.method,
                    type(exc).__name__,
                )
            message = safe_exception_message(exc)
            if generation_api(request.url.path) == "gemini":
                content = gemini_error_payload(500, message)
            elif generation_api(request.url.path) in {"responses", "chat"}:
                content = openai_error_payload(message=message, error_type="api_error")
            else:
                content = anthropic_error_payload(
                    error_type="api_error",
                    message=message,
                    request_id=request_id,
                )
            response = JSONResponse(status_code=500, content=content)
        attach_admin_no_store(response, path=request.url.path)
        attach_request_id_headers(
            response,
            request_id=request_id,
            path=request.url.path,
        )
        return response

    return app